@systemfsoftware/stryker-js 0.1.0

package/dist/Mutant-BPRJTF8f.d.mts

@@ -0,0 +1,351 @@
+import * as Context from "effect/Context";
+import * as S from "effect/Schema";
+import * as schema from "mutation-testing-report-schema/api";
+import * as Effect from "effect/Effect";
+//#region src/Mutant.schema.d.ts
+declare const PositionSchema: S.Struct<{
+  readonly line: S.Finite;
+  readonly column: S.Finite;
+}>;
+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;
+  }>;
+}>;
+declare const Mutant_base: S.Class<Mutant, S.TaggedStruct<"Mutant", {
+  readonly id: S.String;
+  readonly fileName: S.String;
+  readonly mutatorName: S.String;
+  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", "Timeout", "CompileError", "RuntimeError", "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>;
+}>, {}>;
+declare class Mutant extends Mutant_base {}
+type Position$1 = S.Schema.Type<typeof PositionSchema>;
+type Location = S.Schema.Type<typeof LocationSchema>;
+//#endregion
+//#region src/TestRunner.schema.d.ts
+declare const DryRunStatus: S.Literals<readonly ["complete", "error", "timeout"]>;
+type DryRunStatus = typeof DryRunStatus.Type;
+declare const TestStatus: S.Literals<readonly ["success", "failed", "skipped"]>;
+type TestStatus = typeof TestStatus.Type;
+declare const MutantRunStatus: S.Literals<readonly ["killed", "survived", "timeout", "error"]>;
+type MutantRunStatus = typeof MutantRunStatus.Type;
+declare const TestResultSchema: S.Union<readonly [S.Struct<{
+  readonly id: S.String;
+  readonly name: S.String;
+  readonly timeSpentMs: S.Finite;
+  readonly fileName: S.optionalKey<S.String>;
+  readonly startPosition: S.optionalKey<S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>>;
+  readonly status: S.Literal<"failed">;
+  readonly failureMessage: S.String;
+}>, S.Struct<{
+  readonly id: S.String;
+  readonly name: S.String;
+  readonly timeSpentMs: S.Finite;
+  readonly fileName: S.optionalKey<S.String>;
+  readonly startPosition: S.optionalKey<S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>>;
+  readonly status: S.Literal<"skipped">;
+}>, S.Struct<{
+  readonly id: S.String;
+  readonly name: S.String;
+  readonly timeSpentMs: S.Finite;
+  readonly fileName: S.optionalKey<S.String>;
+  readonly startPosition: S.optionalKey<S.Struct<{
+    readonly line: S.Finite;
+    readonly column: S.Finite;
+  }>>;
+  readonly status: S.Literal<"success">;
+}>]>;
+declare const MutantCoverageSchema: S.Struct<{
+  readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
+  readonly static: S.$Record<S.String, S.Finite>;
+}>;
+declare const DryRunResultSchema: S.Union<readonly [S.Struct<{
+  readonly status: S.Literal<"complete">;
+  readonly tests: S.$Array<S.Union<readonly [S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>>;
+    readonly status: S.Literal<"failed">;
+    readonly failureMessage: S.String;
+  }>, S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>>;
+    readonly status: S.Literal<"skipped">;
+  }>, S.Struct<{
+    readonly id: S.String;
+    readonly name: S.String;
+    readonly timeSpentMs: S.Finite;
+    readonly fileName: S.optionalKey<S.String>;
+    readonly startPosition: S.optionalKey<S.Struct<{
+      readonly line: S.Finite;
+      readonly column: S.Finite;
+    }>>;
+    readonly status: S.Literal<"success">;
+  }>]>>;
+  readonly mutantCoverage: S.optionalKey<S.Struct<{
+    readonly perTest: S.$Record<S.String, S.$Record<S.String, S.Finite>>;
+    readonly static: S.$Record<S.String, S.Finite>;
+  }>>;
+}>, S.Struct<{
+  readonly status: S.Literal<"timeout">;
+  readonly reason: S.optionalKey<S.String>;
+}>, S.Struct<{
+  readonly status: S.Literal<"error">;
+  readonly errorMessage: S.String;
+}>]>;
+declare const MutantRunResultSchema: S.Union<readonly [S.Struct<{
+  readonly status: S.Literal<"killed">;
+  readonly killedBy: S.$Array<S.String>;
+  readonly failureMessage: S.String;
+  readonly nrOfTests: S.Finite;
+}>, S.Struct<{
+  readonly status: S.Literal<"survived">;
+  readonly nrOfTests: S.Finite;
+}>, S.Struct<{
+  readonly status: S.Literal<"timeout">;
+  readonly reason: S.optionalKey<S.String>;
+}>, S.Struct<{
+  readonly status: S.Literal<"error">;
+  readonly errorMessage: S.String;
+}>]>;
+declare const CoverageAnalysisSchema: S.Literals<readonly ["off", "all", "perTest"]>;
+declare const DryRunOptionsSchema: S.Struct<{
+  readonly timeout: S.Finite;
+  readonly disableBail: S.Boolean;
+  readonly coverageAnalysis: S.Literals<readonly ["off", "all", "perTest"]>;
+  readonly files: S.optionalKey<S.$Array<S.String>>;
+  readonly testFiles: S.optionalKey<S.$Array<S.String>>;
+}>;
+declare const MutantActivationSchema: S.Literals<readonly ["runtime", "static"]>;
+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>;
+}>;
+declare const TestRunnerCapabilitiesSchema: S.Struct<{
+  readonly reloadEnvironment: S.Boolean;
+}>;
+declare const TestRunnerFailed_base: S.Class<TestRunnerFailed, S.TaggedStruct<"TestRunnerFailed", {
+  readonly cause: S.String;
+  readonly phase: S.Literals<readonly ["capabilities", "dispose", "dryRun", "init", "mutantRun"]>;
+  readonly runnerName: S.String;
+}>, import("effect/Cause").YieldableError>;
+declare class TestRunnerFailed extends TestRunnerFailed_base {}
+declare namespace TestRunner_d_exports {
+  export { BaseTestResult, CompleteDryRunResult, CoverageAnalysis, CoverageAnalysisSchema, DryRunOptions, DryRunOptionsSchema, DryRunResult, DryRunResultSchema, DryRunStatus, ErrorDryRunResult, ErrorMutantRunResult, FailedTestResult, KilledMutantRunResult, MutantActivation, MutantActivationSchema, MutantCoverage$1 as MutantCoverage, MutantCoverageSchema, MutantRunOptions, MutantRunOptionsSchema, MutantRunResult, MutantRunResultSchema, MutantRunStatus, Position, RunOptions, SkippedTestResult, SuccessTestResult, SurvivedMutantRunResult, TestResult, TestResultSchema, TestRunner, TestRunnerCapabilities, TestRunnerCapabilitiesSchema, TestRunnerFailed, TestRunnerService, TestStatus, TimeoutDryRunResult, TimeoutMutantRunResult, testFilesProvided, toMutantRunResult };
+}
+interface Position {
+  readonly line: number;
+  readonly column: number;
+}
+interface BaseTestResult {
+  readonly id: string;
+  readonly name: string;
+  readonly timeSpentMs: number;
+  readonly fileName?: string;
+  readonly startPosition?: Position;
+}
+interface FailedTestResult extends BaseTestResult {
+  readonly status: 'failed';
+  readonly failureMessage: string;
+}
+interface SkippedTestResult extends BaseTestResult {
+  readonly status: 'skipped';
+}
+interface SuccessTestResult extends BaseTestResult {
+  readonly status: 'success';
+}
+type TestResult = FailedTestResult | SkippedTestResult | SuccessTestResult;
+interface MutantCoverage$1 {
+  readonly perTest: Record<string, Record<string, number>>;
+  readonly static: Record<string, number>;
+}
+interface CompleteDryRunResult {
+  readonly tests: readonly TestResult[];
+  readonly mutantCoverage?: MutantCoverage$1;
+  readonly status: 'complete';
+}
+interface TimeoutDryRunResult {
+  readonly status: 'timeout';
+  readonly reason?: string;
+}
+interface ErrorDryRunResult {
+  readonly status: 'error';
+  readonly errorMessage: string;
+}
+type DryRunResult = CompleteDryRunResult | ErrorDryRunResult | TimeoutDryRunResult;
+interface TimeoutMutantRunResult {
+  readonly status: 'timeout';
+  readonly reason?: string;
+}
+interface KilledMutantRunResult {
+  readonly status: 'killed';
+  readonly killedBy: readonly string[];
+  readonly failureMessage: string;
+  readonly nrOfTests: number;
+}
+interface SurvivedMutantRunResult {
+  readonly status: 'survived';
+  readonly nrOfTests: number;
+}
+interface ErrorMutantRunResult {
+  readonly status: 'error';
+  readonly errorMessage: string;
+}
+type MutantRunResult = ErrorMutantRunResult | KilledMutantRunResult | SurvivedMutantRunResult | TimeoutMutantRunResult;
+type CoverageAnalysis = 'off' | 'all' | 'perTest';
+interface RunOptions {
+  readonly timeout: number;
+  readonly disableBail: boolean;
+}
+interface DryRunOptions extends RunOptions {
+  readonly coverageAnalysis: CoverageAnalysis;
+  readonly files?: readonly string[];
+  readonly testFiles?: readonly string[];
+}
+type MutantActivation = 'runtime' | 'static';
+interface MutantRunOptions extends RunOptions {
+  readonly testFilter?: readonly string[];
+  readonly hitLimit?: number;
+  readonly activeMutant: Mutant;
+  readonly sandboxFileName: string;
+  readonly mutantActivation: MutantActivation;
+  readonly reloadEnvironment: boolean;
+}
+interface TestRunnerCapabilities {
+  readonly reloadEnvironment: boolean;
+}
+declare function toMutantRunResult(dryRunResult: DryRunResult, reportAllKillers: boolean): MutantRunResult;
+interface TestRunnerService {
+  readonly capabilities: Effect.Effect<TestRunnerCapabilities, TestRunnerFailed>;
+  readonly init: Effect.Effect<void, TestRunnerFailed>;
+  readonly dryRun: (options: DryRunOptions) => Effect.Effect<DryRunResult, TestRunnerFailed>;
+  readonly mutantRun: (options: MutantRunOptions) => Effect.Effect<MutantRunResult, TestRunnerFailed>;
+  readonly dispose: Effect.Effect<void, TestRunnerFailed>;
+}
+declare const TestRunner_base: Context.ServiceClass<TestRunner, "~@systemfsoftware/stryker-js/TestRunner", TestRunnerService>;
+declare class TestRunner extends TestRunner_base {}
+declare function testFilesProvided(options: {
+  readonly testFiles?: readonly string[];
+}): boolean;
+declare namespace Mutant_d_exports {
+  export { Coverage, CoverageData, CoveragePerTestId, ERROR_CODES, EarlyResultPlan, ErrnoException, FileDescription, FileDescriptions, INSTRUMENTER_CONSTANTS, InstrumenterContext, Location, LocationSchema, Mutant, MutantCoverage, MutantEarlyResultPlan, MutantResult, MutantRunPlan, MutantStatus, MutantTestCoverage, MutantTestPlan, MutateDescription, MutationRange, Position$1 as Position, PositionSchema, RunPlan, TestPlan, causeText, errorToString, isErrnoException, isMutant, normalizeFileName, schema };
+}
+type CoverageData = Record<string, number>;
+type CoveragePerTestId = Record<string, CoverageData>;
+interface Coverage {
+  readonly static: CoverageData;
+  readonly perTest: CoveragePerTestId;
+}
+type MutantStatus = 'Killed' | 'Survived' | 'NoCoverage' | 'Timeout' | 'CompileError' | 'RuntimeError' | 'Ignored' | 'Pending';
+interface EarlyResultPlan {
+  readonly plan: 'EarlyResult';
+  readonly mutant: Mutant;
+}
+interface RunPlan {
+  readonly plan: 'Run';
+  readonly mutant: Mutant;
+  readonly runOptions: MutantRunOptions;
+  readonly netTime: number;
+}
+type TestPlan = EarlyResultPlan | RunPlan;
+declare const isMutant: (value: unknown) => value is Mutant;
+type MutantTestCoverage = Mutant & {
+  readonly coveredBy: ReadonlyArray<string> | undefined;
+  readonly static: boolean | undefined;
+};
+type MutantResult = 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;
+};
+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__';
+}>;
+interface InstrumenterContext {
+  activeMutant?: string;
+  currentTestId?: string;
+  mutantCoverage?: MutantCoverage;
+  hitCount?: number;
+  hitLimit?: number;
+}
+type MutantCoverage = Coverage;
+declare function normalizeFileName(fileName: string): string;
+interface ErrnoException extends Error {
+  code?: string;
+  errno?: number;
+  path?: string;
+  syscall?: string;
+}
+declare function isErrnoException(error: unknown): error is ErrnoException;
+declare function errorToString(error: unknown): string;
+declare const ERROR_CODES: Readonly<{
+  NoSuchFileOrDirectory: 'ENOENT';
+}>;
+interface MutationRange {
+  readonly start: Position$1;
+  readonly end: Position$1;
+}
+type MutateDescription = ReadonlyArray<MutationRange> | boolean;
+interface FileDescription {
+  readonly mutate: MutateDescription;
+}
+type FileDescriptions = Record<string, FileDescription>;
+type MutantRunPlan = RunPlan;
+type MutantEarlyResultPlan = EarlyResultPlan;
+type MutantTestPlan = TestPlan;
+declare const causeText: (cause: unknown, depth: number) => string | undefined;
+//#endregion
+export { TimeoutMutantRunResult as $, CompleteDryRunResult as A, MutantRunOptions as B, causeText as C, normalizeFileName as D, isMutant as E, ErrorMutantRunResult as F, SuccessTestResult as G, Position as H, FailedTestResult as I, TestRunner as J, SurvivedMutantRunResult as K, KilledMutantRunResult as L, DryRunOptions as M, DryRunResult as N, schema as O, ErrorDryRunResult as P, TimeoutDryRunResult as Q, MutantActivation as R, TestPlan as S, isErrnoException as T, RunOptions as U, MutantRunResult as V, SkippedTestResult as W, TestRunnerService as X, TestRunnerCapabilities as Y, TestRunner_d_exports as Z, MutantTestPlan as _, Mutant as _t, EarlyResultPlan as a, DryRunStatus as at, MutationRange as b, FileDescriptions as c, MutantRunOptionsSchema as ct, MutantCoverage as d, TestResultSchema as dt, testFilesProvided as et, MutantEarlyResultPlan as f, TestRunnerCapabilitiesSchema as ft, MutantTestCoverage as g, LocationSchema as gt, MutantStatus as h, Location as ht, ERROR_CODES as i, DryRunResultSchema as it, CoverageAnalysis as j, BaseTestResult as k, INSTRUMENTER_CONSTANTS as l, MutantRunResultSchema as lt, MutantRunPlan as m, TestStatus as mt, CoverageData as n, CoverageAnalysisSchema as nt, ErrnoException as o, MutantActivationSchema as ot, MutantResult as p, TestRunnerFailed as pt, TestResult as q, CoveragePerTestId as r, DryRunOptionsSchema as rt, FileDescription as s, MutantCoverageSchema as st, Coverage as t, toMutantRunResult as tt, InstrumenterContext as u, MutantRunStatus as ut, Mutant_d_exports as v, Position$1 as vt, errorToString as w, RunPlan as x, MutateDescription as y, PositionSchema as yt, MutantCoverage$1 as z };

