@systemfsoftware/stryker-plugins 0.8.0 → 0.9.0

package/README.md

@@ -33,15 +33,14 @@ Mutants it recognizes are reported as `Ignored`, each carrying the reason it was
 
 ## What it ignores
 
-| Declaration                                               | Example                                                             |
-| --------------------------------------------------------- | ------------------------------------------------------------------- |
-| Brand descriptions                                        | `Symbol.for('UserId')`                                              |
-| `TaggedClass` / `TaggedError` tags                        | `S.TaggedClass<A>()('Placed', {…})`                                 |
-| The field schemas of those declarations                   | the `{…}` above                                                     |
-| `optionalWith` defaults                                   | `S.optionalWith(S.Number, { default: () => 0 })`                    |
-| Documentation annotations                                 | `identifier`, `description`, `title`, `documentation`, `examples`   |
-| An `annotations({…})` object that is _only_ documentation | `S.annotations({ title: 'Amount' })`                                |
-| A `TemplateLiteral` head a piped `pattern` already forces | `S.TemplateLiteral('usr', S.String).pipe(S.pattern(/^usr[a-z]*$/))` |
+| Declaration                                               | Example                                                           |
+| --------------------------------------------------------- | ----------------------------------------------------------------- |
+| Brand descriptions                                        | `Symbol.for('UserId')`                                            |
+| `TaggedClass` / `TaggedError` tags                        | `S.TaggedClass<A>()('Placed', {…})`                               |
+| The field schemas of those declarations                   | the `{…}` above                                                   |
+| `optionalWith` defaults                                   | `S.optionalWith(S.Number, { default: () => 0 })`                  |
+| Documentation annotations                                 | `identifier`, `description`, `title`, `documentation`, `examples` |
+| An `annotations({…})` object that is _only_ documentation | `S.annotations({ title: 'Amount' })`                              |
 
 ## Where the line is
 
@@ -49,8 +48,6 @@ Every ignore is proven redundant, never merely assumed — anything a test could
 
 `arbitrary`, `pretty`, `equivalence`, `message`, `jsonSchema` and `parseIssueTitle` are **not** documentation: each changes what the schema does, so a survivor there is a test gap to close. That is why the two `annotations` rules differ — a `title` is ignored wherever it appears, but the enclosing object is ignored only when every entry documents, since emptying an object holding an `arbitrary` would silently change what your property tests generate.
 
-The `TemplateLiteral` head is ignored only where the piped pattern makes it unobservable: the head must be the first span with no regex metacharacters, and the pattern must be an unflagged regex literal opening `^` + that head, with no quantifier making its final character optional. A head with no pattern keeps its mutants, and so do `/^usr?…/`, `/^usr…/i`, `/^usr…/m`, and every span past the first.
-
 ## Contributing
 
 Development setup and workflow: [AGENTS.md](AGENTS.md).

package/dist/{effect-schema-ignorer-C8RpAXcS.mjs → effect-schema-ignorer-CYdHdByP.mjs}

@@ -9,11 +9,6 @@ const StringLiteral = Schema.Struct({
 	type: Schema.Literal("StringLiteral"),
 	value: Schema.String
 });
-const RegExpLiteral = Schema.Struct({
-	type: Schema.Literal("RegExpLiteral"),
-	pattern: Schema.String,
-	flags: Schema.String
-});
 const ObjectExpression = Schema.Struct({ type: Schema.Literal("ObjectExpression") });
 const ArrowFunctionExpression = Schema.Struct({ type: Schema.Literal("ArrowFunctionExpression") });
 const UnknownNode = Schema.Struct({ type: Schema.String });
@@ -27,7 +22,7 @@ const CallExpression = Schema.suspend(() => Schema.Struct({
 	callee: Schema.suspend(() => AstNode),
 	arguments: Schema.Array(Schema.suspend(() => AstNode))
 }));
