@systemfsoftware/stryker-js-instrumenter 8.0.1 → 8.0.2

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @systemfsoftware/stryker-js-instrumenter
 
+## 8.0.2
+
+### Patch Changes
+
+- Exported declarations that previously took `unknown` now take a defaulted type parameter: calls that omit the type argument are unchanged, and calls that were previously rejected for passing an unconstrained value are accepted. No runtime behaviour changes.
+
 ## 8.0.1
 
 ### Patch Changes

package/dist/index.d.mts

@@ -2,7 +2,7 @@ import * as Effect from 'effect/Effect';
 import * as S from 'effect/Schema';
 import { YieldableError } from 'effect/Cause';
 
-export declare const causeText: (cause: unknown, depth: number) => string | undefined;
+export declare const causeText: <A = unknown>(cause: A, depth: number) => string | undefined;
 
 export declare interface Coverage {
     readonly static: CoverageData;
@@ -31,7 +31,7 @@ export declare const ERROR_CODES: Readonly<{
     NoSuchFileOrDirectory: 'ENOENT';
 }>;
 
-export declare function errorToString(error: unknown): string;
+export declare function errorToString<A = unknown>(error: A): string;
 
 declare interface File_2 extends FileDescription {
     name: string;

package/dist/index.mjs

@@ -542,24 +542,29 @@ const COMMENT_KEYS = /* @__PURE__ */ new Set(["leadingComments", "trailingCommen
 function isCommentKey(key) {
 	return typeof key === "string" && COMMENT_KEYS.has(key);
 }
+function walkTraverse(root, stack, visitors) {
+	walk(walkableNode(root), {
+		enter(node, _parent, context) {
+			readPath(stack, node, this, context, visitors);
+		},
+		leave(_node, _parent, context) {
+			closePath(stack, context, visitors);
+		}
+	});
+}
+const toTraverseError = (error) => error instanceof Error ? error : new Error("Traversal failed", { cause: error });
+const handleTraverseError = (error) => {
+	const err = toTraverseError(error);
+	if (!S.is(TraversalStopped)(err)) throw err;
+};
 function traverse(root, visitors) {
 	const stack = [];
 	try {
-		walk(walkableNode(root), {
-			enter(node, _parent, context) {
-				readPath(stack, node, this, context, visitors);
-			},
-			leave(_node, _parent, context) {
-				closePath(stack, context, visitors);
-			}
-		});
+		walkTraverse(root, stack, visitors);
 	} catch (error) {
-		rethrowUnlessStopped(error);
+		handleTraverseError(error);
 	}
 }
-const rethrowUnlessStopped = (error) => {
-	if (!S.is(TraversalStopped)(error)) throw error;
-};
 const readPath = (stack, node, controls, context, visitors) => {
 	if (isCommentKey(context.key)) return;
 	const path = createPath(node, parentOf(stack), controls, context);
@@ -627,7 +632,7 @@ function writeInto(parent, key, index, replacement) {
 	writeAtKey(parent, key, index, replacement);
 }
 function writeAtKey(parent, key, index, replacement) {
-	Match.value(key).pipe(Match.when(Predicate.isString, (slot) => writeAtSlot(parent, slot, index, replacement)), Match.orElse(() => void 0));
+	if (Predicate.isString(key)) writeAtSlot(parent, key, index, replacement);
 }
 function writeAtSlot(parent, key, index, replacement) {
 	Match.value(index).pipe(Match.when(Match.null, () => overwrite(parent, key, replacement)), Match.orElse((position) => writeElement(parent[key], position, replacement)));
@@ -713,17 +718,16 @@ function isRangedBaseNode(value) {
 function isNonEmptyArray(value) {
 	return Array.isArray(value) && value.length > 0;
 }
-function hasField(value, key) {
-	return isPlainRecord(value) && key in value;
+function hasContentField(value) {
+	return isPlainRecord(value) && "content" in value;
 }
-function hasContent(value) {
-	return hasField(value, "content");
-}
-function hasHtml(value) {
-	return hasField(value, "html");
+function hasHtmlField(value) {
+	return isPlainRecord(value) && "html" in value;
 }
+const readRecordField = (record, key) => record[key];
 function fieldOf$1(value, key) {
-	return Match.value(value).pipe(Match.when(isPlainRecord, (record) => record[key]), Match.orElse(() => void 0));
+	if (!isPlainRecord(value)) return void 0;
+	return readRecordField(value, key);
 }
 function appendIfDefined(values, value) {
 	if (value !== void 0) values.push(value);
@@ -998,12 +1002,12 @@ function isTextRange(value) {
 function isTemplateExpressionTag(value) {
 	return isTypedRecord(value) && TEMPLATE_EXPRESSION_TYPES[value["type"]] === true;
 }
-/**
-* The first child of a `<script>` element node. A template `<script>` tag
-* carries its code as that single `Text` child.
-*/
+const firstChild = (element) => {
+	const children = element["children"];
+	return isNonEmptyArray(children) ? Option.getOrUndefined(Arr.head(children)) : void 0;
+};
 function scriptChild(node) {
-	return Match.value(node).pipe(Match.when(isScriptElement, (element) => Match.value(element["children"]).pipe(Match.when(isNonEmptyArray, (values) => Option.getOrUndefined(Arr.head(values))), Match.orElse(() => void 0))), Match.orElse(() => void 0));
+	return isScriptElement(node) ? firstChild(node) : void 0;
 }
 function tryGetScriptRangeFromElement(node) {
 	return Match.value(scriptChild(node)).pipe(Match.when(isTextRange, (range) => ({
@@ -1013,14 +1017,14 @@ function tryGetScriptRangeFromElement(node) {
 	})), Match.orElse(() => void 0));
 }
 function templateExpressionRange(node) {
-	return Match.value(node).pipe(Match.when(isTemplateExpressionTag, (tag) => rangedExpressionOf(tag["expression"])), Match.orElse(() => void 0));
+	return isTemplateExpressionTag(node) ? rangedExpressionOf(node["expression"]) : void 0;
 }
 function rangedExpressionOf(payload) {
-	return Match.value(payload).pipe(Match.when(isRangedBaseNode, (expression) => ({
-		start: expression.start,
-		end: expression.end,
+	if (isRangedBaseNode(payload)) return {
+		start: payload.start,
+		end: payload.end,
 		isExpression: true
-	})), Match.orElse(() => void 0));
+	};
 }
 /**
 * Allow instrumentation of Svelte 5 projects without dropping support for Svelte 4.
@@ -1032,9 +1036,10 @@ const loadWalker = (version, fileName) => Match.value(isAtLeast(version, SVELTE_
 * The specifier is chosen at run time and both modules are optional peers of
 * this package, so neither can be a static import.
 */
+const findWalker = (module) => isRecordWithWalk(module) ? module.walk : void 0;
 const loadWalkerModule = (specifier, fileName, cause) => Effect.gen(function* () {
 	const module = yield* Effect.promise(() => import(specifier));
-	const walk = Match.value(module).pipe(Match.when(isRecordWithWalk, (record) => record.walk), Match.orElse(() => void 0));
+	const walk = findWalker(module);
 	if (walk === void 0) return yield* SvelteWalkerNotFound.make({
 		fileName,
 		cause
@@ -1109,29 +1114,31 @@ function getTemplateScriptRanges(ast, walker) {
 	return ranges;
 }
 function htmlRootOf(ast) {
-	return Match.value(ast).pipe(Match.when(hasHtml, (record) => record["html"]), Match.orElse(() => {
-		throw new Error("Svelte AST without html");
-	}));
+	if (!hasHtmlField(ast)) throw new Error("Svelte AST without html");
+	return ast["html"];
 }
 function instanceScriptRange(ast) {
-	return Match.value(fieldOf$1(ast, "instance")).pipe(Match.when(hasContent, (instance) => scriptContentRange(instance["content"], INSTANCE_RANGE_MISSING)), Match.orElse(() => void 0));
+	const record = contentFieldOf(fieldOf$1(ast, "instance"));
+	return record === void 0 ? void 0 : scriptContentRange(record["content"], INSTANCE_RANGE_MISSING);
 }
 function scriptContentRange(content, missingRange) {
-	return Match.value(content).pipe(Match.when(isRange, (range) => ({
-		start: range.start,
-		end: range.end,
+	if (isRange(content)) return {
+		start: content.start,
+		end: content.end,
 		isExpression: false
-	})), Match.orElse(() => {
-		throw new Error(missingRange);
-	}));
+	};
+	throw new Error(missingRange);
 }
 function getModuleScriptRange(svelteAst) {
 	return Match.value(fieldOf$1(svelteAst, "module")).pipe(Match.when(void 0, () => void 0), Match.when(null, () => void 0), Match.orElse((block) => moduleBlockRange(block)));
 }
+function contentFieldOf(value) {
+	return Option.getOrUndefined(Option.filter(Option.fromNullishOr(value), hasContentField));
+}
 function moduleBlockRange(block) {
-	return Match.value(block).pipe(Match.when(hasContent, (record) => scriptContentRange(record["content"], MODULE_RANGE_MISSING)), Match.orElse(() => {
-		throw new Error(MODULE_RANGE_MISSING);
-	}));
+	const record = contentFieldOf(block);
+	if (record === void 0) throw new Error(MODULE_RANGE_MISSING);
+	return scriptContentRange(record["content"], MODULE_RANGE_MISSING);
 }
 /**
 * Remaps script locations back to the original places using the script map
@@ -3331,16 +3338,19 @@ function literalWithoutRegex(node) {
 	return valueLiteralText(node.value);
 }
 function valueLiteralText(value) {
-	switch (typeof value) {
-		case "string": return JSON.stringify(value);
-		case "number": return String(value);
-		case "boolean": return String(value);
-		case "bigint": return `${value}n`;
-		case "symbol":
-		case "undefined":
-		case "object":
-		case "function": return "null";
-	}
+	if (typeof value === "string") return JSON.stringify(value);
+	return nonStringLiteralText(value);
+}
+function nonStringLiteralText(value) {
+	if (typeof value === "number") return String(value);
+	return booleanOrBigintText(value);
+}
+function booleanOrBigintText(value) {
+	if (typeof value === "boolean") return String(value);
+	return bigintText(value);
+}
+function bigintText(value) {
+	return typeof value === "bigint" ? `${value}n` : "null";
 }
 function flagText(present, text) {
 	switch (Boolean(present)) {
@@ -3394,13 +3404,12 @@ const HASHBANG_FIELDS = {
 function isHashbang(value) {
 	return Predicate.isObject(value) && Object.entries(HASHBANG_FIELDS).every(([key, accepts]) => accepts(value[key]));
 }
-const hashbangOf = (root) => {
-	const hashbang = Reflect.get(root, "hashbang");
-	if (!isHashbang(hashbang)) return null;
-	return hashbang;
-};
-const jsPrint = (file) => printProgram(file.root, { hashbang: hashbangOf(file.root) });
-const tsPrint = (file) => printProgram(file.root, { hashbang: hashbangOf(file.root) });
+const toHashbang = (hashbang) => isHashbang(hashbang) ? hashbang : null;
+function getHashbang(root) {
+	return toHashbang("hashbang" in root ? root.hashbang : null);
+}
+const jsPrint = (file) => printProgram(file.root, { hashbang: getHashbang(file.root) });
+const tsPrint = (file) => printProgram(file.root, { hashbang: getHashbang(file.root) });
 function getScriptStart$1(script) {
 	const span = spanOf(script.root);
 	if (span === void 0) throw new Error("Script AST root without start");
@@ -3467,9 +3476,14 @@ function normalizeFileName(fileName) {
 }
 const hasText = (value) => Predicate.isString(value) && value.length > 0;
 const textIfNonEmpty = (value) => Option.getOrUndefined(Option.filter(Option.fromUndefinedOr(value), hasText));
-const fieldOf = (value, key) => Match.value(key in value).pipe(Match.when(true, () => {
-	return Reflect.get(value, key);
-}), Match.orElse(() => void 0));
+function readFieldOf(record, key) {
+	return record[key];
+}
+const hasFieldIn = (value, key) => key in value;
+const fieldOf = (value, key) => {
+	if (!hasFieldIn(value, key)) return;
+	return readFieldOf(value, key);
+};
 const hasStringCode = (error) => Match.value(fieldOf(error, "code")).pipe(Match.when(Match.string, () => true), Match.orElse(() => false));
 function isErrnoException(error) {
 	return Match.value(error).pipe(Match.when(Match.instanceOf(Error), hasStringCode), Match.orElse(() => false));
@@ -3494,7 +3508,7 @@ const isNonPlaceholderText = (text) => Match.value({
 	isPlaceholder: false
 }, () => true), Match.orElse(() => false));
 const isUsableText = (value) => Match.value(value).pipe(Match.when(Match.string, isNonPlaceholderText), Match.orElse(() => false));
-const usableText = (value) => Match.value(value).pipe(Match.when(isUsableText, (text) => text), Match.orElse(() => ""));
+const usableText = (value) => isUsableText(value) ? value : "";
 const objectToStringText = (value) => Match.value(fieldOf(value, "toString")).pipe(Match.when(Match.instanceOf(Function), (callable) => {
 	try {
 		return usableText(Reflect.apply(callable, value, []));
@@ -3503,9 +3517,19 @@ const objectToStringText = (value) => Match.value(fieldOf(value, "toString")).pi
 	}
 }), Match.orElse(() => ""));
 const isObjectType = (cause) => typeof cause === "object";
-const toStringText = (error) => Match.value(error).pipe(Match.when(Match.null, () => ""), Match.when(isObjectType, (value) => objectToStringText(value)), Match.orElse(() => ""));
-const stringifyRest = (error) => Match.value(jsonText(error)).pipe(Match.when(hasText, (json) => json), Match.orElse(() => toStringText(error)));
-const stringifyNonError = (error) => Match.value(error).pipe(Match.when(Match.string, (text) => text), Match.when(isJsonPrimitive, (primitive) => JSON.stringify(primitive)), Match.orElse(() => stringifyRest(error)));
+const isNonNullObjectType = (error) => error !== null && isObjectType(error);
+const toStringText = (error) => isNonNullObjectType(error) ? objectToStringText(error) : "";
+const stringifyRest = (error) => {
+	const json = jsonText(error);
+	return hasText(json) ? json : toStringText(error);
+};
+function primitiveJsonOf(error) {
+	return isJsonPrimitive(error) ? JSON.stringify(error) : void 0;
+}
+const stringifyNonError = (error) => typeof error === "string" ? error : nonStringTextOf(error);
+function nonStringTextOf(error) {
+	return primitiveJsonOf(error) ?? stringifyRest(error);
+}
 const errorText = (error) => Match.value(error).pipe(Match.when(isErrnoException, formatErrnoException), Match.orElse(() => formatError(error)));
 function errorToString(error) {
 	return Match.value(error).pipe(Match.when(isEmptyError, () => ""), Match.when(Match.instanceOf(Error), errorText), Match.orElse(() => stringifyNonError(error)));
@@ -3519,7 +3543,18 @@ const errorMessage = (error) => Match.value(error.message.length > 0).pipe(Match
 const errorMessageOrTag = (value) => Match.value(value).pipe(Match.when(Match.instanceOf(Error), errorMessage), Match.orElse(() => tagOf(value)));
 const messageText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "message"))).pipe(Match.when(hasText, (message) => message), Match.orElse(() => errorMessageOrTag(value)));
 const ownCauseText = (value) => Match.value(textIfNonEmpty(fieldOf(value, "reason"))).pipe(Match.when(hasText, (reason) => reason), Match.orElse(() => messageText(value)));
-const causeText = (cause, depth) => Match.value(cause).pipe(Match.when(() => depth > 4, () => void 0), Match.when(Match.undefined, () => void 0), Match.when(Match.null, () => void 0), Match.when(Match.string, textIfNonEmpty), Match.when(isObjectType, (value) => textWithNested(ownCauseText(value), causeText(fieldOf(value, "cause"), depth + 1))), Match.orElse(() => void 0));
+const isPastDepth = (depth) => depth > 4;
+const isMissingCause = (cause) => cause === void 0 || cause === null;
+const causeText = (cause, depth) => isPastDepth(depth) ? void 0 : missingCauseTextOf(cause, depth);
+function missingCauseTextOf(cause, depth) {
+	return isMissingCause(cause) ? void 0 : causeTextOfValue(cause, depth);
+}
+function causeTextOfValue(cause, depth) {
+	return typeof cause === "string" ? textIfNonEmpty(cause) : objectCauseTextOf(cause, depth);
+}
+function objectCauseTextOf(cause, depth) {
+	return isObjectType(cause) ? textWithNested(ownCauseText(cause), causeText(fieldOf(cause, "cause"), depth + 1)) : void 0;
+}
 //#endregion
 //#region src/Mutator.ts
 /**
@@ -3809,9 +3844,10 @@ function withOperator(node, operator) {
 function mutantsWhen(holds, build) {
 	return Match.value(holds).pipe(Match.when(true, build), Match.orElse(() => NO_MUTANTS));
 }
-/** A named property of a node that may or may not carry it. */
+const hasPropertyIn = (node, key) => key in node;
+const readPropertyOf = (node, key) => hasPropertyIn(node, key) ? node[key] : void 0;
 function propertyOf(node, key) {
-	return Match.value(node).pipe(Match.when((candidate) => Predicate.hasProperty(candidate, key), (host) => host[key]), Match.orElse(() => void 0));
+	return Predicate.isObject(node) ? readPropertyOf(node, key) : void 0;
 }
 function isIdentifier(node) {
 	return nodeType(node) === "Identifier";
@@ -4877,7 +4913,8 @@ function frozenContainer(value) {
 		freezableChildren(object).forEach((child) => {
 			deepFreeze(child);
 		});
-		return Object.freeze(object);
+		Object.freeze(object);
+		return value;
 	});
 }
 function freezableChildren(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-instrumenter",
-  "version": "8.0.1",
+  "version": "8.0.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/stryker-js-effect.git",
@@ -34,8 +34,8 @@
     "@effect/tsgo": "^0.45.0",
     "@microsoft/api-extractor": "^7",
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
-    "@systemfsoftware/effect-gherkin-spec": "^4.2.1",
-    "@systemfsoftware/oxlint-config-recommended": "^1.0.0",
+    "@systemfsoftware/effect-gherkin-spec": "^4.2.2",
+    "@systemfsoftware/oxlint-config-recommended": "^1.1.0",
     "@systemfsoftware/tsconfig": "^1.3.6",
     "@types/node": "^24",
     "oxlint": "^1",