@systemfsoftware/stryker-js-instrumenter 7.0.0 → 8.0.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @systemfsoftware/stryker-js-instrumenter
 
+## 8.0.0
+
+### Major Changes
+
+- The built-in reporters, plugin loading and their types are no longer published
+  from separate entry points on `@systemfsoftware/stryker-js`; import them from
+  `@systemfsoftware/stryker-js`. The mutant vocabulary — `Mutant`, `Location`,
+  `Position` and their schemas — is importable only from
+  `@systemfsoftware/stryker-js-instrumenter`.
+
+## 7.1.0
+
+### Minor Changes
+
+- Types that appear on the published CLI and instrumenter APIs are now exported.
+
 ## 7.0.0
 
 ### Major Changes

package/dist/index.d.mts

@@ -1,22 +1,73 @@
 import * as Effect from 'effect/Effect';
-import { FileDescription } from '@systemfsoftware/stryker-js-language';
-import { Mutant } from '@systemfsoftware/stryker-js-language';
 import * as S from 'effect/Schema';
 import { YieldableError } from 'effect/Cause';
 
+export declare const causeText: (cause: unknown, depth: number) => string | undefined;
+
+export declare interface Coverage {
+    readonly static: CoverageData;
+    readonly perTest: CoveragePerTestId;
+}
+
+export declare type CoverageData = Record<string, number>;
+
+export declare type CoveragePerTestId = Record<string, CoverageData>;
+
 export declare const disableTypeChecks: (file: File_2) => Effect.Effect<File_2, InstrumentError>;
 
+export declare interface EarlyResultPlan {
+    readonly plan: 'EarlyResult';
+    readonly mutant: Mutant;
+}
+
+export declare interface ErrnoException extends Error {
+    code?: string;
+    errno?: number;
+    path?: string;
+    syscall?: string;
+}
+
+export declare const ERROR_CODES: Readonly<{
+    NoSuchFileOrDirectory: 'ENOENT';
+}>;
+
+export declare function errorToString(error: unknown): string;
+
 declare interface File_2 extends FileDescription {
     name: string;
     content: string;
 }
 export { File_2 as File }
 
-export declare const instrument: (files: readonly File_2[], options: InstrumenterOptions, basePath?: string) => Effect.Effect<InstrumentResult$1, InstrumentError>;
+export declare interface FileDescription {
+    readonly mutate: MutateDescription;
+}
+
+export declare type FileDescriptions = Record<string, FileDescription>;
+
+export declare const instrument: (files: readonly File_2[], options: InstrumenterOptions, basePath?: string) => Effect.Effect<InstrumentResult, InstrumentError>;
+
+export declare const INSTRUMENTER_CONSTANTS: Readonly<{
+    NAMESPACE: '__stryker__';
+    MUTATION_COVERAGE_OBJECT: 'mutantCoverage';
+    ACTIVE_MUTANT: 'activeMutant';
+    CURRENT_TEST_ID: 'currentTestId';
+    HIT_COUNT: 'hitCount';
+    HIT_LIMIT: 'hitLimit';
+    ACTIVE_MUTANT_ENV_VARIABLE: '__STRYKER_ACTIVE_MUTANT__';
+}>;
+
+export declare interface InstrumenterContext {
+    activeMutant?: string;
+    currentTestId?: string;
+    mutantCoverage?: MutantCoverage;
+    hitCount?: number;
+    hitLimit?: number;
+}
 
 export declare type InstrumenterOptions = typeof InstrumenterOptionsSchema.Type;
 
