@systemfsoftware/stryker-js-instrumenter 3.0.0 → 4.0.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @systemfsoftware/stryker-js-instrumenter
 
+## 4.0.0
+
+### Major Changes
+
+- instrument() keeps its public signature; the decision moved to a plain kernel, and the instrument workflow now distinguishes in-place from ephemeral output
+
+### Patch Changes
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@6.0.0
+  - @systemfsoftware/stryker-js@1.0.0
+
+## 3.0.1
+
+### Patch Changes
+
+- Refreshed builds on the platform-services dependency graph; the packages no longer reach for host builtins directly. No CLI flags or option names change.
+
+- Updated dependencies:
+  - @systemfsoftware/stryker-js@0.2.0
+
 ## 3.0.0
 
 ### Major Changes

package/dist/index.d.mts

@@ -1,11 +1,10 @@
-import { Wire, Workflow } from "@systemfsoftware/effect-cell-types";
 import { FileDescription, Mutant } from "@systemfsoftware/stryker-js/Mutant";
 import * as Effect from "effect/Effect";
-import "effect/Result";
+import { Wire } from "@systemfsoftware/effect-cell-types";
 import * as S from "effect/Schema";
 import { IgnorerService } from "@systemfsoftware/stryker-js/Ignorer";
 import "effect/Option";
-//#region src/Instrument.workflow.d.ts
+//#region src/Instrument.schema.d.ts
 declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
   readonly message: S.String;
   readonly cause: S.Defect;

package/dist/index.mjs

@@ -1,9 +1,7 @@
-import { Cell, Wire, Workflow } from "@systemfsoftware/effect-cell-types";
 import { INSTRUMENTER_CONSTANTS, Mutant } from "@systemfsoftware/stryker-js/Mutant";
 import * as Effect from "effect/Effect";
-import { pipe } from "effect/Function";
 import * as Predicate from "effect/Predicate";
-import * as Result from "effect/Result";
+import { Wire } from "@systemfsoftware/effect-cell-types";
 import * as S from "effect/Schema";
 import { parseSync } from "oxc-parser";
 import path from "path";
@@ -12,17 +10,7 @@ import { propertyPath, strykerReportBugUrl } from "@systemfsoftware/stryker-js/S
 import * as Option from "effect/Option";
 import path$1 from "node:path";
 import { RegExpParser, visitRegExpAST } from "@eslint-community/regexpp";
