@systemfsoftware/stryker-js-instrumenter 0.2.0 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,98 @@
 # @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
+
+- Parse, transform and mutant-placement failures now carry a message naming the
+  file and what went wrong, and their `cause` survives being written to JSON — so
+  a failure that crossed a process boundary no longer arrives blank.
+
+  Every error tag is now qualified, which is what makes two identically named
+  errors from different packages distinguishable.
+
+  `MutantPlacementFailed` is removed; it was a second name for `PlacementFailed`
+  and had no constructor anywhere. Match `PlacementFailed`.
+
+- svelte is now an optional peer dependency. Install it to mutate .svelte components; without it, every other file type is unaffected. A copy of the Svelte compiler used to be bundled in, which pinned whichever version was present when the package was built and made the compiler version check read the wrong answer.
+
+### Patch Changes
+
+- The instrumenter no longer depends on `weapon-regex`, a Scala library compiled to JavaScript that is no longer maintained. It is replaced by `@eslint-community/regexpp`, which has no dependencies of its own. Regular expression mutants are unchanged, so no action is required.
+
+- The shared helpers package is gone. Nothing installs it any more, and the
+  handful of helpers worth sharing now live in the plugin contract next to the
+  types they serve:
+
+  - `strykerReportBugUrl`, `normalizeFileName`, `propertyPath`, `errorToString`
+    and `isErrnoException` from `@systemfsoftware/stryker-js-plugin-api/core`
+  - `noopLogger` from `@systemfsoftware/stryker-js-plugin-api/logging`
+  - `testFilesProvided` from `@systemfsoftware/stryker-js-plugin-api/test-runner`
+
+  If you imported any of those, change the specifier. Everything else it exported
+  had no consumer and is removed: use `Predicate.isNotNullish` from Effect in place
+  of `notEmpty`, and `RegExp.escape` in place of `escapeRegExp`.
+
+- These packages no longer install dependencies they never imported, so installing them pulls less into your tree.
+
+  `tslib` is gone from all six. The mutation runner additionally stops installing `lodash.groupby`, `semver` and `source-map`, and the command line interface stops installing `@effect/platform-node-shared`. Nothing exported changes.
+
+- When a mutant cannot be placed, the reported error now links to this project's issue tracker rather than the upstream StrykerJS one.
+
+- Published packages no longer carry build artifacts left over from earlier builds. One package was shipping about a megabyte of bundled test-runner internals this way.
+
+- Updated dependencies:
+  - @systemfsoftware/stryker-js-plugin-api@3.0.0
+
 ## 0.2.0
 
 ### Minor 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,246 +1,85 @@
