@systemfsoftware/stryker-js-instrumenter 1.0.0 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,54 @@
 # @systemfsoftware/stryker-js-instrumenter
 
+## 2.0.0
+
+### Major Changes
+
+- Three packages are renamed. `plugin-api` is now `@systemfsoftware/stryker-js`, the
+  language every plugin is written against. `mutation-run` is now
+  `@systemfsoftware/stryker-js-platform-node`, the Node host that runs a mutation
+  test. `mutation-report` is now `@systemfsoftware/stryker-js-html-reporter`.
+  Install the new names and change your imports.
+
+  Options types moved. `StrykerOptions`, `PartialStrykerOptions` and `LogLevel` are
+  imported from the `Schema` export; `Mutant`, `MutantStatus`, `Position` and
+  `Location` from the `Mutant` export. Point a config's `extends` at the language
+  package's `Schema` export.
+
+  `MutantStatus` accepts one spelling per outcome: `Killed`, `Survived`,
+  `NoCoverage`, `Timeout`, `CompileError`, `RuntimeError`, `Ignored` and `Pending`.
+  The lowercase and abbreviated forms — `killed`, `timedOut`, `noCoverage` and the
+  rest — are gone. A comparison against a removed spelling never matched the value
+  the reporter actually produced, so check any status comparison you wrote.
+
+  Statuses, plugin kinds, exit classes and AST formats are string literal unions
+  rather than enums, so read them as their string values. Member access such as
+  `ExitClass.VerdictFail` no longer resolves.
+
+  A plugin no longer receives a logger, and the logger port is gone. Plugins log
+  through Effect, and the host decides where that output goes.
+
+  The bundled base preset is gone. A config inherits from the language package's
+  `Schema` export and states the thresholds, reporters and plugins it wants; you no
+  longer silently inherit a package manager, a plugin list or a break threshold.
+
+### Patch Changes
+
+- Selecting `workflow-make-boundary` keeps mutants inside `Workflow.make` decision bodies.
+
+  Ignore plugins are asked about each mutant, not about the file root with a subtree latch. An inverted selector that answers "ignore" for everything outside a make body therefore no longer ignores the make body itself. Inner mutants of declaration-style ignore plugins (`effect-schema-declarations`, Angular signal option objects) are still ignored.
+
+- Instrumenting a file that calls a method named after an `Object.prototype`
+  member - `toString`, `valueOf`, `constructor` and the rest - no longer fails
+  with `Property name expected type of string but got function`. The method
+  mutator's replacement table answered such a lookup with the inherited function
+  rather than reporting no replacement, and a single `.toString()` call was enough
+  to stop the run. Those methods are now left alone, as they always should have
+  been.
+
+- Updated dependencies:
+  - @systemfsoftware/effect-cell-types@5.0.0
+
 ## 1.0.0
 
 ### Major Changes

package/README.md

@@ -1,6 +1,6 @@
 # @systemfsoftware/stryker-js-instrumenter
 
-A source-code fork of the upstream StrykerJS instrumenter package, pinned at 9.6.1.
+Parses source files, applies their configured mutators, and produces the mutant set for a mutation run.
 
 ## Install
 
@@ -16,10 +16,6 @@ pnpm add @systemfsoftware/stryker-js-instrumenter
 
 The instrumenter is used internally by the Stryker mutation testing framework to instrument source files with mutant coverage and switching logic.
 