package/dist/Mutant.d.mts

@@ -0,0 +1,2 @@
+import { C as causeText, D as normalizeFileName, E as isMutant, O as schema, S as TestPlan, T as isErrnoException, _ as MutantTestPlan, _t as Mutant, a as EarlyResultPlan, b as MutationRange, c as FileDescriptions, d as MutantCoverage, f as MutantEarlyResultPlan, g as MutantTestCoverage, gt as LocationSchema, h as MutantStatus, ht as Location, i as ERROR_CODES, l as INSTRUMENTER_CONSTANTS, m as MutantRunPlan, n as CoverageData, o as ErrnoException, p as MutantResult, r as CoveragePerTestId, s as FileDescription, t as Coverage, u as InstrumenterContext, vt as Position, w as errorToString, x as RunPlan, y as MutateDescription, yt as PositionSchema } from "./Mutant-BPRJTF8f.mjs";
+export { Coverage, CoverageData, CoveragePerTestId, ERROR_CODES, EarlyResultPlan, ErrnoException, FileDescription, FileDescriptions, INSTRUMENTER_CONSTANTS, InstrumenterContext, type Location, LocationSchema, Mutant, MutantCoverage, MutantEarlyResultPlan, MutantResult, MutantRunPlan, MutantStatus, MutantTestCoverage, MutantTestPlan, MutateDescription, MutationRange, type Position, PositionSchema, RunPlan, TestPlan, causeText, errorToString, isErrnoException, isMutant, normalizeFileName, schema };

