@sarj/eslint-plugin 19.8.0 → 19.9.0

package/dist/catalog.js

@@ -2,7 +2,7 @@ import {
   publicDocumentation,
   ruleSpec,
   src_default
-} from "./chunk-G5BIV4A4.js";
+} from "./chunk-MFL7OATV.js";
 
 // src/docs/directive-disable-enable-pair.ts
 var DIRECTIVE_DISABLE_ENABLE_PAIR_DOCUMENTATION = {
@@ -4527,11 +4527,11 @@ var PREFER_DISCRIMINATED_UNION_DOCUMENTATION = {
   category: "correctness",
   autofix: "safe",
   limitations: [
-    "Names, Boolean counts and optional-field counts never establish a finding. A producer's direct literal writes establish either tag-specific payload presence or a pair of required Boolean fields with two or three distinct combinations, with both fields varying. All four combinations, constant dimensions and expression-valued flags are excluded. At most eight Boolean fields are compared. Only one relationship is reported per contract; payload evidence takes precedence.",
-    "Producer analysis requires a finite literal tag, every declared tag syntactically witnessed, exhaustive simple return paths without literal constant conditions, plain object returns, and consistent optional-field presence for each tag. It resolves only unmerged local aliases/interfaces without inheritance or generics, and the built-in Promise around async returns. This is syntax-only evidence of field presence; explicit undefined, void and null payloads are skipped, while expression value types are not inferred. Dynamic returns, spreads, computed keys, accessors, loops and try statements are deliberately skipped.",
-    "A switch producer is supported only for a non-overloaded function declaration when its sole body statement switches on an unchanged direct string or number parameter, has unique same-kind literal labels and a default, and every nonempty case body is a sole object return or throw, optionally inside sole blocks. Empty labels may share the next terminating body; nested conditions, conditional returns, statement prefixes, breaks, other fallthrough, captured/closed inputs and switches under preceding control flow abstain. Broad parameter domains establish input witnesses for each label and the default; this does not infer branch-specific runtime effects or expression value types. Path visits, depth and returned objects are bounded conservatively.",
+    "Names, Boolean counts and optional-field counts never establish a finding. A producer's literal writes establish either tag-specific payload presence or a pair of required Boolean fields with two or three distinct combinations, with both fields varying. Boolean members may use boolean, true | false or one unmerged nongeneric local alias of either. All four combinations, constant dimensions, optional/unknown dimensions and expression-valued flags are excluded. At most eight Boolean fields are compared. Only one relationship is reported per contract; payload evidence takes precedence. Independently nullable payloads do not erase Boolean evidence.",
+    "Producer analysis requires a finite literal tag, every declared tag syntactically witnessed, exhaustive simple return paths without literal constant conditions, plain object returns, and consistent optional-field presence for each tag. It resolves only unmerged local aliases/interfaces without inheritance or generics, one local alias of a literal tag domain, and the built-in Promise around async returns. Callable or opaque own then properties abstain for async producers because Promise assimilation can replace the fulfilled value. Inherited then methods and external prototype mutation are not modeled. This is syntax-only evidence of field presence; explicit undefined, void and null payloads do not establish payload requirements, while expression value types are not inferred. Type-only assertion/satisfies/non-null wrappers, literal computed string keys and a sole-use const immediately before its return are recognized. Const alias chains, observation, mutation and dynamic eval abstain. Dynamic returns, spreads, dynamic computed keys, accessors, loops and try statements are deliberately skipped.",
+    "A switch producer is supported only for a non-overloaded function declaration when its sole body statement switches on an unchanged direct string or number parameter, has unique same-kind literal labels and a default, and every nonempty case body is a sole object return or throw, optionally inside sole blocks. Empty labels may share the next terminating body; nested conditions, conditional returns, statement prefixes, breaks, other fallthrough, captured/closed inputs, dynamic eval and switches under preceding control flow abstain. Broad parameter domains establish input witnesses for each label and the default; this does not infer branch-specific runtime effects or expression value types. Path visits, depth and returned objects are bounded conservatively.",
     "These are refactoring advisories, not proven defects or proof that other writers cannot produce more states. Historical observations, partial results, unknown states and independently completing operations may need the broader contract. Review all readers and writers before migrating a shared contract; preserve every valid combination. A union of existing literal flag pairs is the smallest type-only replacement; a named disposition is a reviewed domain migration.",
-    "Automatic fixes are limited to an unused private nongeneric synchronous function with a direct inline contract and one conditional return containing at most four literal objects. They narrow only the existing discriminator or implicated Boolean pair and preserve other member types and all runtime code, including condition evaluation, object creation, identity and exceptions. Nested conditionals are supported. Shared/observed contracts, aliases, exports, async functions, comments, expression payloads and generated/declaration/test files remain excluded. Public interfaces, serialization and cancellation are never rewritten."
+    "Automatic fixes are limited to an unused private nongeneric synchronous function with a direct inline contract and one conditional return containing at most four bare literal objects. Boolean-pair fixes narrow only the implicated pair, retaining every unrelated member's type, readonly modifier and optionality. Tag/payload fixes express the produced state-specific payload presence while preserving declared payload value types. All runtime code, condition evaluation, object creation, identity and exceptions remain unchanged. Nested conditionals are supported. Assertion/satisfies wrappers, shared/observed contracts, aliases, exports, async functions, comments, expression payloads and generated/declaration/test files remain excluded. Public interfaces, serialization and cancellation are never rewritten."
   ],
   references: ["https://functional-architecture.org/make_illegal_states_unrepresentable/", "https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions"],
   examples: [

package/dist/{chunk-G5BIV4A4.js → chunk-MFL7OATV.js}

@@ -22449,14 +22449,19 @@ function discriminatedUnionReturns(node, sourceCode2) {
   if (shape === void 0) return void 0;
   const returned2 = returnedProperties(paths.objects, shape);
   if (returned2 === void 0) return void 0;
+  if (node.async && returned2.some((properties2) => {
+    const then = properties2.get("then");
+    return then !== void 0 && (then.type !== "Literal" || typeof then.value === "object" && then.value !== null);
+  })) return void 0;
+  const emptyPayload = returned2.some((properties2) => hasEmptyPayload(properties2, shape.optional));
   for (const [name, member3] of shape.members) {
-    if (member3.optional) continue;
-    const domain = tagDomain(member3.typeAnnotation?.typeAnnotation);
+    if (member3.optional || emptyPayload) continue;
+    const domain = tagDomain(member3.typeAnnotation?.typeAnnotation, sourceCode2);
     if (domain !== void 0 && hasTagSpecificPayload(name, domain, shape.optional, returned2)) {
       return { reportNode: contract.reportNode, relationship: { kind: "presence", tag: name }, members: shape.members, returned: returned2 };
     }
   }
-  const fields2 = correlatedBooleanFields(shape, returned2);
+  const fields2 = correlatedBooleanFields(shape, returned2, sourceCode2);
   return fields2 === void 0 ? void 0 : {
     reportNode: contract.reportNode,
     relationship: { kind: "boolean-pair", fields: fields2 },
@@ -22464,8 +22469,8 @@ function discriminatedUnionReturns(node, sourceCode2) {
     returned: returned2
   };
 }
-function correlatedBooleanFields(shape, returned2) {
-  const fields2 = [...shape.members].filter(([, member3]) => !member3.optional && member3.typeAnnotation?.typeAnnotation.type === "TSBooleanKeyword").map(([name]) => name);
+function correlatedBooleanFields(shape, returned2, sourceCode2) {
+  const fields2 = [...shape.members].filter(([, member3]) => !member3.optional && booleanType(member3.typeAnnotation?.typeAnnotation, sourceCode2)).map(([name]) => name);
   if (fields2.length > 8) return void 0;
   for (const [index, left] of fields2.entries()) {
     for (const right of fields2.slice(index + 1)) {
@@ -22475,6 +22480,10 @@ function correlatedBooleanFields(shape, returned2) {
   }
   return void 0;
 }
+function booleanType(type, sourceCode2) {
+  const domain = tagDomain(type, sourceCode2);
+  return domain?.size === 2 && domain.has(true) && domain.has(false);
+}
 function booleanCombinations(left, right, returned2) {
   const combinations = /* @__PURE__ */ new Set();
   for (const properties2 of returned2) {
@@ -22514,15 +22523,7 @@ function returnContract(node, sourceCode2) {
 }
 function definitions(reference, sourceCode2) {
   if (reference.typeName.type !== "Identifier") return [];
-  let scope = sourceCode2.getScope(reference);
-  while (scope !== null) {
-    const found = scope.set.get(reference.typeName.name);
-    const binding3 = found === void 0 ? void 0 : tsVariable(found);
-    const typeDefinitions2 = binding3?.defs.filter((definition) => definition.isTypeDefinition) ?? [];
-    if (typeDefinitions2.length > 0 || binding3?.isTypeVariable === true) return typeDefinitions2;
-    scope = scope.upper;
-  }
-  return [];
+  return typeBinding(sourceCode2, reference.typeName)?.defs.filter((definition) => definition.isTypeDefinition) ?? [];
 }
 function objectContract(elements) {
   const members2 = /* @__PURE__ */ new Map();
@@ -22543,7 +22544,6 @@ function returnedProperties(objects, contract) {
     if (properties2 === void 0) return void 0;
     if ([...properties2.keys()].some((name) => !contract.members.has(name))) return void 0;
     if ([...contract.members].some(([name, member3]) => !member3.optional && !properties2.has(name))) return void 0;
-    if (hasEmptyPayload(properties2, contract.optional)) return void 0;
     returned2.push(properties2);
   }
   return returned2;
@@ -22568,7 +22568,13 @@ function hasEmptyPayload(properties2, optional) {
   }
   return false;
 }
-function tagDomain(node) {
+function tagDomain(node, sourceCode2) {
+  if (node?.type === "TSTypeReference" && !isPresent(node.typeArguments)) {
+    const bindings = definitions(node, sourceCode2);
+    const declaration = bindings.length === 1 ? bindings[0]?.node : void 0;
+    if (declaration?.type !== "TSTypeAliasDeclaration" || isPresent(declaration.typeParameters)) return void 0;
+    node = declaration.typeAnnotation;
+  }
   if (node?.type === "TSBooleanKeyword") return /* @__PURE__ */ new Set([true, false]);
   if (node?.type !== "TSUnionType") return void 0;
   const values = /* @__PURE__ */ new Set();
@@ -22648,6 +22654,7 @@ function reachableSwitch(statement, sourceCode2) {
   return kind !== void 0 && reachableSwitchLabels(statement, kind);
 }
 function broadSwitchInput(statement, sourceCode2) {
+  if (hasIdentifierNamed(sourceCode2, "eval")) return void 0;
   const body3 = statement.parent;
   if (body3.type !== "BlockStatement" || body3.body.length !== 1) return void 0;
   const owner = body3.parent;
@@ -22699,6 +22706,13 @@ function statementsPaths(statements, budget, depth) {
 }
 function returnedObjects(expression, budget, depth) {
   if (!budget.within(depth)) return void 0;
+  if (isErasedExpression(expression)) {
+    return returnedObjects(expression.expression, budget, depth + 1);
+  }
+  if (expression.type === "Identifier") {
+    const initializer = closedReturnInitializer(expression, budget.sourceCode);
+    return initializer === void 0 ? void 0 : returnedObjects(initializer, budget, depth + 1);
+  }
   if (expression.type === "ObjectExpression") {
     return budget.recordObject() ? [expression] : void 0;
   }
@@ -22707,10 +22721,21 @@ function returnedObjects(expression, budget, depth) {
   const alternate = returnedObjects(expression.alternate, budget, depth + 1);
   return consequent === void 0 || alternate === void 0 ? void 0 : [...consequent, ...alternate];
 }
+function closedReturnInitializer(identifier, sourceCode2) {
+  const returned2 = identifier.parent;
+  if (returned2.type !== "ReturnStatement" || returned2.argument !== identifier || returned2.parent.type !== "BlockStatement" || hasIdentifierNamed(sourceCode2, "eval")) return void 0;
+  const block = returned2.parent;
+  const declaration = block.body[block.body.indexOf(returned2) - 1];
+  if (declaration?.type !== "VariableDeclaration" || declaration.kind !== "const" || declaration.declarations.length !== 1) return void 0;
+  const value = declaration.declarations[0];
+  if (value?.id.type !== "Identifier" || value.id.name !== identifier.name || value.init === null) return void 0;
+  const binding3 = findVariable(sourceCode2.getScope(identifier), identifier.name);
+  if (binding3?.defs.length !== 1 || binding3.defs[0]?.node !== value || binding3.eslintUsed || !binding3.references.some((reference) => reference.identifier === identifier && reference.isRead()) || binding3.references.some((reference) => reference.isWrite() ? reference.init !== true : reference.identifier !== identifier)) return void 0;
+  return value.init;
+}
 function propertyName(node) {
-  if (node.computed) return void 0;
-  if (node.key.type === "Identifier") return node.key.name;
   if (node.key.type === "Literal" && typeof node.key.value === "string") return node.key.value;
+  if (!node.computed && node.key.type === "Identifier") return node.key.name;
   return void 0;
 }
 function literalTag(node) {
@@ -22781,19 +22806,27 @@ function returnsOnlyConditionalObject(fn) {
   if (fn.async || fn.generator || isPresent(fn.typeParameters)) return false;
   const statements = fn.body?.body ?? [];
   const [returned2] = statements;
-  return statements.length === 1 && returned2?.type === "ReturnStatement" && returned2.argument?.type === "ConditionalExpression";
+  return statements.length === 1 && returned2?.type === "ReturnStatement" && returned2.argument?.type === "ConditionalExpression" && bareConditionalObjects(returned2.argument);
+}
+function bareConditionalObjects(expression) {
+  return expression.type === "ObjectExpression" || expression.type === "ConditionalExpression" && bareConditionalObjects(expression.consequent) && bareConditionalObjects(expression.alternate);
 }
 function privateVariantType(properties2, result, sourceCode2) {
   if ([...properties2.values()].some((value) => value.type !== "Literal" || typeof value.value === "object" && value.value !== null || typeof value.value === "number" && !Number.isFinite(value.value))) return null;
   const fields2 = [];
   for (const [name, member3] of result.members) {
     const value = properties2.get(name);
-    if (value === void 0) continue;
+    if (value === void 0 && result.relationship.kind === "presence") continue;
     const annotation = member3.typeAnnotation?.typeAnnotation;
     if (annotation === void 0) return null;
     const narrow = result.relationship.kind === "presence" ? name === result.relationship.tag : name === result.relationship.fields.left || name === result.relationship.fields.right;
-    const type = narrow ? sourceCode2.getText(value) : sourceCode2.getText(annotation);
-    fields2.push(`${member3.readonly ? "readonly " : ""}${sourceCode2.getText(member3.key)}: ${type}`);
+    let type = sourceCode2.getText(annotation);
+    if (narrow) {
+      if (value === void 0) return null;
+      type = sourceCode2.getText(value);
+    }
+    const optional = result.relationship.kind === "boolean-pair" && !narrow && member3.optional;
+    fields2.push(`${member3.readonly ? "readonly " : ""}${sourceCode2.getText(member3.key)}${optional ? "?" : ""}: ${type}`);
   }
   return `{ ${fields2.join("; ")} }`;
 }

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   src_default
-} from "./chunk-G5BIV4A4.js";
+} from "./chunk-MFL7OATV.js";
 export {
   src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarj/eslint-plugin",
-  "version": "19.8.0",
+  "version": "19.9.0",
   "packageManager": "npm@12.2.1",
   "description": "Custom Oxlint rules for hypermodern TypeScript / React / Next.js projects",
   "type": "module",