-## API
-
-The public surface is generated from the source and versioned with the package: [`etc/stryker-js-instrumenter.api.md`](./etc/stryker-js-instrumenter.api.md).
-
 ## License
 
 Apache-2.0. Part of [systemfsoftware](https://github.com/systemfsoftware/systemfsoftware/tree/main/packages/testing/mutation/stryker-js/instrumenter#readme).

package/dist/index.d.mts

@@ -1,70 +1,85 @@
-import { FileDescription, Mutant } from "@systemfsoftware/stryker-js-plugin-api/core";
+import babel, { File as File$1, types } from "@babel/core";
+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 * as S from "effect/Schema";
-import { types } from "@babel/core";
+import { IgnorerService } from "@systemfsoftware/stryker-js/Ignorer";
 import "effect/Option";
-import { IgnorerService } from "@systemfsoftware/stryker-js-plugin-api/ignore";
-import * as Effect from "effect/Effect";
-//#region src/file.d.ts
-interface File extends FileDescription {
-  name: string;
-  content: string;
+//#region src/Instrument.workflow.d.ts
+declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
+  readonly message: S.String;
+  readonly cause: S.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class InstrumentError extends InstrumentError_base {
+  get message(): string;
 }
+declare const InstrumenterOptionsSchema: S.Struct<{
+  plugins: S.NullOr<S.$Array<S.Unknown & Wire.Mark> & Wire.Mark> & Wire.Mark;
+  excludedMutations: S.$Array<S.String & Wire.Mark> & Wire.Mark;
+  ignorers: S.$Array<S.Unknown & Wire.Mark> & Wire.Mark;
+  noHeader: S.optional<S.Boolean & Wire.Mark> & Wire.Mark;
+}> & Wire.Mark;
+type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
+declare const InstrumentResult_base: S.Class<InstrumentResult$1, S.TaggedStruct<"InstrumentResult", {
+  readonly files: S.$Array<S.Struct<{
+    readonly name: S.String;
+    readonly content: S.String;
+    readonly mutate: S.Union<readonly [S.Boolean, S.$Array<S.Struct<{
+      readonly start: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+      readonly end: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+      }>;
+    }>>]>;
+  }>>;
+  readonly mutants: S.$Array<typeof Mutant>;
+}>, {}>;
+declare class InstrumentResult$1 extends InstrumentResult_base {}
 //#endregion
-//#region src/parsers/parser-options.d.ts
+//#region src/Parser.d.ts
 interface ParserOptions {
-  plugins: unknown[] | null;
+  plugins: readonly unknown[] | null;
 }
 //#endregion
-//#region src/disable-type-checks.d.ts
-/**
- * Disables TypeScript type checking for a single file by inserting `// @ts-nocheck` commands.
- * It also does this for *.js files, as they can be type checked by typescript as well.
- * Other file types are silently ignored
- *
- * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#-ts-nocheck-in-typescript-files
- */
-declare function disableTypeChecks(file: File, options: ParserOptions): Promise<File>;
-//#endregion
-//#region src/frameworks/angular-ignorer.d.ts
-declare const angularIgnorer: IgnorerService;
-//#endregion
-//#region src/frameworks/index.d.ts
-declare const strykerPlugins: readonly unknown[];
-declare const frameworkPluginsFileUrl: string;
-//#endregion
-//#region src/instrument-result.d.ts
+//#region src/Instrument.d.ts
+interface File extends FileDescription {
+  name: string;
+  content: string;
+}
 interface InstrumentResult {
   files: readonly File[];
   mutants: readonly Mutant[];
 }
+declare function disableTypeChecks(file: File, options: ParserOptions): Promise<File>;
+declare const instrument: (files: readonly File[], options: InstrumenterOptions) => Effect.Effect<InstrumentResult$1, InstrumentError>;
 //#endregion
-//#region src/mutators/mutator-options.d.ts
-interface MutatorOptions {
-  excludedMutations: string[];
-  noHeader?: boolean;
-}
-//#endregion
-//#region src/transformers/transformer-options.d.ts
-interface TransformerOptions extends MutatorOptions {
-  ignorers: IgnorerService[];
-}
-//#endregion
-//#region src/instrumenter-options.d.ts
-interface InstrumenterOptions extends ParserOptions, TransformerOptions {}
-//#endregion
-//#region src/instrument-error.schema.d.ts
-declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"InstrumentError", {
-  readonly message: S.String;
-  readonly cause: S.Defect;
-}>, import("effect/Cause").YieldableError>;
-declare class InstrumentError extends InstrumentError_base {
-  get message(): string;
+//#region src/Transformer.d.ts
+/**
+ * `@babel/core` exports its `File` class at runtime, but `@types/babel__core`
+ * omits it. The declaration lives in this module rather than an ambient
+ * `.d.ts` so it travels with the sources: a consumer that compiles this
+ * package from source (the workspace's `@systemfsoftware/source` condition,
+ * and api-extractor with it) reaches the augmentation through the import
+ * graph, which an unreferenced ambient file never joins.
+ */
+declare module '@babel/core' {
+  class File {
+    constructor(options: {
+      filename?: string;
+    }, input: {
+      code: string;
+      ast: types.File;
+      inputMap?: unknown;
+    });
+    ast: types.File;
+  }
 }
+declare const angularIgnorer: IgnorerService;
+declare const strykerPlugins: readonly unknown[];
+declare const frameworkPluginsFileUrl: string;
 //#endregion
-//#region src/instrumenter.d.ts
-declare const instrument: (files: readonly File[], options: InstrumenterOptions) => Effect.Effect<{
-  files: File[];
-  mutants: import("@systemfsoftware/stryker-js-plugin-api/core").Mutant[];
-}, InstrumentError, never>;
-//#endregion
-export { File, InstrumentResult, InstrumenterOptions, type ParserOptions, angularIgnorer, disableTypeChecks, frameworkPluginsFileUrl, instrument, strykerPlugins };
+export { type File, type InstrumentResult, type InstrumenterOptions, type ParserOptions, angularIgnorer, disableTypeChecks, frameworkPluginsFileUrl, instrument, strykerPlugins };