package/dist/Mutant.mjs

@@ -0,0 +1,114 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { n as Mutant, r as PositionSchema, t as LocationSchema } from "./Mutant.schema-BTWhFTk4.mjs";
+import * as schema from "mutation-testing-report-schema/api";
+//#region src/Mutant.ts
+var Mutant_exports = /* @__PURE__ */ __exportAll({
+	ERROR_CODES: () => ERROR_CODES,
+	INSTRUMENTER_CONSTANTS: () => INSTRUMENTER_CONSTANTS,
+	LocationSchema: () => LocationSchema,
+	Mutant: () => Mutant,
+	PositionSchema: () => PositionSchema,
+	causeText: () => causeText,
+	errorToString: () => errorToString,
+	isErrnoException: () => isErrnoException,
+	isMutant: () => isMutant,
+	normalizeFileName: () => normalizeFileName,
+	schema: () => schema
+});
+const isMutant = (value) => value instanceof Mutant;
+const INSTRUMENTER_CONSTANTS = Object.freeze({
+	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__"
+});
+function normalizeFileName(fileName) {
+	return fileName.replace(/\\/g, "/");
+}
+function isErrnoException(error) {
+	if (!(error instanceof Error)) return false;
+	if (!("code" in error)) return false;
+	return typeof Reflect.get(error, "code") === "string";
+}
+const isEmptyError = (error) => {
+	if (error === void 0 || error === null) return true;
+	if (typeof error === "string" && error.length === 0) return true;
+	if (error === 0 || error === false) return true;
+	if (typeof error === "number" && Number.isNaN(error)) return true;
+	return false;
+};
+const formatErrnoException = (error) => {
+	const stack = error.stack;
+	if (stack !== void 0 && stack.length > 0) return `${error.name}: ${error.code} (${error.syscall}) ${stack}`;
+	return `${error.name}: ${error.code} (${error.syscall})`;
+};
+const formatError = (error) => {
+	const message = `${error.name}: ${error.message}`;
+	if (error.stack !== void 0 && error.stack.length > 0) return `${message}\n${error.stack.toString()}`;
+	return message;
+};
+const stringifyNonError = (error) => {
+	if (typeof error === "string") return error;
+	if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") return JSON.stringify(error);
+	try {
+		const json = JSON.stringify(error);
+		if (typeof json === "string" && json.length > 0) return json;
+	} catch {}
+	if (typeof error === "object" && error !== null && "toString" in error) {
+		const toStringValue = Reflect.get(error, "toString");
+		if (typeof toStringValue === "function") try {
+			const text = Reflect.apply(toStringValue, error, []);
+			if (typeof text === "string" && text.length > 0 && text !== "[object Object]") return text;
+		} catch {}
+	}
+	return "";
+};
+function errorToString(error) {
+	if (isEmptyError(error)) return "";
+	if (error instanceof Error) {
+		if (isErrnoException(error)) return formatErrnoException(error);
+		return formatError(error);
+	}
+	return stringifyNonError(error);
+}
+const ERROR_CODES = Object.freeze({ NoSuchFileOrDirectory: "ENOENT" });
+const stringField = (value, key) => {
+	if (!(key in value)) return;
+	const field = Reflect.get(value, key);
+	if (typeof field === "string" && field.length > 0) return field;
+};
+const tagOf = (value) => {
+	let tag;
+	if ("_tag" in value) tag = Reflect.get(value, "_tag");
+	else tag = void 0;
+	if (typeof tag === "string" && tag.length > 0) return tag;
+	if (value instanceof Error && value.name.length > 0) return value.name;
+};
+const causeText = (cause, depth) => {
+	if (depth > 4 || cause === void 0 || cause === null) return;
+	if (typeof cause === "string") {
+		if (cause.length > 0) return cause;
+		return;
+	}
+	if (typeof cause !== "object") return;
+	let own;
+	const reason = stringField(cause, "reason");
+	if (reason !== void 0) own = reason;
+	else {
+		const message = stringField(cause, "message");
+		if (message !== void 0) own = message;
+		else if (cause instanceof Error && cause.message.length > 0) own = cause.message;
+		else own = tagOf(cause);
+	}
+	let nested;
+	if ("cause" in cause) nested = causeText(Reflect.get(cause, "cause"), depth + 1);
+	else nested = void 0;
+	if (own === void 0) return nested;
+	if (nested === void 0) return own;
+	return `${own}: ${nested}`;
+};
+//#endregion
+export { ERROR_CODES, INSTRUMENTER_CONSTANTS, LocationSchema, Mutant, PositionSchema, causeText, errorToString, isErrnoException, isMutant, normalizeFileName, schema, Mutant_exports as t };