-//#region src/Instrument.workflow.ts
-/**
-* Instrument.workflow — pure decision for the instrument capability.
-*
-* The heavy lifting (AST traversal, mutant collection, code generation)
-* happens in `Instrument.ts`'s read phase, which is allowed to be stateful.
-* This decision receives the already-collected mutants as data and wraps them
-* into the decision type. All helpers and schemas live in this file so the
-* decision body only reaches parameters, const locals, same-file declarations,
-* and the sealed pure effect surface.
-*/
+//#region src/Instrument.schema.ts
 var InstrumentError = class extends S.TaggedError("@systemfsoftware/stryker-js-instrumenter/InstrumentError")("InstrumentError", {
 	message: S.String,
 	cause: S.Defect()
@@ -72,11 +60,6 @@ var InstrumentResult = class extends S.TaggedClass()("InstrumentResult", {
 	files: S.Array(FileSchema),
 	mutants: S.Array(Mutant)
 }) {};
-const instrumentWorkflow = Workflow.make(InstrumentDecoded, (decoded) => Result.succeed(InstrumentDecision.make({
-	files: decoded.files,
-	mutants: decoded.mutants,
-	asts: decoded.asts
-})));
 S.Literals([
 	"html",
 	"js",
@@ -3988,19 +3971,9 @@ const PredicateRecord = { key: (node) => Predicate.hasProperty(node, "key") ? no
 function isTypeNode(path) {
 	return flowTypeAnnotationNodeTypes.includes(path.node.type) || tsTypeAnnotationNodeTypes.includes(path.node.type) || isDeclareVariableStatement(path.node) || isDeclareModule(path.node);
 }
-/**
-* Determines whether or not it is a declare variable statement node.
-* @example
-* declare const foo: 'foo';
-*/
 function isDeclareVariableStatement(node) {
 	return nodeType(node) === "VariableDeclaration" && "declare" in node && node.declare === true;
 }
-/**
-* Determines whether or not a node is a string literal that is the name of a module.
-* @example
-* declare module "express" {};
-*/
 function isDeclareModule(node) {
 	return nodeType(node) === "TSModuleDeclaration" && "declare" in node && node.declare === true;
 }
@@ -4032,30 +4005,15 @@ const flowTypeAnnotationNodeTypes = Object.freeze([
 function isImportDeclaration(path) {
 	return nodeType(path.node) === "TSImportEqualsDeclaration" || path.node.type === "ImportDeclaration";
 }
-/**
-* returns syntax for `global.activeMutant === $mutantId`
-* @param mutantId The id of the mutant to switch
-*/
 function mutantTestExpression(mutantId) {
 	return callExpression(identifier(IS_MUTANT_ACTIVE_HELPER), [stringLiteral(mutantId)]);
 }
-/**
-* Returns a sequence of mutation coverage counters with an optional last expression.
-*
-* @example (global.__coverMutant__(0, 1), 40 + 2)
-* @param mutants The mutants for which covering syntax needs to be generated
-* @param targetExpression The original expression
-*/
 function mutationCoverageSequenceExpression(mutants, targetExpression) {
 	const mutantIds = [...mutants].map((mutant) => stringLiteral(mutant.id));
 	const sequence = [callExpression(identifier(COVER_MUTANT_HELPER), mutantIds)];
 	if (targetExpression) sequence.push(targetExpression);
 	return sequenceExpression(sequence);
 }
-/**
-* Verifies the placer's claim: `canPlace` established the node kind, so a
-* mismatch here means the placer was handed a mutant it never accepted.
-*/
 function nodeOfKind(mutant, node, isKind, kind) {
 	if (!isKind(node)) throw new Error(`Cannot place mutant ${mutant.id}: expected ${kind}, got ${node.type}`);
 	return node;
@@ -4068,14 +4026,6 @@ function throwPlacementError(error, nodePath, placer, mutants, fileName, lineTab
 	const errorMessage = `${location} ${message}. Either remove this file from the list of files to be mutated, or exclude the mutator (using ${propertyPath()("mutator", "excludedMutations")}). Please report this issue at ${strykerReportBugUrl(message)}. Original error: ${error.stack}`;
 	throw new Error(errorMessage);
 }
-/**
-* Will set the identifier of anonymous function expressions if is located in a variable declaration.
-* Will treat input as readonly. Returns undefined if not needed.
-* @example
-* const a = function() { }
-* becomes
-* const a = function a() {}
-*/
 function classOrFunctionExpressionNamedIfNeeded(path) {
 	const kind = nodeType(path.node);
 	if ((kind === "FunctionExpression" || kind === "ClassExpression") && !("id" in path.node) === false && path.node["id"] !== null) {}
@@ -4088,14 +4038,6 @@ function classOrFunctionExpressionNamedIfNeeded(path) {
 		if (parentPath !== null && parentPath.node.type === "Property" && parentPath.node.key.type === "Identifier" && path.getStatementParent()?.node.type === "VariableDeclaration") return path.node;
 	}
 }
-/**
-* Will set the identifier of anonymous arrow function expressions if is located in a variable declaration.
-* Will treat input as readonly. Returns undefined if not needed.
-* @example
-* const a = () => { }
-* becomes
-* const a = (() => { const a = () => {}; return a; })()
-*/
 function arrowFunctionExpressionNamedIfNeeded(path) {
 	const parentPath = path.parentPath;
 	if (path.node.type === "ArrowFunctionExpression" && parentPath !== null && parentPath.node.type === "VariableDeclarator" && parentPath.node.id.type === "Identifier") {
@@ -4123,52 +4065,30 @@ function isValidExpression(path) {
 	if (parent === null) return true;
 	const parentNode = parent.node;
 	return !isObjectPropertyKey() && !isPartOfChain() && !(parentNode.type === "TaggedTemplateExpression") && !isPartOfDeleteExpression() && !isPartOfAssignmentExpression();
-	/**
-	* Determines if the expression is property of an object.
-	* @example
-	* const a = {
-	*  'foo': 'bar' // 'foo' here is an object property
-	* };
-	*/
 	function isObjectPropertyKey() {
 		return parentNode.type === "Property" && parentNode.key === path.node;
 	}
-	/**
-	* Determines if the expression is part of a call/member chain.
-	* @example
-	* // bar is part of chain, foo is NOT part of the chain:
-	* foo.bar.baz();
-	* foo.bar?.baz()
-	* foo.bar;
-	* foo.bar!;
-	* foo.bar();
-	* foo?.bar();
-	* baz[foo.bar()]
-	* bar?.baz[0]
-	*/
 	function isPartOfChain() {
 		return isMemberOrCallOrNonNullExpression(path) && (isMemberExpressionNode(parent) && !(parentNode.type === "MemberExpression" && parentNode.computed && parentNode.property === path.node) || nodeType(parentNode) === "TSNonNullExpression" || isCallExpressionNode(parent) && parentNode.type === "CallExpression" && parentNode.callee === path.node);
 	}
-	/**
-	* Determines if the expression is part of a delete expression.
-	* @returns true if the expression is part of a delete expression
-	* @example
-	* delete foo.bar;
-	*/
 	function isPartOfDeleteExpression() {
 		return parentNode.type === "UnaryExpression" && parentNode.operator === "delete";
 	}
-	/**
-	* Determines if the expression is part of an assignment expression.
-	* @returns true if the expression is part of an assignment expression
-	* @example
-	* foo.bar = 42;
-	* initialNodes.filter((n) => n.id === 'tiptilt')[0].className = tiptiltState;
-	*/
 	function isPartOfAssignmentExpression() {
 		return parentNode.type === "AssignmentExpression" && parentNode.left === path.node;
 	}
 }
+function unwrapParenthesizedExpression(node) {
+	let current = node;
+	while (nodeType(current) === "ParenthesizedExpression") {
+		const wrapper = current;
+		if (typeof wrapper !== "object" || wrapper === null || !("expression" in wrapper)) break;
+		const inner = wrapper.expression;
+		if (inner === void 0 || inner === null) break;
+		current = inner;
+	}
+	return current;
+}
 const allMutantPlacers = Object.freeze([
 	{
 		name: "expressionMutantPlacer",
@@ -4178,7 +4098,7 @@ const allMutantPlacers = Object.freeze([
 		place(path, appliedMutants) {
 			let expression = nameIfAnonymous(path);
 			expression = mutationCoverageSequenceExpression(appliedMutants.keys(), expression);
-			for (const [mutant, appliedMutant] of appliedMutants) expression = conditionalExpression(mutantTestExpression(mutant.id), nodeOfKind(mutant, appliedMutant, isExpressionKind, "an expression"), expression);
+			for (const [mutant, appliedMutant] of appliedMutants) expression = conditionalExpression(mutantTestExpression(mutant.id), nodeOfKind(mutant, unwrapParenthesizedExpression(appliedMutant), isExpressionKind, "an expression"), expression);
 			path.replaceWith(expression);
 		}
 	},
@@ -4284,11 +4204,6 @@ function isMemberExpressionWithIdentifier(node, objectNames, propertyName) {
 }
 const strykerPlugins = [];
 const frameworkPluginsFileUrl = import.meta.url;
-/**
-* The instrumentation header: parsed once with oxc, frozen, shared. The
-* `globalThis` implementation is based on core-js's — see
-* https://github.com/stryker-mutator/stryker-js/issues/4035
-*/
 const parsedInstrumentationHeader = parseSync("instrumenter-header.js", `// @ts-nocheck
 var ${STRYKER_NAMESPACE_HELPER} = function(){
   var g = typeof globalThis === 'object' && globalThis && globalThis.Math === Math && globalThis || new Function("return this")();
@@ -4561,9 +4476,6 @@ function toError(value) {
 }
 //#endregion
 //#region src/Instrument.ts
-/**
-* Instrument — the instrument capability: Cell description, file/mutant types and the instrument entry point.
-*/
 const commentDirectiveRegEx = /^(\s*)@(ts-[a-z-]+).*$/;
 const tsDirectiveLikeRegEx = /@(ts-[a-z-]+)/;
 const startingCommentRegex = /(^\s*\/\*.*?\*\/)/gs;
@@ -4707,7 +4619,7 @@ function toTransformerOptions(options) {
 function isAst(value) {
 	return typeof value === "object" && value !== null && "format" in value && "root" in value;
 }
-const instrumentDescription = pipe(Cell.read((command) => Effect.gen(function* () {
+const readCollected = (command) => Effect.gen(function* () {
 	const files = command.files;
 	const options = command.options;
 	const parse = createParser();
@@ -4751,54 +4663,58 @@ const instrumentDescription = pipe(Cell.read((command) => Effect.gen(function* (
 			})
 		})
 	};
-})), Cell.decode((raw) => Result.succeed(InstrumentDecoded.make({
-	files: raw.files,
-	options: raw.options,
-	asts: raw.asts,
-	mutants: raw.mutants
-}))), Cell.decide(instrumentWorkflow), Cell.encode((outcome) => outcome), Cell.write((outcome) => Result.match(outcome, {
-	onFailure: (error) => Effect.fail(error),
-	onSuccess: (decision) => Effect.try({
-		try: () => {
-			const files = decision.files;
-			const asts = decision.asts;
-			const outFiles = [];
-			const isAstValue = (value) => typeof value === "object" && value !== null && "format" in value && "root" in value;
-			for (let i = 0; i < asts.length; i++) {
-				const maybeAst = asts[i];
-				const maybeFile = files[i];
-				if (maybeAst === void 0 || maybeFile === void 0) continue;
-				if (!isAstValue(maybeAst)) continue;
-				const ast = maybeAst;
-				const file = maybeFile;
-				const mutatedContent = print(ast);
-				outFiles.push({
-					name: file.name,
-					mutate: file.mutate,
-					content: mutatedContent
-				});
-			}
-			return InstrumentResult.make({
-				files: outFiles,
-				mutants: decision.mutants
+});
+const printDecision = (decision) => Effect.try({
+	try: () => {
+		const files = decision.files;
+		const asts = decision.asts;
+		const outFiles = [];
+		for (let i = 0; i < asts.length; i++) {
+			const maybeAst = asts[i];
+			const maybeFile = files[i];
+			if (maybeAst === void 0 || maybeFile === void 0) continue;
+			if (!isAst(maybeAst)) continue;
+			const ast = maybeAst;
+			const file = maybeFile;
+			const mutatedContent = print(ast);
+			outFiles.push({
+				name: file.name,
+				mutate: file.mutate,
+				content: mutatedContent
 			});
-		},
-		catch: (cause) => new InstrumentError({
-			message: "Failed to print",
-			cause
-		})
+		}
+		return InstrumentResult.make({
+			files: outFiles,
+			mutants: decision.mutants
+		});
+	},
+	catch: (cause) => new InstrumentError({
+		message: "Failed to print",
+		cause
 	})
-})));
-const instrument = (files, options) => {
+});
+const decideInstrument = (decoded) => InstrumentDecision.make({
+	files: decoded.files,
+	mutants: decoded.mutants,
+	asts: decoded.asts
+});
+const instrument = (files, options) => Effect.gen(function* () {
 	const schemaFiles = files.map((file) => ({
 		name: file.name,
 		content: file.content,
 		mutate: file.mutate
 	}));
-	return Cell.apply(instrumentDescription, InstrumentCommand.make({
+	const collected = yield* readCollected(InstrumentCommand.make({
 		files: schemaFiles,
 		options
 	}));
-};
+	const decision = decideInstrument(InstrumentDecoded.make({
+		files: collected.files,
+		options: collected.options,
+		asts: collected.asts,
+		mutants: collected.mutants
+	}));
+	return yield* printDecision(decision);
+});
 //#endregion
 export { angularIgnorer, disableTypeChecks, frameworkPluginsFileUrl, instrument, strykerPlugins };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@systemfsoftware/stryker-js-instrumenter",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/systemfsoftware/systemfsoftware.git",
@@ -24,8 +24,8 @@
     "angular-html-parser": "~10.4.0",
     "effect": "^4.0.0-rc.112",
     "oxc-parser": "^0.140.0",
-    "@systemfsoftware/effect-cell-types": "^5.0.2",
-    "@systemfsoftware/stryker-js": "^0.1.1"
+    "@systemfsoftware/effect-cell-types": "^6.0.0",
+    "@systemfsoftware/stryker-js": "^1.0.0"
   },
   "devDependencies": {
     "@systemfsoftware/arethetypeswrong-cli": "^1.1.1",
@@ -37,11 +37,11 @@
     "tsdown": "^0.22.14",
     "typescript": "^7",
     "vitest": "^4",
-    "@systemfsoftware/all": "^1.0.2",
-    "@systemfsoftware/effect-gherkin-spec": "^4.0.0",
+    "@systemfsoftware/all": "^1.1.2",
     "@systemfsoftware/oxlint-config": "^0.1.0",
-    "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/tsconfig": "^1.3.3"
+    "@systemfsoftware/effect-gherkin-spec": "^4.0.0",
+    "@systemfsoftware/tsconfig": "^1.3.3",
+    "@systemfsoftware/vitest-config": "^0.1.0"
   },
   "engines": {
     "node": ">=20.0.0"