@effected/images 0.6.0 → 0.6.1

package/ImageBackendError.js

@@ -1,11 +1,7 @@
+import { causeMessage } from "./internal/causeMessage.js";
 import { Schema } from "effect";
 
 // src/ImageBackendError.ts
-const causeMessage = (cause) => {
-	let current = cause;
-	for (let depth = 0; depth < 8 && current instanceof Error && current.cause instanceof Error; depth++) current = current.cause;
-	return current instanceof Error ? current.message : String(current);
-};
 /**
 * An image backend read or write failed.
 *
@@ -33,7 +29,9 @@ var ImageBackendError = class extends Schema.TaggedError()("ImageBackendError",
 	cause: Schema.Defect()
 }) {
 	get message() {
-		return `Image backend ${this.operation} failed for key "${this.key}" (${this.reason}): ${causeMessage(this.cause)}`;
+		const summary = `Image backend ${this.operation} failed for key "${this.key}" (${this.reason})`;
+		const detail = causeMessage(this.cause);
+		return detail === void 0 ? summary : `${summary}: ${detail}`;
 	}
 };
 

package/internal/causeMessage.js

@@ -0,0 +1,39 @@
+import { Predicate } from "effect";
+
+// src/internal/causeMessage.ts
+/** How many nodes of a cause chain the walk reads before stopping, so a cyclic chain cannot spin. */
+const CAUSE_DEPTH = 8;
+/** The message a single node carries: a thrown string, or a non-empty string `message` property. */
+const messageAt = (node) => {
+	const text = Predicate.isString(node) ? node : Predicate.hasProperty(node, "message") && Predicate.isString(node.message) ? node.message : void 0;
+	return text === void 0 || text.trim() === "" ? void 0 : text;
+};
+/**
+* Every distinct non-empty message a preserved cause chain carries, nearest
+* first and joined with `: `, or `undefined` when nothing along it has one.
+*
+* A `Schema.Defect()` field holds whatever was thrown, so the read is guarded
+* rather than assumed: `Predicate.hasProperty` + `Predicate.isString` accepts
+* an `Error`, a cross-realm `Error` that fails `instanceof`, a plain
+* `{ message }` object and a thrown string alike. An empty or whitespace-only
+* message counts as none. The walk follows `cause` links because a wrapper's
+* text is often the generic summary and the driver's text underneath is the
+* actionable detail, yet a wrapper that composes its own context must not
+* lose it either; so nothing is dropped, and a deeper text the nearer one
+* already contains is not repeated. The walk is bounded, so a cycle terminates.
+*/
+const causeMessage = (cause) => {
+	let message;
+	let node = cause;
+	for (let depth = 0; depth < CAUSE_DEPTH && node !== void 0 && node !== null; depth++) {
+		const text = messageAt(node);
+		if (text !== void 0) {
+			if (message === void 0 || text.includes(message)) message = text;
+			else if (!message.includes(text)) message = `${message}: ${text}`;
+		}
+		node = Predicate.hasProperty(node, "cause") ? node.cause : void 0;
+	}
+	return message;
+};
+
+export { causeMessage };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/images",
-	"version": "0.6.0",
+	"version": "0.6.1",
 	"private": false,
 	"description": "Image facts (format, MIME type, dimensions) from bytes, and a generated-image cache, for Effect.",
 	"keywords": [