-import { BaseContext, Injector, PluginKind } from "@systemfsoftware/stryker-js-plugin-api/plugin";
-import { FileDescription, Mutant, MutateDescription, Position } from "@systemfsoftware/stryker-js-plugin-api/core";
-import { types } from "@babel/core";
-import { I } from "@systemfsoftware/stryker-js-util";
-import { Ignorer } from "@systemfsoftware/stryker-js-plugin-api/ignore";
-import { Logger } from "@systemfsoftware/stryker-js-plugin-api/logging";
-//#region src/instrumenter-tokens.d.ts
-declare const instrumenterTokens: Readonly<{
-  readonly createParser: 'instrumenterCreateParser';
-  readonly print: 'instrumenterPrint';
-  readonly transform: 'instrumenterTransform';
-}>;
-//#endregion
-//#region src/syntax/index.d.ts
-declare enum AstFormat {
-  Html = "html",
-  JS = "js",
-  TS = "ts",
-  Tsx = "tsx",
-  Svelte = "svelte"
-}
-interface AstByFormat {
-  [AstFormat.Html]: HtmlAst;
-  [AstFormat.JS]: JSAst;
-  [AstFormat.TS]: TSAst;
-  [AstFormat.Tsx]: TsxAst;
-  [AstFormat.Svelte]: SvelteAst;
-}
-type Ast = HtmlAst | JSAst | SvelteAst | TSAst | TsxAst;
-type ScriptAst = JSAst | TSAst | TsxAst;
-interface BaseAst {
-  originFileName: string;
-  rawContent: string;
-  root: Ast['root'];
-  offset?: Position;
-}
-/**
- * Represents an Html AST.
- */
-interface HtmlAst extends BaseAst {
-  format: AstFormat.Html;
-  root: HtmlRootNode;
-}
-/**
- * Represents a TS AST
- */
-interface JSAst extends BaseAst {
-  format: AstFormat.JS;
-  root: types.File;
-}
-/**
- * Represents a TS AST
- */
-interface TSAst extends BaseAst {
-  format: AstFormat.TS;
-  root: types.File;
-}
-/**
- * Represents a TS AST
- */
-interface TsxAst extends BaseAst {
-  format: AstFormat.Tsx;
-  root: types.File;
-}
-/**
- * Represents a Svelte AST
- */
-interface SvelteAst extends BaseAst {
-  format: AstFormat.Svelte;
-  root: SvelteRootNode;
-}
-/**
- * Represents the root node of an HTML AST
- * We've taken a shortcut here, instead of representing the entire AST, we're only representing the script tags.
- * We might need to expand this in the future if we would ever want to support mutating the actual HTML (rather than only the JS/TS)
- */
-interface HtmlRootNode {
-  scripts: ScriptAst[];
-}
-interface SvelteRootNode {
-  moduleScript?: TemplateScript;
-  additionalScripts: TemplateScript[];
-}
-/**
- * Represents a svelte script or binding expression
- * We've taken a shortcut here, instead of representing the entire AST, we're only representing the script tags and expression bindings.
- */
-interface TemplateScript {
-  ast: ScriptAst;
-  range: Range;
-  isExpression: boolean;
-}
-interface Range {
-  start: number;
-  end: number;
-}
-//#endregion
-//#region src/parsers/parser-options.d.ts
+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 { IgnorerService } from "@systemfsoftware/stryker-js/Ignorer";
+import "effect/Option";
+//#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/Parser.d.ts
 interface ParserOptions {
-  plugins: unknown[] | null;
+  plugins: readonly unknown[] | null;
 }
 //#endregion