-const AstNode = Schema.suspend(() => Schema.Union(Identifier, StringLiteral, RegExpLiteral, ObjectExpression, ArrowFunctionExpression, MemberExpression, CallExpression, UnknownNode));
+const AstNode = Schema.suspend(() => Schema.Union(Identifier, StringLiteral, ObjectExpression, ArrowFunctionExpression, MemberExpression, CallExpression, UnknownNode));
 //#endregion
 //#region src/effect-schema-ignorer/schema-declaration-ignore.ts
 const SYMBOL_DESCRIPTION_IGNORED = "Symbol.for() brand description is identity-only data, not behaviour";
@@ -36,7 +31,6 @@ const TAGGED_FIELDS_IGNORED = "TaggedClass/TaggedError field schema is a declara
 const OPTIONAL_DEFAULT_IGNORED = "optionalWith default value is config, not behaviour";
 const ANNOTATION_OBJECT_IGNORED = "annotations object holding only documentation is a declaration, not behaviour";
 const ANNOTATION_TEXT_IGNORED = "annotation documentation value is declaration data, not behaviour";
-const TEMPLATE_HEAD_IGNORED = "TemplateLiteral head re-stated by an anchored pattern filter is a declaration of the encoded type, not behaviour";
 /**
 * The Effect `Schema` annotations that describe a schema without changing what
 * it does. `arbitrary`, `pretty`, `equivalence`, `message`, `jsonSchema` and
@@ -75,7 +69,6 @@ const isMemberExpression = Schema.is(MemberExpression);
 const isCallExpression = Schema.is(CallExpression);
 const isDocumentationProperty = Schema.is(DocumentationProperty);
 const isDocumentationObject = Schema.is(DocumentationObject);
-const isRegExpLiteral = Schema.is(RegExpLiteral);
 const isNamedMember = (node, object, property) => isMemberExpression(node) && isIdentifier(node.object) && node.object.name === object && isIdentifier(node.property) && node.property.name === property;
 const isSymbolForCallee = (callee) => isNamedMember(callee, "Symbol", "for");
 const isTaggedFactoryReference = (reference) => isMemberExpression(reference) && isIdentifier(reference.property) && TAGGED_FACTORIES.includes(reference.property.name);
@@ -83,41 +76,6 @@ const isTaggedFactoryCallee = (callee) => isCallExpression(callee) && isTaggedFa
 const isArgumentOf = (node, parent, index, calleeMatches) => isCallExpression(parent) && calleeMatches(parent.callee) && parent.arguments[index] === node;
 const isOptionalWithCallee = (callee) => isNamedMember(callee, "S", "optionalWith");
 const isAnnotationsCallee = (callee) => isMemberExpression(callee) && isIdentifier(callee.property) && callee.property.name === "annotations";
-/**
-* A head whose every character stands for itself inside a regex. `a.b` is
-* excluded because `^a.b` would also admit `axb`, which the head refuses.
-*/
-const REGEX_INERT_HEAD = /^[A-Za-z0-9_]+$/;
-/** `?`, `*` and `{` make the character before them optional, so `^usr?` never forces the `r`. */
-const OPTIONAL_QUANTIFIERS = [
-	"?",
-	"*",
-	"{"
-];
-const isNamedMethodCallee = (callee, method) => isMemberExpression(callee) && isIdentifier(callee.property) && callee.property.name === method;
-/**
-* Whether an unflagged, `^`-anchored regex admits only strings opening with
-* `head`. Flags are refused outright: `i` would admit another casing and `m`
-* would let `^` match a line start, and the head rejects both — so it decides.
-*/
-const forcesPrefix = (regex, head) => isRegExpLiteral(regex) && regex.flags === "" && regex.pattern.startsWith(`^${head}`) && !OPTIONAL_QUANTIFIERS.includes(regex.pattern.charAt(head.length + 1));
-const patternForcesPrefix = (argument, head) => isCallExpression(argument) && isNamedMethodCallee(argument.callee, "pattern") && argument.arguments.some((regex) => forcesPrefix(regex, head));
-/**
-* The head of a `TemplateLiteral` piped straight into a `pattern` that already
-* forces that same prefix. Effect rejects refinements as spans, so a prefixed
-* wire format can only earn its `` `${head}${string}` `` type this way, and the
-* prefix ends up stated twice by construction. Emptying the head then changes
-* nothing observable: the filter still refuses every input the head would have
-* refused, and Effect derives the arbitrary from the filter's regex rather than
-* the head. Only the encoded *type* moves, which no test can see.
-*
-* Restricted to argument 0: a trailing span sits past the anchor, so an
-* anchored prefix proves nothing about it and its mutants stay.
-*/
-const templateHeadRule = {
-	matches: (node, parent, grandparent, ancestor) => isStringLiteral(node) && REGEX_INERT_HEAD.test(node.value) && isArgumentOf(node, parent, 0, (callee) => isNamedMethodCallee(callee, "TemplateLiteral")) && isMemberExpression(grandparent) && grandparent.object === parent && isIdentifier(grandparent.property) && grandparent.property.name === "pipe" && isCallExpression(ancestor) && ancestor.callee === grandparent && ancestor.arguments.some((argument) => patternForcesPrefix(argument, node.value)),
-	reason: TEMPLATE_HEAD_IGNORED
-};
 const argumentRule = (is, argumentIndex, calleeMatches, reason) => ({
 	matches: (node, parent) => is(node) && isArgumentOf(node, parent, argumentIndex, calleeMatches),
 	reason
@@ -139,8 +97,7 @@ const RULES = [
 	argumentRule(isObjectExpression, 1, isTaggedFactoryCallee, TAGGED_FIELDS_IGNORED),
 	argumentRule(isArrowFunctionExpression, 1, isOptionalWithCallee, OPTIONAL_DEFAULT_IGNORED),
 	argumentRule(isDocumentationObject, 0, isAnnotationsCallee, ANNOTATION_OBJECT_IGNORED),
-	documentationValueRule,
-	templateHeadRule
+	documentationValueRule
 ];
 const decideSchemaDeclarationIgnore = (node, parent, grandparent, ancestor) => RULES.find((rule) => rule.matches(node, parent, grandparent, ancestor))?.reason;
 //#endregion

package/dist/effect-schema-ignorer.mjs

@@ -1,2 +1,2 @@
-import { t as strykerPlugins } from "./effect-schema-ignorer-C8RpAXcS.mjs";
+import { t as strykerPlugins } from "./effect-schema-ignorer-CYdHdByP.mjs";
 export { strykerPlugins };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { t as strykerPlugins$2 } from "./effect-schema-ignorer-C8RpAXcS.mjs";
+import { t as strykerPlugins$2 } from "./effect-schema-ignorer-CYdHdByP.mjs";
 import { PluginKind, declareValuePlugin } from "@stryker-mutator/api/plugin";
 import { Schema } from "effect";
 //#region src/in-source-test-ignorer/ast-node.schema.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/stryker-plugins",
   "license": "MIT",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -53,12 +53,12 @@
     "vitest": "^4",
     "@systemfsoftware/arethetypeswrong-cli": "^1.0.7",
     "@systemfsoftware/effect-schema-law": "^0.5.0",
-    "@systemfsoftware/oxlint-config": "^0.1.0",
     "@systemfsoftware/effect-schema-vite": "^1.4.0",
+    "@systemfsoftware/oxlint-config": "^0.1.0",
     "@systemfsoftware/stryker-js-core": "^1.1.6",
+    "@systemfsoftware/stryker-js-typescript-checker": "^1.1.6",
     "@systemfsoftware/tsconfig": "^1.2.6",
-    "@systemfsoftware/vitest-config": "^0.1.0",
-    "@systemfsoftware/stryker-js-typescript-checker": "^1.1.6"
+    "@systemfsoftware/vitest-config": "^0.1.0"
   },
   "peerDependencies": {
     "@stryker-mutator/api": "^9.6.1",