package/dist/Mutant.schema-BTWhFTk4.mjs

@@ -0,0 +1,34 @@
+import * as S from "effect/Schema";
+//#region src/Mutant.schema.ts
+const PositionSchema = S.Struct({
+	line: S.Finite,
+	column: S.Finite
+});
+const LocationSchema = S.Struct({
+	start: PositionSchema,
+	end: PositionSchema
+});
+var Mutant = class extends S.TaggedClass()("Mutant", {
+	id: S.String,
+	fileName: S.String,
+	mutatorName: S.String,
+	replacement: S.String,
+	location: LocationSchema,
+	status: S.optional(S.Literals([
+		"Killed",
+		"Survived",
+		"NoCoverage",
+		"Timeout",
+		"CompileError",
+		"RuntimeError",
+		"Ignored",
+		"Pending"
+	])),
+	statusReason: S.optional(S.String),
+	coveredBy: S.optional(S.Array(S.String)),
+	static: S.optional(S.Boolean),
+	testsCompleted: S.optional(S.Finite),
+	description: S.optional(S.String)
+}) {};
+//#endregion
+export { Mutant as n, PositionSchema as r, LocationSchema as t };

package/dist/Plugin-Ceh1G8Dz.mjs

@@ -0,0 +1,117 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { t as Reporter } from "./Reporter-COVWW1my.mjs";
+import * as Context from "effect/Context";
+import * as S from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as Option from "effect/Option";
+//#region src/Plugin.schema.ts
+const PluginKind = S.Literals([
+	"Checker",
+	"TestRunner",
+	"Reporter",
+	"Ignore",
+	"Evaluator"
+]);
+var PluginContribution = class extends S.TaggedClass()("PluginContribution", {
+	kind: PluginKind,
+	name: S.String,
+	layer: S.Unknown
+}) {};
+var Shadowing = class extends S.TaggedClass()("Shadowing", {
+	kind: S.String,
+	name: S.String,
+	shadowedIndex: S.Finite,
+	winnerIndex: S.Finite
+}) {};
+//#endregion
+//#region src/Plugin.ts
+var Plugin_exports = /* @__PURE__ */ __exportAll({
+	PluginContribution: () => PluginContribution,
+	PluginKind: () => PluginKind,
+	RunConfiguration: () => RunConfiguration,
+	SandboxDirectory: () => SandboxDirectory,
+	Shadowing: () => Shadowing,
+	composePlugins: () => composePlugins,
+	declarePlugin: () => declarePlugin
+});
+var RunConfiguration = class extends Context.Service()("~@systemfsoftware/stryker-js/RunConfiguration") {};
+var SandboxDirectory = class extends Context.Service()("~@systemfsoftware/stryker-js/SandboxDirectory") {};
+function declarePlugin(kind, name, layer) {
+	return new PluginContribution({
+		kind,
+		name,
+		layer
+	});
+}
+function foldContributions(contributions) {
+	const resolved = MutableHashMap.empty();
+	const shadowings = [];
+	const lastSeen = MutableHashMap.empty();
+	for (const [index, contribution] of contributions.entries()) {
+		const key = `${contribution.kind}:${contribution.name}`;
+		const previous = MutableHashMap.get(lastSeen, key);
+		if (Option.isSome(previous)) shadowings.push(new Shadowing({
+			kind: String(contribution.kind),
+			name: contribution.name,
+			shadowedIndex: previous.value,
+			winnerIndex: index
+		}));
+		MutableHashMap.set(resolved, key, contribution);
+		MutableHashMap.set(lastSeen, key, index);
+	}
+	return {
+		resolved,
+		shadowings
+	};
+}
+function composePlugins(contributions) {
+	const { resolved, shadowings } = foldContributions(contributions);
+	const allResolved = Array.from(MutableHashMap.values(resolved));
+	const reporterContributions = allResolved.filter((c) => c.kind === "Reporter");
+	const nonReporterLayers = allResolved.filter((c) => c.kind !== "Reporter").map((contribution) => contribution.layer);
+	let broadcastLayer;
+	if (reporterContributions.length > 0) broadcastLayer = Layer.effect(Reporter, Effect.gen(function* () {
+		const config = yield* RunConfiguration;
+		const wantedNames = {};
+		for (const name of config.reporters) wantedNames[name.toLowerCase()] = true;
+		const selected = reporterContributions.filter((c) => c.name.toLowerCase() in wantedNames);
+		const sandboxOption = yield* Effect.serviceOption(SandboxDirectory);
+		const namedReporters = [];
+		for (const contribution of selected) {
+			let buildEffect = Layer.build(contribution.layer).pipe(Effect.provideService(RunConfiguration, config));
+			if (Option.isSome(sandboxOption)) buildEffect = buildEffect.pipe(Effect.provideService(SandboxDirectory, sandboxOption.value));
+			const ctx = yield* buildEffect;
+			const reporter = Context.get(ctx, Reporter);
+			namedReporters.push({
+				name: contribution.name,
+				reporter
+			});
+		}
+		const toEach = (event, call) => Effect.forEach(namedReporters, ({ name, reporter }) => call(reporter).pipe(Effect.catchCause((cause) => Effect.logWarning(`Reporter "${name}" failed handling ${event}`).pipe(Effect.annotateLogs("cause", cause)))), {
+			concurrency: "unbounded",
+			discard: true
+		});
+		return {
+			onDryRunCompleted: (event) => toEach("onDryRunCompleted", (r) => r.onDryRunCompleted(event)),
+			onMutationTestingPlanReady: (event) => toEach("onMutationTestingPlanReady", (r) => r.onMutationTestingPlanReady(event)),
+			onMutantTested: (result) => toEach("onMutantTested", (r) => r.onMutantTested(result)),
+			onMutationTestReportReady: (report, metrics) => toEach("onMutationTestReportReady", (r) => r.onMutationTestReportReady(report, metrics)),
+			wrapUp: toEach("wrapUp", (r) => r.wrapUp)
+		};
+	}));
+	const allLayers = [...nonReporterLayers];
+	if (broadcastLayer !== void 0) allLayers.push(broadcastLayer);
+	if (allLayers.length === 0) return {
+		layer: Option.none(),
+		shadowings
+	};
+	const merged = allLayers.reduce((acc, next) => Layer.merge(acc, next));
+	return {
+		layer: Option.some(merged),
+		shadowings
+	};
+}
+//#endregion
+export { declarePlugin as a, Shadowing as c, composePlugins as i, RunConfiguration as n, PluginContribution as o, SandboxDirectory as r, PluginKind as s, Plugin_exports as t };