-//#region src/parsers/create-parser.d.ts
-declare function createParser(parserOptions: ParserOptions): {
-  <T extends AstFormat>(code: string, fileName: string, formatOverride: T): Promise<AstByFormat[T]>;
-  (code: string, fileName: string, formatOverride?: AstFormat): Promise<Ast>;
-};
-//#endregion
-//#region src/printers/index.d.ts
-declare function print(file: Ast): string;
-//#endregion
-//#region src/mutant.d.ts
-interface Mutable {
-  mutatorName: string;
-  ignoreReason?: string | undefined;
-  replacement: types.Node;
-}
-declare class Mutant$1 implements Mutable {
-  readonly id: string;
-  readonly fileName: string;
-  readonly original: types.Node;
-  readonly offset: Position;
-  readonly replacementCode: string;
-  readonly replacement: types.Node;
-  readonly mutatorName: string;
-  readonly ignoreReason: string | undefined;
-  constructor(id: string, fileName: string, original: types.Node, specs: Mutable, offset?: Position);
-  toApiMutant(): Mutant;
-  /**
-   * Applies the mutant in (a copy of) the AST, without changing provided AST.
-   * Can the tree itself (in which case the replacement is returned),
-   * or can be nested in the given tree.
-   *
-   * Returns a plain node rather than the argument's own type: whether the
-   * replacement fits a given position is the placer's claim, and the placer
-   * checks it with a Babel predicate. A generic return would have to assert it
-   * here, where nothing can check it.
-   * @param originalTree The original node, which will be treated as readonly
-   */
-  applied(originalTree: types.Node): types.Node;
-}
-//#endregion
-//#region src/transformers/mutant-collector.d.ts
-declare class MutantCollector {
-  private readonly _mutants;
-  get mutants(): readonly Mutant$1[];
-  /**
-   * Adds mutants to the internal mutant list.
-   * @param fileName file name that houses the mutant
-   * @param original The node to mutate
-   * @param mutables the named node mutation to be added
-   * @param contextPath the context where these mutants are found and should be placed as close by as possible
-   * @param offset offset of mutant nodes
-   * @returns The mutant (for testability)
-   */
-  collect(fileName: string, original: types.Node, mutable: Mutable, offset?: Position): Mutant$1;
-  hasPlacedMutants(fileName: string): boolean;
-}
-//#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: Ignorer[];
-}
-//#endregion
-//#region src/transformers/transformer.d.ts
-/**
- * Transform the AST by generating mutants and placing them in the AST.
- * Supports all AST formats supported by Stryker.
- * @param ast The Abstract Syntax Tree
- * @param mutantCollector the mutant collector that will be used to register and administer mutants
- * @param transformerContext the options used during transforming
- */
-declare function transform(ast: Ast, mutantCollector: I<MutantCollector>, transformerContext: Omit<TransformerContext, 'transform'>): void;
-type AstTransformer<T extends AstFormat> = (ast: AstByFormat[T], mutantCollector: I<MutantCollector>, context: TransformerContext) => void;
-interface TransformerContext {
-  transform: AstTransformer<AstFormat>;
-  options: TransformerOptions;
-  mutateDescription: MutateDescription;
-  logger: Logger;
-}
-//#endregion
-//#region src/create-instrumenter.d.ts
-interface InstrumenterContext extends BaseContext {
-  [instrumenterTokens.createParser]: typeof createParser;
-  [instrumenterTokens.print]: typeof print;
-  [instrumenterTokens.transform]: typeof transform;
-}
-declare function createInstrumenter(injector: Injector<BaseContext>): Instrumenter;
-declare namespace createInstrumenter {
-  var inject: ["$injector"];
-}
-//#endregion
-//#region src/file.d.ts
+//#region src/Instrument.d.ts
 interface File extends FileDescription {
   name: string;
   content: string;
 }
-//#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/index.d.ts
-declare const strykerPlugins: import("@systemfsoftware/stryker-js-plugin-api/plugin").ClassPlugin<PluginKind.Ignore, []>[];
-declare const frameworkPluginsFileUrl: string;
-//#endregion
-//#region src/instrument-result.d.ts
 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/instrumenter-options.d.ts
-interface InstrumenterOptions extends ParserOptions, TransformerOptions {}
-//#endregion
-//#region src/instrumenter.d.ts
+//#region src/Transformer.d.ts
 /**
- * The instrumenter is responsible for
- * * Generating mutants based on source files
- * * Instrumenting the source code with the mutants placed in `mutant switches`.
- * * Adding mutant coverage expressions in the source code.
- * @see https://github.com/stryker-mutator/stryker-js/issues/1514
+ * `@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 class Instrumenter {
-  private readonly logger;
-  private readonly _createParser;
-  private readonly _print;
-  private readonly _transform;
-  static inject: ["logger", "instrumenterCreateParser", "instrumenterPrint", "instrumenterTransform"];
-  constructor(logger: Logger, _createParser?: typeof createParser, _print?: typeof print, _transform?: typeof transform);
-  instrument(files: readonly File[], options: InstrumenterOptions): Promise<InstrumentResult>;
-}
+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
-export { File, InstrumentResult, Instrumenter, InstrumenterContext, InstrumenterOptions, type ParserOptions, createInstrumenter, disableTypeChecks, frameworkPluginsFileUrl, strykerPlugins };
+export { type File, type InstrumentResult, type InstrumenterOptions, type ParserOptions, angularIgnorer, disableTypeChecks, frameworkPluginsFileUrl, instrument, strykerPlugins };