-declare const InstrumenterOptionsSchema: S.Struct<{
+export declare const InstrumenterOptionsSchema: S.Struct<{
     readonly excludedMutations: S.$Array<S.String>;
     readonly ignorers: S.$Array<S.Unknown>;
     readonly noHeader: S.optional<S.Boolean>;
@@ -31,31 +82,154 @@ declare const InstrumentError_base: S.Class<InstrumentError, S.TaggedStruct<"Ins
     readonly cause: S.Defect;
 }>, YieldableError>;
 
-declare class InstrumentResult$1 extends InstrumentResult_base {}
-
 export declare interface InstrumentResult {
     files: readonly File_2[];
     mutants: readonly Mutant[];
 }
 
-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>;
+export declare function isErrnoException(error: unknown): error is ErrnoException;
+
+export declare const isMutant: (value: unknown) => value is Mutant;
+
+export declare type Location = typeof LocationSchema.Type;
+
+export declare const LocationSchema: 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;
+    }>;
+}>;
+
+export declare class Mutant extends Mutant_base {}
+
+declare const Mutant_base: S.Class<Mutant, S.TaggedStruct<"Mutant", {
+    readonly id: S.NonEmptyString;
+    readonly fileName: S.NonEmptyString;
+    readonly mutatorName: S.NonEmptyString;
+    readonly replacement: S.String;
+    readonly location: 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 status: S.optional<S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>>;
+    readonly statusReason: S.optional<S.String>;
+    readonly coveredBy: S.optional<S.$Array<S.String>>;
+    readonly static: S.optional<S.Boolean>;
+    readonly testsCompleted: S.optional<S.Finite>;
+    readonly description: S.optional<S.String>;
 }>, {}>;
 
+export declare type MutantActivation = typeof MutantActivationSchema.Type;
+
+export declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
+
+export declare interface MutantCoverage {
+    readonly perTest: Record<string, Record<string, number>>;
+    readonly static: Record<string, number>;
+}
+
+export declare type MutantEarlyResultPlan = EarlyResultPlan;
+
+export declare interface MutantRunOptions extends RunOptions {
+    readonly testFilter?: readonly string[];
+    readonly hitLimit?: number;
+    readonly activeMutant: Mutant;
+    readonly sandboxFileName: string;
+    readonly mutantActivation: MutantActivation;
+    readonly reloadEnvironment: boolean;
+}
+
+export declare const MutantRunOptionsSchema: S.Struct<{
+    readonly timeout: S.Finite;
+    readonly disableBail: S.Boolean;
+    readonly activeMutant: typeof Mutant;
+    readonly sandboxFileName: S.String;
+    readonly mutantActivation: S.Literals<readonly ["runtime", "static"]>;
+    readonly reloadEnvironment: S.Boolean;
+    readonly testFilter: S.optionalKey<S.$Array<S.String>>;
+    readonly hitLimit: S.optionalKey<S.Finite>;
+}>;
+
+export declare type MutantRunPlan = RunPlan;
+
+export declare type MutantStatus = typeof MutantStatusSchema.Type;
+
+export declare const MutantStatusSchema: S.Literals<readonly ["Killed", "Survived", "NoCoverage", "CompileError", "RuntimeError", "Timeout", "Ignored", "Pending"]>;
+
+export declare type MutantTestCoverage = Mutant & {
+    readonly coveredBy: ReadonlyArray<string> | undefined;
+    readonly static: boolean | undefined;
+};
+
+export declare type MutantTestPlan = TestPlan;
+
+export declare type MutateDescription = ReadonlyArray<MutationRange> | boolean;
+
+export declare interface MutationRange {
+    readonly start: Position;
+    readonly end: Position;
+}
+
+export declare function normalizeFileName(fileName: string): string;
+
+export declare type OpenEndLocation = typeof OpenEndLocationSchema.Type;
+
+export declare const OpenEndLocationSchema: S.Struct<{
+    readonly start: S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+    }>;
+    readonly end: S.optional<S.Struct<{
+        readonly line: S.Finite;
+        readonly column: S.Finite;
+    }>>;
+}>;
+
 export declare interface ParserOptions {}
 
+export declare type Position = typeof PositionSchema.Type;
+
+export declare const PositionSchema: S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+}>;
+
+export declare type RunMutantResult = Mutant & {
+    readonly status: MutantStatus;
+    readonly statusReason?: string | undefined;
+    readonly testsCompleted?: number | undefined;
+    readonly killedBy?: readonly string[] | undefined;
+    readonly coveredBy?: readonly string[] | undefined;
+    readonly static?: boolean | undefined;
+};
+
+export declare interface RunOptions {
+    readonly timeout: number;
+    readonly disableBail: boolean;
+}
+
+export declare const RunOptionsFields: {
+    timeout: S.Finite;
+    disableBail: S.Boolean;
+};
+
+export declare interface RunPlan {
+    readonly plan: 'Run';
+    readonly mutant: Mutant;
+    readonly runOptions: MutantRunOptions;
+    readonly netTime: number;
+}
+
+export declare type TestPlan = EarlyResultPlan | RunPlan;
+
 export { }