@codeperfect/eslint-plugin 2.6.0 → 2.8.0

package/dist/domain/core/prefer-interface-types/naming.js

@@ -0,0 +1,179 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { collectTopLevelNames } from "./declaration-names.js";
+/**
+ * Allocates unique PascalCase names for collected inline object types.
+ * @param matches Collected inline object types in report order.
+ * @param topLevelStatements Program statements used for collision detection.
+ * @param reservedNames Names declared in lexical scopes that could capture a generated reference.
+ * @returns Matches paired with collision-free names.
+ * @example
+ * ```typescript
+ * const namedMatches = allocateNames(matches, program.body);
+ * ```
+ */
+function allocateNames(matches, topLevelStatements, reservedNames = new Set()) {
+    const usedNames = collectTopLevelNames(topLevelStatements);
+    for (const reservedName of reservedNames) {
+        usedNames.add(reservedName);
+    }
+    return matches.map((match) => {
+        const fallback = match.baseName === "Parameter" ? "Parameter" : "Type";
+        const preferredName = toPascalCase(match.baseName, fallback);
+        let name = preferredName;
+        let suffix = 1;
+        while (usedNames.has(name)) {
+            name = `${preferredName}${String(suffix)}`;
+            suffix += 1;
+        }
+        usedNames.add(name);
+        return { ...match, name };
+    });
+}
+/**
+ * Narrows an unknown value to the small naming node surface.
+ * @param value Candidate node value.
+ * @returns Naming node when the value is object-like.
+ * @example
+ * ```typescript
+ * const node = asNamingNode(value);
+ * ```
+ */
+function asNamingNode(value) {
+    return value !== null && typeof value === "object" ? value : void 0;
+}
+/**
+ * Returns an identifier name when the supplied value is an identifier node.
+ * @param value Candidate identifier node.
+ * @returns Identifier name when present.
+ * @example
+ * ```typescript
+ * const name = getIdentifierName(node);
+ * ```
+ */
+function getIdentifierName(value) {
+    const node = asNamingNode(value);
+    return node?.type === AST_NODE_TYPES.Identifier &&
+        typeof node.name === "string"
+        ? node.name
+        : void 0;
+}
+/**
+ * Gets an identifier name from a parameter, including supported wrappers.
+ * @param parameter Parameter node to inspect.
+ * @returns Parameter identifier or the required fallback.
+ * @example
+ * ```typescript
+ * const name = getParameterBaseName(parameter);
+ * ```
+ */
+function getParameterBaseName(parameter) {
+    let node = asNamingNode(parameter);
+    while (node !== void 0) {
+        if (node.type === AST_NODE_TYPES.Identifier &&
+            typeof node.name === "string") {
+            return node.name;
+        }
+        if (node.type === AST_NODE_TYPES.RestElement) {
+            node = asNamingNode(node.argument);
+            continue;
+        }
+        if (node.type === AST_NODE_TYPES.AssignmentPattern) {
+            node = asNamingNode(node.left);
+            continue;
+        }
+        if (node.type === AST_NODE_TYPES.TSParameterProperty) {
+            node = asNamingNode(node.parameter);
+            continue;
+        }
+        break;
+    }
+    return "Parameter";
+}
+/**
+ * Returns a static identifier or string-literal property name.
+ * @param value Candidate property key.
+ * @returns Static property name when present.
+ * @example
+ * ```typescript
+ * const name = getPropertyName(node.key);
+ * ```
+ */
+function getPropertyName(value) {
+    const node = asNamingNode(value);
+    if (node?.type === AST_NODE_TYPES.Identifier &&
+        typeof node.name === "string") {
+        return node.name;
+    }
+    if (node?.type === AST_NODE_TYPES.Literal) {
+        const literalValue = node.value;
+        return typeof literalValue === "string" ? literalValue : void 0;
+    }
+    return void 0;
+}
+/**
+ * Resolves the nearest declared name for a function-like return type.
+ * @param functionNode Function-like node owning the return annotation.
+ * @returns Nearby identifier or the anonymous-context fallback.
+ * @example
+ * ```typescript
+ * const name = getReturnBaseName(functionNode);
+ * ```
+ */
+function getReturnBaseName(functionNode) {
+    const node = asNamingNode(functionNode);
+    if (node === void 0) {
+        return "Type";
+    }
+    const ownIdentifier = getIdentifierName(node.id) ?? getPropertyName(node.key);
+    if (ownIdentifier !== void 0) {
+        return ownIdentifier;
+    }
+    let current = node.parent;
+    while (current !== null && current !== void 0) {
+        if (current.type === AST_NODE_TYPES.VariableDeclarator) {
+            return getIdentifierName(current.id) ?? "Type";
+        }
+        const propertyName = getPropertyName(current.key);
+        if (propertyName !== void 0) {
+            return propertyName;
+        }
+        current = current.parent;
+    }
+    return "Type";
+}
+/**
+ * Gets the declared identifier for a variable annotation.
+ * @param variableNode Variable declarator node.
+ * @returns Variable identifier or the anonymous-context fallback.
+ * @example
+ * ```typescript
+ * const name = getVariableBaseName(variableNode);
+ * ```
+ */
+function getVariableBaseName(variableNode) {
+    return getIdentifierName(asNamingNode(variableNode)?.id) ?? "Type";
+}
+/**
+ * Converts an identifier-like value to a small PascalCase name.
+ * @param value Identifier-like source value.
+ * @param fallback Name used when the value has no ASCII word characters.
+ * @returns PascalCase name suitable for a generated interface.
+ * @example
+ * ```typescript
+ * const name = toPascalCase("input_value", "Type");
+ * ```
+ */
+function toPascalCase(value, fallback) {
+    const words = value
+        .replaceAll(/([a-z\d])([A-Z])/g, "$1 $2")
+        .replaceAll(/[^A-Za-z\d]+/g, " ")
+        .trim()
+        .split(/\s+/)
+        .filter((word) => word.length > 0);
+    const name = words
+        .map((word) => word.slice(0, 1).toUpperCase() + word.slice(1))
+        .join("");
+    return name.length > 0 && !/^\d/.test(name) ? name : fallback;
+}
+export { allocateNames, getParameterBaseName, getReturnBaseName, getVariableBaseName, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"naming.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/naming.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAQ1D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAE3D;;;;;;;;;;GAUG;AACH,SAAS,aAAa,CACpB,OAAmC,EACnC,kBAAsC,EACtC,gBAAqC,IAAI,GAAG,EAAE;IAE9C,MAAM,SAAS,GAAG,oBAAoB,CAAC,kBAAkB,CAAC,CAAC;IAE3D,KAAK,MAAM,YAAY,IAAI,aAAa,EAAE,CAAC;QACzC,SAAS,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAC9B,CAAC;IAED,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QAC3B,MAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,KAAK,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC;QACvE,MAAM,aAAa,GAAG,YAAY,CAAC,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC7D,IAAI,IAAI,GAAG,aAAa,CAAC;QACzB,IAAI,MAAM,GAAG,CAAC,CAAC;QAEf,OAAO,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC3B,IAAI,GAAG,GAAG,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,CAAC,CAAC;QACd,CAAC;QAED,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAEpB,OAAO,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,CAAC;IAC5B,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,YAAY,CAAC,KAAc;IAClC,OAAO,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACtE,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,iBAAiB,CAAC,KAAc;IACvC,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IAEjC,OAAO,IAAI,EAAE,IAAI,KAAK,cAAc,CAAC,UAAU;QAC7C,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ;QAC7B,CAAC,CAAC,IAAI,CAAC,IAAI;QACX,CAAC,CAAC,KAAK,CAAC,CAAC;AACb,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,oBAAoB,CAAC,SAAkB;IAC9C,IAAI,IAAI,GAAG,YAAY,CAAC,SAAS,CAAC,CAAC;IAEnC,OAAO,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACvB,IACE,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;YACvC,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAC7B,CAAC;YACD,OAAO,IAAI,CAAC,IAAI,CAAC;QACnB,CAAC;QAED,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,WAAW,EAAE,CAAC;YAC7C,IAAI,GAAG,YAAY,CAAE,IAA+B,CAAC,QAAQ,CAAC,CAAC;YAC/D,SAAS;QACX,CAAC;QAED,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,iBAAiB,EAAE,CAAC;YACnD,IAAI,GAAG,YAAY,CAAE,IAA2B,CAAC,IAAI,CAAC,CAAC;YACvD,SAAS;QACX,CAAC;QAED,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,mBAAmB,EAAE,CAAC;YACrD,IAAI,GAAG,YAAY,CAAE,IAAgC,CAAC,SAAS,CAAC,CAAC;YACjE,SAAS;QACX,CAAC;QAED,MAAM;IACR,CAAC;IAED,OAAO,WAAW,CAAC;AACrB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,eAAe,CAAC,KAAc;IACrC,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IAEjC,IACE,IAAI,EAAE,IAAI,KAAK,cAAc,CAAC,UAAU;QACxC,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAC7B,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED,IAAI,IAAI,EAAE,IAAI,KAAK,cAAc,CAAC,OAAO,EAAE,CAAC;QAC1C,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC;QAEhC,OAAO,OAAO,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAClE,CAAC;IAED,OAAO,KAAK,CAAC,CAAC;AAChB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,iBAAiB,CAAC,YAAqB;IAC9C,MAAM,IAAI,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;IAExC,IAAI,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACpB,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,MAAM,aAAa,GAAG,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAE9E,IAAI,aAAa,KAAK,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,IAAI,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC;IAE1B,OAAO,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,CAAC,EAAE,CAAC;QAC9C,IAAI,OAAO,CAAC,IAAI,KAAK,cAAc,CAAC,kBAAkB,EAAE,CAAC;YACvD,OAAO,iBAAiB,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,MAAM,CAAC;QACjD,CAAC;QAED,MAAM,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAElD,IAAI,YAAY,KAAK,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAC3B,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,mBAAmB,CAAC,YAAqB;IAChD,OAAO,iBAAiB,CAAC,YAAY,CAAC,YAAY,CAAC,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC;AACrE,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,YAAY,CAAC,KAAa,EAAE,QAAgB;IACnD,MAAM,KAAK,GAAG,KAAK;SAChB,UAAU,CAAC,mBAAmB,EAAE,OAAO,CAAC;SACxC,UAAU,CAAC,eAAe,EAAE,GAAG,CAAC;SAChC,IAAI,EAAE;SACN,KAAK,CAAC,KAAK,CAAC;SACZ,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAErC,MAAM,IAAI,GAAG,KAAK;SACf,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SAC7D,IAAI,CAAC,EAAE,CAAC,CAAC;IAEZ,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC;AAChE,CAAC;AAED,OAAO,EACL,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,GACpB,CAAC","sourcesContent":["import { AST_NODE_TYPES } from \"@typescript-eslint/utils\";\n\nimport type {\n  InlineTypeMatch,\n  NamedInlineTypeMatch,\n  NamingNode,\n} from \"./types\";\n\nimport { collectTopLevelNames } from \"./declaration-names\";\n\n/**\n * Allocates unique PascalCase names for collected inline object types.\n * @param matches Collected inline object types in report order.\n * @param topLevelStatements Program statements used for collision detection.\n * @param reservedNames Names declared in lexical scopes that could capture a generated reference.\n * @returns Matches paired with collision-free names.\n * @example\n * ```typescript\n * const namedMatches = allocateNames(matches, program.body);\n * ```\n */\nfunction allocateNames(\n  matches: readonly InlineTypeMatch[],\n  topLevelStatements: readonly unknown[],\n  reservedNames: ReadonlySet<string> = new Set(),\n): NamedInlineTypeMatch[] {\n  const usedNames = collectTopLevelNames(topLevelStatements);\n\n  for (const reservedName of reservedNames) {\n    usedNames.add(reservedName);\n  }\n\n  return matches.map((match) => {\n    const fallback = match.baseName === \"Parameter\" ? \"Parameter\" : \"Type\";\n    const preferredName = toPascalCase(match.baseName, fallback);\n    let name = preferredName;\n    let suffix = 1;\n\n    while (usedNames.has(name)) {\n      name = `${preferredName}${String(suffix)}`;\n      suffix += 1;\n    }\n\n    usedNames.add(name);\n\n    return { ...match, name };\n  });\n}\n\n/**\n * Narrows an unknown value to the small naming node surface.\n * @param value Candidate node value.\n * @returns Naming node when the value is object-like.\n * @example\n * ```typescript\n * const node = asNamingNode(value);\n * ```\n */\nfunction asNamingNode(value: unknown): NamingNode | undefined {\n  return value !== null && typeof value === \"object\" ? value : void 0;\n}\n\n/**\n * Returns an identifier name when the supplied value is an identifier node.\n * @param value Candidate identifier node.\n * @returns Identifier name when present.\n * @example\n * ```typescript\n * const name = getIdentifierName(node);\n * ```\n */\nfunction getIdentifierName(value: unknown): string | undefined {\n  const node = asNamingNode(value);\n\n  return node?.type === AST_NODE_TYPES.Identifier &&\n    typeof node.name === \"string\"\n    ? node.name\n    : void 0;\n}\n\n/**\n * Gets an identifier name from a parameter, including supported wrappers.\n * @param parameter Parameter node to inspect.\n * @returns Parameter identifier or the required fallback.\n * @example\n * ```typescript\n * const name = getParameterBaseName(parameter);\n * ```\n */\nfunction getParameterBaseName(parameter: unknown): string {\n  let node = asNamingNode(parameter);\n\n  while (node !== void 0) {\n    if (\n      node.type === AST_NODE_TYPES.Identifier &&\n      typeof node.name === \"string\"\n    ) {\n      return node.name;\n    }\n\n    if (node.type === AST_NODE_TYPES.RestElement) {\n      node = asNamingNode((node as { argument?: unknown }).argument);\n      continue;\n    }\n\n    if (node.type === AST_NODE_TYPES.AssignmentPattern) {\n      node = asNamingNode((node as { left?: unknown }).left);\n      continue;\n    }\n\n    if (node.type === AST_NODE_TYPES.TSParameterProperty) {\n      node = asNamingNode((node as { parameter?: unknown }).parameter);\n      continue;\n    }\n\n    break;\n  }\n\n  return \"Parameter\";\n}\n\n/**\n * Returns a static identifier or string-literal property name.\n * @param value Candidate property key.\n * @returns Static property name when present.\n * @example\n * ```typescript\n * const name = getPropertyName(node.key);\n * ```\n */\nfunction getPropertyName(value: unknown): string | undefined {\n  const node = asNamingNode(value);\n\n  if (\n    node?.type === AST_NODE_TYPES.Identifier &&\n    typeof node.name === \"string\"\n  ) {\n    return node.name;\n  }\n\n  if (node?.type === AST_NODE_TYPES.Literal) {\n    const literalValue = node.value;\n\n    return typeof literalValue === \"string\" ? literalValue : void 0;\n  }\n\n  return void 0;\n}\n\n/**\n * Resolves the nearest declared name for a function-like return type.\n * @param functionNode Function-like node owning the return annotation.\n * @returns Nearby identifier or the anonymous-context fallback.\n * @example\n * ```typescript\n * const name = getReturnBaseName(functionNode);\n * ```\n */\nfunction getReturnBaseName(functionNode: unknown): string {\n  const node = asNamingNode(functionNode);\n\n  if (node === void 0) {\n    return \"Type\";\n  }\n\n  const ownIdentifier = getIdentifierName(node.id) ?? getPropertyName(node.key);\n\n  if (ownIdentifier !== void 0) {\n    return ownIdentifier;\n  }\n\n  let current = node.parent;\n\n  while (current !== null && current !== void 0) {\n    if (current.type === AST_NODE_TYPES.VariableDeclarator) {\n      return getIdentifierName(current.id) ?? \"Type\";\n    }\n\n    const propertyName = getPropertyName(current.key);\n\n    if (propertyName !== void 0) {\n      return propertyName;\n    }\n\n    current = current.parent;\n  }\n\n  return \"Type\";\n}\n\n/**\n * Gets the declared identifier for a variable annotation.\n * @param variableNode Variable declarator node.\n * @returns Variable identifier or the anonymous-context fallback.\n * @example\n * ```typescript\n * const name = getVariableBaseName(variableNode);\n * ```\n */\nfunction getVariableBaseName(variableNode: unknown): string {\n  return getIdentifierName(asNamingNode(variableNode)?.id) ?? \"Type\";\n}\n\n/**\n * Converts an identifier-like value to a small PascalCase name.\n * @param value Identifier-like source value.\n * @param fallback Name used when the value has no ASCII word characters.\n * @returns PascalCase name suitable for a generated interface.\n * @example\n * ```typescript\n * const name = toPascalCase(\"input_value\", \"Type\");\n * ```\n */\nfunction toPascalCase(value: string, fallback: string): string {\n  const words = value\n    .replaceAll(/([a-z\\d])([A-Z])/g, \"$1 $2\")\n    .replaceAll(/[^A-Za-z\\d]+/g, \" \")\n    .trim()\n    .split(/\\s+/)\n    .filter((word) => word.length > 0);\n\n  const name = words\n    .map((word) => word.slice(0, 1).toUpperCase() + word.slice(1))\n    .join(\"\");\n\n  return name.length > 0 && !/^\\d/.test(name) ? name : fallback;\n}\n\nexport {\n  allocateNames,\n  getParameterBaseName,\n  getReturnBaseName,\n  getVariableBaseName,\n};\n"]}

package/dist/domain/core/prefer-interface-types/rule-utilities.d.ts

@@ -1,5 +1,7 @@
 /** Type definition for type annotation nodes inspected by this rule. */
 interface TypeAnnotationNode {
+    /** Source range used for safe autofix replacement. */
+    range?: [number, number];
     /** Type field value. */
     type: string;
     /** Nested annotation for parenthesized types. */

package/dist/domain/core/prefer-interface-types/rule-utilities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule-utilities.ts"],"names":[],"mappings":"AAiCA,wEAAwE;AACxE,UAAU,kBAAkB;IAC1B,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IAEb,iDAAiD;IACjD,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB,8DAA8D;IAC9D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;CACnB;AAED,+EAA+E;AAC/E,UAAU,sBAAsB;IAC9B,iEAAiE;IACjE,EAAE,CAAC,EAAE,OAAO,CAAC;CACd;AA6BD;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,MAAM,OAAO,KACZ,kBAAkB,GAAG,SAavB,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,uBAAuB,GAC3B,MAAM,OAAO,KACZ,kBAAkB,GAAG,SAQvB,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,MAAM,OAAO,KAAG,OAAO,EAQ7C,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,0BAA0B,GAC9B,MAAM,kBAAkB,GAAG,SAAS,KACnC,kBAAkB,GAAG,SA8BvB,CAAC;AAEF,OAAO,EACL,0BAA0B,EAC1B,aAAa,EACb,uBAAuB,EACvB,qBAAqB,GACtB,CAAC;AACF,YAAY,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,CAAC"}
+{"version":3,"file":"rule-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule-utilities.ts"],"names":[],"mappings":"AAiCA,wEAAwE;AACxE,UAAU,kBAAkB;IAC1B,sDAAsD;IACtD,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEzB,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IAEb,iDAAiD;IACjD,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB,8DAA8D;IAC9D,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;CACnB;AAED,+EAA+E;AAC/E,UAAU,sBAAsB;IAC9B,iEAAiE;IACjE,EAAE,CAAC,EAAE,OAAO,CAAC;CACd;AA6BD;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,MAAM,OAAO,KACZ,kBAAkB,GAAG,SAavB,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,uBAAuB,GAC3B,MAAM,OAAO,KACZ,kBAAkB,GAAG,SAQvB,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,aAAa,GAAI,MAAM,OAAO,KAAG,OAAO,EAQ7C,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,0BAA0B,GAC9B,MAAM,kBAAkB,GAAG,SAAS,KACnC,kBAAkB,GAAG,SA8BvB,CAAC;AAEF,OAAO,EACL,0BAA0B,EAC1B,aAAa,EACb,uBAAuB,EACvB,qBAAqB,GACtB,CAAC;AACF,YAAY,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/domain/core/prefer-interface-types/rule-utilities.js

@@ -102,4 +102,4 @@ const getInlineObjectTypeLiteral = (node) => {
     return void 0;
 };
 export { getInlineObjectTypeLiteral, getParameters, getReturnTypeAnnotation, getTypeAnnotationNode, };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule-utilities.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["/** Type definition for function-like nodes carrying parameters and return types. */\ninterface FunctionLikeNode {\n  /** Params helper value. */\n  params?: unknown[];\n\n  /** ReturnType helper value. */\n  returnType?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for nodes that can wrap a single parameter-like child. */\ninterface ParameterContainer {\n  /** Argument helper value. */\n  argument?: unknown;\n\n  /** Left-side helper value used by assignment patterns. */\n  left?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n}\n\n/** Type definition for nodes exposing a nested type annotation wrapper. */\ninterface TypeAnnotationContainer {\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for type annotation nodes inspected by this rule. */\ninterface TypeAnnotationNode {\n  /** Type field value. */\n  type: string;\n\n  /** Nested annotation for parenthesized types. */\n  typeAnnotation?: unknown;\n\n  /** Nested member annotations for union/intersection types. */\n  types?: unknown[];\n}\n\n/** Type definition for variable declarator nodes with optional identifiers. */\ninterface VariableDeclaratorNode {\n  /** Identifier or binding pattern for the variable declarator. */\n  id?: unknown;\n}\n\n/**\n * Gets a nested type annotation from parameter wrappers.\n * @param node Parameter wrapper node.\n * @returns The nested type annotation when present.\n * @example\n * ```typescript\n * const annotation = getNestedTypeAnnotation({ argument: node });\n * ```\n */\nconst getNestedTypeAnnotation = (\n  node: ParameterContainer,\n): TypeAnnotationNode | undefined => {\n  if (node.argument !== void 0) {\n    return getTypeAnnotationNode(node.argument);\n  }\n\n  if (node.left !== void 0) {\n    return getTypeAnnotationNode(node.left);\n  }\n\n  if (node.parameter !== void 0) {\n    return getTypeAnnotationNode(node.parameter);\n  }\n\n  return void 0;\n};\n\n/**\n * Extracts the type annotation from a node.\n * @param node Node that may contain a type annotation.\n * @returns The type annotation when present.\n * @example\n * ```typescript\n * const annotation = getTypeAnnotationNode(node);\n * ```\n */\nconst getTypeAnnotationNode = (\n  node: unknown,\n): TypeAnnotationNode | undefined => {\n  if (node === null || typeof node !== \"object\") {\n    return void 0;\n  }\n\n  const directTypeAnnotation = (node as TypeAnnotationContainer).typeAnnotation\n    ?.typeAnnotation;\n\n  if (directTypeAnnotation !== void 0) {\n    return directTypeAnnotation;\n  }\n\n  return getNestedTypeAnnotation(node);\n};\n\n/**\n * Gets the return type annotation for a function-like node.\n * @param node Node that may contain a return type.\n * @returns The return type annotation when present.\n * @example\n * ```typescript\n * const annotation = getReturnTypeAnnotation(node);\n * ```\n */\nconst getReturnTypeAnnotation = (\n  node: unknown,\n): TypeAnnotationNode | undefined => {\n  if (node === null || typeof node !== \"object\") {\n    return void 0;\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return typedNode.returnType?.typeAnnotation;\n};\n\n/**\n * Gets getParameters.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getParameters();\n * ```\n */\nconst getParameters = (node: unknown): unknown[] => {\n  if (node === null || typeof node !== \"object\") {\n    return [];\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return Array.isArray(typedNode.params) ? typedNode.params : [];\n};\n\n/**\n * Finds an inline object type literal within a type annotation node.\n * @param node Type annotation node to inspect.\n * @returns The first inline object type literal when present.\n * @example\n * ```typescript\n * const inlineObjectType = getInlineObjectTypeLiteral(annotation);\n * ```\n */\nconst getInlineObjectTypeLiteral = (\n  node: TypeAnnotationNode | undefined,\n): TypeAnnotationNode | undefined => {\n  if (node === void 0) {\n    return void 0;\n  }\n\n  if (node.type === \"TSTypeLiteral\") {\n    return node;\n  }\n\n  if (node.type === \"TSParenthesizedType\") {\n    return getInlineObjectTypeLiteral(\n      node.typeAnnotation as TypeAnnotationNode | undefined,\n    );\n  }\n\n  if (node.type === \"TSUnionType\" || node.type === \"TSIntersectionType\") {\n    const nestedTypes = Array.isArray(node.types) ? node.types : [];\n\n    for (const nestedType of nestedTypes) {\n      const nestedInlineObjectType = getInlineObjectTypeLiteral(\n        nestedType as TypeAnnotationNode | undefined,\n      );\n\n      if (nestedInlineObjectType !== void 0) {\n        return nestedInlineObjectType;\n      }\n    }\n  }\n\n  return void 0;\n};\n\nexport {\n  getInlineObjectTypeLiteral,\n  getParameters,\n  getReturnTypeAnnotation,\n  getTypeAnnotationNode,\n};\nexport type { TypeAnnotationNode, VariableDeclaratorNode };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule-utilities.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["/** Type definition for function-like nodes carrying parameters and return types. */\ninterface FunctionLikeNode {\n  /** Params helper value. */\n  params?: unknown[];\n\n  /** ReturnType helper value. */\n  returnType?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for nodes that can wrap a single parameter-like child. */\ninterface ParameterContainer {\n  /** Argument helper value. */\n  argument?: unknown;\n\n  /** Left-side helper value used by assignment patterns. */\n  left?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n}\n\n/** Type definition for nodes exposing a nested type annotation wrapper. */\ninterface TypeAnnotationContainer {\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for type annotation nodes inspected by this rule. */\ninterface TypeAnnotationNode {\n  /** Source range used for safe autofix replacement. */\n  range?: [number, number];\n\n  /** Type field value. */\n  type: string;\n\n  /** Nested annotation for parenthesized types. */\n  typeAnnotation?: unknown;\n\n  /** Nested member annotations for union/intersection types. */\n  types?: unknown[];\n}\n\n/** Type definition for variable declarator nodes with optional identifiers. */\ninterface VariableDeclaratorNode {\n  /** Identifier or binding pattern for the variable declarator. */\n  id?: unknown;\n}\n\n/**\n * Gets a nested type annotation from parameter wrappers.\n * @param node Parameter wrapper node.\n * @returns The nested type annotation when present.\n * @example\n * ```typescript\n * const annotation = getNestedTypeAnnotation({ argument: node });\n * ```\n */\nconst getNestedTypeAnnotation = (\n  node: ParameterContainer,\n): TypeAnnotationNode | undefined => {\n  if (node.argument !== void 0) {\n    return getTypeAnnotationNode(node.argument);\n  }\n\n  if (node.left !== void 0) {\n    return getTypeAnnotationNode(node.left);\n  }\n\n  if (node.parameter !== void 0) {\n    return getTypeAnnotationNode(node.parameter);\n  }\n\n  return void 0;\n};\n\n/**\n * Extracts the type annotation from a node.\n * @param node Node that may contain a type annotation.\n * @returns The type annotation when present.\n * @example\n * ```typescript\n * const annotation = getTypeAnnotationNode(node);\n * ```\n */\nconst getTypeAnnotationNode = (\n  node: unknown,\n): TypeAnnotationNode | undefined => {\n  if (node === null || typeof node !== \"object\") {\n    return void 0;\n  }\n\n  const directTypeAnnotation = (node as TypeAnnotationContainer).typeAnnotation\n    ?.typeAnnotation;\n\n  if (directTypeAnnotation !== void 0) {\n    return directTypeAnnotation;\n  }\n\n  return getNestedTypeAnnotation(node);\n};\n\n/**\n * Gets the return type annotation for a function-like node.\n * @param node Node that may contain a return type.\n * @returns The return type annotation when present.\n * @example\n * ```typescript\n * const annotation = getReturnTypeAnnotation(node);\n * ```\n */\nconst getReturnTypeAnnotation = (\n  node: unknown,\n): TypeAnnotationNode | undefined => {\n  if (node === null || typeof node !== \"object\") {\n    return void 0;\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return typedNode.returnType?.typeAnnotation;\n};\n\n/**\n * Gets getParameters.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getParameters();\n * ```\n */\nconst getParameters = (node: unknown): unknown[] => {\n  if (node === null || typeof node !== \"object\") {\n    return [];\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return Array.isArray(typedNode.params) ? typedNode.params : [];\n};\n\n/**\n * Finds an inline object type literal within a type annotation node.\n * @param node Type annotation node to inspect.\n * @returns The first inline object type literal when present.\n * @example\n * ```typescript\n * const inlineObjectType = getInlineObjectTypeLiteral(annotation);\n * ```\n */\nconst getInlineObjectTypeLiteral = (\n  node: TypeAnnotationNode | undefined,\n): TypeAnnotationNode | undefined => {\n  if (node === void 0) {\n    return void 0;\n  }\n\n  if (node.type === \"TSTypeLiteral\") {\n    return node;\n  }\n\n  if (node.type === \"TSParenthesizedType\") {\n    return getInlineObjectTypeLiteral(\n      node.typeAnnotation as TypeAnnotationNode | undefined,\n    );\n  }\n\n  if (node.type === \"TSUnionType\" || node.type === \"TSIntersectionType\") {\n    const nestedTypes = Array.isArray(node.types) ? node.types : [];\n\n    for (const nestedType of nestedTypes) {\n      const nestedInlineObjectType = getInlineObjectTypeLiteral(\n        nestedType as TypeAnnotationNode | undefined,\n      );\n\n      if (nestedInlineObjectType !== void 0) {\n        return nestedInlineObjectType;\n      }\n    }\n  }\n\n  return void 0;\n};\n\nexport {\n  getInlineObjectTypeLiteral,\n  getParameters,\n  getReturnTypeAnnotation,\n  getTypeAnnotationNode,\n};\nexport type { TypeAnnotationNode, VariableDeclaratorNode };\n"]}

package/dist/domain/core/prefer-interface-types/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAyFnC,2EAA2E;AAC3E,QAAA,MAAM,wBAAwB,EAAE,IAAI,CAAC,UA6DpC,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAyGnC,2EAA2E;AAC3E,QAAA,MAAM,wBAAwB,EAAE,IAAI,CAAC,UA4FpC,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC"}

package/dist/domain/core/prefer-interface-types/rule.js

@@ -1,54 +1,55 @@
+import { createAggregateFix } from "./autofix.js";
+import { collectScopeNames } from "./declaration-names.js";
+import { allocateNames, getParameterBaseName, getReturnBaseName, getVariableBaseName, } from "./naming.js";
 import { getInlineObjectTypeLiteral, getParameters, getReturnTypeAnnotation, getTypeAnnotationNode, } from "./rule-utilities.js";
 /**
  * Reports an inline object type annotation.
- * @param context Rule execution context.
+ * @param matches Deferred match collection.
  * @param typeAnnotation Type annotation node to report.
+ * @param baseName Preferred generated name before normalization.
  * @example
  * ```typescript
  * reportTypeLiteral(context, typeAnnotation);
  * ```
  */
-const reportTypeLiteral = (context, typeAnnotation) => {
-    context.report({
-        messageId: "preferNamedObject",
-        node: typeAnnotation,
-    });
+const collectTypeLiteral = (matches, typeAnnotation, baseName) => {
+    matches.push({ baseName, node: typeAnnotation });
 };
 /**
  * Checks function-like nodes for inline object types.
- * @param context Rule execution context.
+ * @param matches Deferred match collection.
  * @param node Function-like node to check.
  * @example
  * ```typescript
  * checkFunctionLike(context, node);
  * ```
  */
-const checkFunctionLike = (context, node) => {
+const checkFunctionLike = (matches, node) => {
     for (const parameter of getParameters(node)) {
         const inlineObjectType = getInlineObjectTypeLiteral(getTypeAnnotationNode(parameter));
         if (inlineObjectType !== void 0) {
-            reportTypeLiteral(context, inlineObjectType);
+            collectTypeLiteral(matches, inlineObjectType, getParameterBaseName(parameter));
         }
     }
     const inlineReturnObjectType = getInlineObjectTypeLiteral(getReturnTypeAnnotation(node));
     if (inlineReturnObjectType !== void 0) {
-        reportTypeLiteral(context, inlineReturnObjectType);
+        collectTypeLiteral(matches, inlineReturnObjectType, getReturnBaseName(node));
     }
 };
 /**
  * Checks variable declarators for inline object types.
- * @param context Rule execution context.
+ * @param matches Deferred match collection.
  * @param node Variable declarator to check.
  * @example
  * ```typescript
  * checkVariableDeclarator(context, node);
  * ```
  */
-const checkVariableDeclarator = (context, node) => {
+const checkVariableDeclarator = (matches, node) => {
     const typedNode = node;
     const inlineObjectType = getInlineObjectTypeLiteral(getTypeAnnotationNode(typedNode.id));
     if (inlineObjectType !== void 0) {
-        reportTypeLiteral(context, inlineObjectType);
+        collectTypeLiteral(matches, inlineObjectType, getVariableBaseName(node));
     }
 };
 /** ESLint rule requiring named interface/type aliases for object types. */
@@ -63,6 +64,7 @@ const preferInterfaceTypesRule = {
      * ```
      */
     create(context) {
+        const matches = [];
         /**
          * Checks function-like nodes for inline object types.
          * @param node Function-like node to inspect.
@@ -72,7 +74,7 @@ const preferInterfaceTypesRule = {
          * ```
          */
         const functionLikeListener = (node) => {
-            checkFunctionLike(context, node);
+            checkFunctionLike(matches, node);
         };
         /**
          * Checks variable declarators for inline object types.
@@ -83,12 +85,33 @@ const preferInterfaceTypesRule = {
          * ```
          */
         const variableDeclaratorListener = (node) => {
-            checkVariableDeclarator(context, node);
+            checkVariableDeclarator(matches, node);
+        };
+        /**
+         * Reports all collected findings and owns the single aggregate fix.
+         * @example
+         * ```typescript
+         * programExitListener();
+         * ```
+         */
+        const programExitListener = () => {
+            const statements = context.sourceCode.ast.body;
+            const scopeManager = context.sourceCode.scopeManager;
+            const namedMatches = allocateNames(matches, statements, collectScopeNames(scopeManager));
+            const aggregateFix = createAggregateFix(context, namedMatches);
+            for (const [index, match] of namedMatches.entries()) {
+                context.report({
+                    ...(index === 0 && aggregateFix !== void 0 && { fix: aggregateFix }),
+                    messageId: "preferNamedObject",
+                    node: match.node,
+                });
+            }
         };
         return {
             ArrowFunctionExpression: functionLikeListener,
             FunctionDeclaration: functionLikeListener,
             FunctionExpression: functionLikeListener,
+            "Program:exit": programExitListener,
             TSCallSignatureDeclaration: functionLikeListener,
             TSConstructSignatureDeclaration: functionLikeListener,
             TSDeclareFunction: functionLikeListener,
@@ -103,6 +126,7 @@ const preferInterfaceTypesRule = {
             recommended: false,
             url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/prefer-interface-types.md",
         },
+        fixable: "code",
         messages: {
             preferNamedObject: "Use a named interface or type alias instead of an inline object type.",
         },
@@ -111,4 +135,4 @@ const preferInterfaceTypesRule = {
     },
 };
 export { preferInterfaceTypesRule };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,0BAA0B,EAC1B,aAAa,EACb,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;GAQG;AACH,MAAM,iBAAiB,GAAG,CACxB,OAAyB,EACzB,cAAkC,EAC5B,EAAE;IACR,OAAO,CAAC,MAAM,CAAC;QACb,SAAS,EAAE,mBAAmB;QAC9B,IAAI,EAAE,cAAsC;KAC7C,CAAC,CAAC;AACL,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,iBAAiB,GAAG,CACxB,OAAyB,EACzB,IAAe,EACT,EAAE;IACR,KAAK,MAAM,SAAS,IAAI,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5C,MAAM,gBAAgB,GAAG,0BAA0B,CACjD,qBAAqB,CAAC,SAAS,CAAC,CACjC,CAAC;QAEF,IAAI,gBAAgB,KAAK,KAAK,CAAC,EAAE,CAAC;YAChC,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IAED,MAAM,sBAAsB,GAAG,0BAA0B,CACvD,uBAAuB,CAAC,IAAI,CAAC,CAC9B,CAAC;IAEF,IAAI,sBAAsB,KAAK,KAAK,CAAC,EAAE,CAAC;QACtC,iBAAiB,CAAC,OAAO,EAAE,sBAAsB,CAAC,CAAC;IACrD,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,uBAAuB,GAAG,CAC9B,OAAyB,EACzB,IAAe,EACT,EAAE;IACR,MAAM,SAAS,GAAG,IAA8B,CAAC;IAEjD,MAAM,gBAAgB,GAAG,0BAA0B,CACjD,qBAAqB,CAAC,SAAS,CAAC,EAAE,CAAC,CACpC,CAAC;IAEF,IAAI,gBAAgB,KAAK,KAAK,CAAC,EAAE,CAAC;QAChC,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC,CAAC;AAEF,2EAA2E;AAC3E,MAAM,wBAAwB,GAAoB;IAChD;;;;;;;;OAQG;IACH,MAAM,CAAC,OAAyB;QAC9B;;;;;;;WAOG;QACH,MAAM,oBAAoB,GAAG,CAAC,IAAe,EAAQ,EAAE;YACrD,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACnC,CAAC,CAAC;QAEF;;;;;;;WAOG;QACH,MAAM,0BAA0B,GAAG,CAAC,IAAe,EAAQ,EAAE;YAC3D,uBAAuB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACzC,CAAC,CAAC;QAEF,OAAO;YACL,uBAAuB,EAAE,oBAAoB;YAC7C,mBAAmB,EAAE,oBAAoB;YACzC,kBAAkB,EAAE,oBAAoB;YACxC,0BAA0B,EAAE,oBAAoB;YAChD,+BAA+B,EAAE,oBAAoB;YACrD,iBAAiB,EAAE,oBAAoB;YACvC,cAAc,EAAE,oBAAoB;YACpC,iBAAiB,EAAE,oBAAoB;YACvC,kBAAkB,EAAE,0BAA0B;SAC/C,CAAC;IACJ,CAAC;IACD,IAAI,EAAE;QACJ,IAAI,EAAE;YACJ,WAAW,EACT,kHAAkH;YACpH,WAAW,EAAE,KAAK;YAClB,GAAG,EAAE,yFAAyF;SAC/F;QACD,QAAQ,EAAE;YACR,iBAAiB,EACf,uEAAuE;SAC1E;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACnB;CACF,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type {\n  TypeAnnotationNode,\n  VariableDeclaratorNode,\n} from \"./rule-utilities\";\n\nimport {\n  getInlineObjectTypeLiteral,\n  getParameters,\n  getReturnTypeAnnotation,\n  getTypeAnnotationNode,\n} from \"./rule-utilities\";\n\n/**\n * Reports an inline object type annotation.\n * @param context Rule execution context.\n * @param typeAnnotation Type annotation node to report.\n * @example\n * ```typescript\n * reportTypeLiteral(context, typeAnnotation);\n * ```\n */\nconst reportTypeLiteral = (\n  context: Rule.RuleContext,\n  typeAnnotation: TypeAnnotationNode,\n): void => {\n  context.report({\n    messageId: \"preferNamedObject\",\n    node: typeAnnotation as unknown as Rule.Node,\n  });\n};\n\n/**\n * Checks function-like nodes for inline object types.\n * @param context Rule execution context.\n * @param node Function-like node to check.\n * @example\n * ```typescript\n * checkFunctionLike(context, node);\n * ```\n */\nconst checkFunctionLike = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  for (const parameter of getParameters(node)) {\n    const inlineObjectType = getInlineObjectTypeLiteral(\n      getTypeAnnotationNode(parameter),\n    );\n\n    if (inlineObjectType !== void 0) {\n      reportTypeLiteral(context, inlineObjectType);\n    }\n  }\n\n  const inlineReturnObjectType = getInlineObjectTypeLiteral(\n    getReturnTypeAnnotation(node),\n  );\n\n  if (inlineReturnObjectType !== void 0) {\n    reportTypeLiteral(context, inlineReturnObjectType);\n  }\n};\n\n/**\n * Checks variable declarators for inline object types.\n * @param context Rule execution context.\n * @param node Variable declarator to check.\n * @example\n * ```typescript\n * checkVariableDeclarator(context, node);\n * ```\n */\nconst checkVariableDeclarator = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  const typedNode = node as VariableDeclaratorNode;\n\n  const inlineObjectType = getInlineObjectTypeLiteral(\n    getTypeAnnotationNode(typedNode.id),\n  );\n\n  if (inlineObjectType !== void 0) {\n    reportTypeLiteral(context, inlineObjectType);\n  }\n};\n\n/** ESLint rule requiring named interface/type aliases for object types. */\nconst preferInterfaceTypesRule: Rule.RuleModule = {\n  /**\n   * Creates listeners that validate function-like and variable annotations.\n   * @param context Rule execution context.\n   * @returns Rule listener map.\n   * @example\n   * ```typescript\n   * const listeners = preferInterfaceTypesRule.create(context);\n   * ```\n   */\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    /**\n     * Checks function-like nodes for inline object types.\n     * @param node Function-like node to inspect.\n     * @example\n     * ```typescript\n     * functionLikeListener(node);\n     * ```\n     */\n    const functionLikeListener = (node: Rule.Node): void => {\n      checkFunctionLike(context, node);\n    };\n\n    /**\n     * Checks variable declarators for inline object types.\n     * @param node Variable declarator to inspect.\n     * @example\n     * ```typescript\n     * variableDeclaratorListener(node);\n     * ```\n     */\n    const variableDeclaratorListener = (node: Rule.Node): void => {\n      checkVariableDeclarator(context, node);\n    };\n\n    return {\n      ArrowFunctionExpression: functionLikeListener,\n      FunctionDeclaration: functionLikeListener,\n      FunctionExpression: functionLikeListener,\n      TSCallSignatureDeclaration: functionLikeListener,\n      TSConstructSignatureDeclaration: functionLikeListener,\n      TSDeclareFunction: functionLikeListener,\n      TSFunctionType: functionLikeListener,\n      TSMethodSignature: functionLikeListener,\n      VariableDeclarator: variableDeclaratorListener,\n    };\n  },\n  meta: {\n    docs: {\n      description:\n        \"Require named interfaces or type aliases for object types in parameters, return types, and variable annotations.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/prefer-interface-types.md\",\n    },\n    messages: {\n      preferNamedObject:\n        \"Use a named interface or type alias instead of an inline object type.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { preferInterfaceTypesRule };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type {\n  TypeAnnotationNode,\n  VariableDeclaratorNode,\n} from \"./rule-utilities\";\nimport type { InlineTypeMatch } from \"./types\";\n\nimport { createAggregateFix } from \"./autofix\";\nimport { collectScopeNames } from \"./declaration-names\";\nimport {\n  allocateNames,\n  getParameterBaseName,\n  getReturnBaseName,\n  getVariableBaseName,\n} from \"./naming\";\nimport {\n  getInlineObjectTypeLiteral,\n  getParameters,\n  getReturnTypeAnnotation,\n  getTypeAnnotationNode,\n} from \"./rule-utilities\";\n\n/**\n * Reports an inline object type annotation.\n * @param matches Deferred match collection.\n * @param typeAnnotation Type annotation node to report.\n * @param baseName Preferred generated name before normalization.\n * @example\n * ```typescript\n * reportTypeLiteral(context, typeAnnotation);\n * ```\n */\nconst collectTypeLiteral = (\n  matches: InlineTypeMatch[],\n  typeAnnotation: TypeAnnotationNode,\n  baseName: string,\n): void => {\n  matches.push({ baseName, node: typeAnnotation });\n};\n\n/**\n * Checks function-like nodes for inline object types.\n * @param matches Deferred match collection.\n * @param node Function-like node to check.\n * @example\n * ```typescript\n * checkFunctionLike(context, node);\n * ```\n */\nconst checkFunctionLike = (\n  matches: InlineTypeMatch[],\n  node: Rule.Node,\n): void => {\n  for (const parameter of getParameters(node)) {\n    const inlineObjectType = getInlineObjectTypeLiteral(\n      getTypeAnnotationNode(parameter),\n    );\n\n    if (inlineObjectType !== void 0) {\n      collectTypeLiteral(\n        matches,\n        inlineObjectType,\n        getParameterBaseName(parameter),\n      );\n    }\n  }\n\n  const inlineReturnObjectType = getInlineObjectTypeLiteral(\n    getReturnTypeAnnotation(node),\n  );\n\n  if (inlineReturnObjectType !== void 0) {\n    collectTypeLiteral(\n      matches,\n      inlineReturnObjectType,\n      getReturnBaseName(node),\n    );\n  }\n};\n\n/**\n * Checks variable declarators for inline object types.\n * @param matches Deferred match collection.\n * @param node Variable declarator to check.\n * @example\n * ```typescript\n * checkVariableDeclarator(context, node);\n * ```\n */\nconst checkVariableDeclarator = (\n  matches: InlineTypeMatch[],\n  node: Rule.Node,\n): void => {\n  const typedNode = node as VariableDeclaratorNode;\n\n  const inlineObjectType = getInlineObjectTypeLiteral(\n    getTypeAnnotationNode(typedNode.id),\n  );\n\n  if (inlineObjectType !== void 0) {\n    collectTypeLiteral(matches, inlineObjectType, getVariableBaseName(node));\n  }\n};\n\n/** ESLint rule requiring named interface/type aliases for object types. */\nconst preferInterfaceTypesRule: Rule.RuleModule = {\n  /**\n   * Creates listeners that validate function-like and variable annotations.\n   * @param context Rule execution context.\n   * @returns Rule listener map.\n   * @example\n   * ```typescript\n   * const listeners = preferInterfaceTypesRule.create(context);\n   * ```\n   */\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    const matches: InlineTypeMatch[] = [];\n\n    /**\n     * Checks function-like nodes for inline object types.\n     * @param node Function-like node to inspect.\n     * @example\n     * ```typescript\n     * functionLikeListener(node);\n     * ```\n     */\n    const functionLikeListener = (node: Rule.Node): void => {\n      checkFunctionLike(matches, node);\n    };\n\n    /**\n     * Checks variable declarators for inline object types.\n     * @param node Variable declarator to inspect.\n     * @example\n     * ```typescript\n     * variableDeclaratorListener(node);\n     * ```\n     */\n    const variableDeclaratorListener = (node: Rule.Node): void => {\n      checkVariableDeclarator(matches, node);\n    };\n\n    /**\n     * Reports all collected findings and owns the single aggregate fix.\n     * @example\n     * ```typescript\n     * programExitListener();\n     * ```\n     */\n    const programExitListener = (): void => {\n      const statements = context.sourceCode.ast.body;\n      const scopeManager = context.sourceCode.scopeManager as\n        import(\"./types\").ScopeManager | undefined;\n      const namedMatches = allocateNames(\n        matches,\n        statements,\n        collectScopeNames(scopeManager),\n      );\n      const aggregateFix = createAggregateFix(context, namedMatches);\n\n      for (const [index, match] of namedMatches.entries()) {\n        context.report({\n          ...(index === 0 && aggregateFix !== void 0 && { fix: aggregateFix }),\n          messageId: \"preferNamedObject\",\n          node: match.node as unknown as Rule.Node,\n        });\n      }\n    };\n\n    return {\n      ArrowFunctionExpression: functionLikeListener,\n      FunctionDeclaration: functionLikeListener,\n      FunctionExpression: functionLikeListener,\n      \"Program:exit\": programExitListener,\n      TSCallSignatureDeclaration: functionLikeListener,\n      TSConstructSignatureDeclaration: functionLikeListener,\n      TSDeclareFunction: functionLikeListener,\n      TSFunctionType: functionLikeListener,\n      TSMethodSignature: functionLikeListener,\n      VariableDeclarator: variableDeclaratorListener,\n    };\n  },\n  meta: {\n    docs: {\n      description:\n        \"Require named interfaces or type aliases for object types in parameters, return types, and variable annotations.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/prefer-interface-types.md\",\n    },\n    fixable: \"code\",\n    messages: {\n      preferNamedObject:\n        \"Use a named interface or type alias instead of an inline object type.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { preferInterfaceTypesRule };\n"]}

package/dist/domain/core/prefer-interface-types/types.d.ts

@@ -0,0 +1,80 @@
+import type { Rule } from "eslint";
+import type { TypeAnnotationNode } from "./rule-utilities.js";
+/** Source-code surface required to build the aggregate autofix. */
+type FixSourceCode = Pick<Rule.RuleContext["sourceCode"], "ast" | "getText" | "text"> & {
+    /** Scope information used to preserve lexical type bindings. */
+    scopeManager?: ScopeManager;
+};
+/** One inline object type collected for deferred reporting and fixing. */
+interface InlineTypeMatch {
+    /** Preferred base name before PascalCase conversion and collision handling. */
+    baseName: string;
+    /** Inline object type reported by the rule. */
+    node: TypeAnnotationNode;
+}
+/** One collected inline object type with its allocated interface name. */
+interface NamedInlineTypeMatch extends InlineTypeMatch {
+    /** Collision-free generated interface name. */
+    name: string;
+}
+/** Node shape used to resolve nearby declaration names. */
+interface NamingNode {
+    /** Optional declaration identifier. */
+    id?: unknown;
+    /** Optional property or method key. */
+    key?: unknown;
+    /** Optional identifier name. */
+    name?: unknown;
+    /** Parent node supplied by the parser. */
+    parent?: NamingNode | null;
+    /** Node type discriminator. */
+    type?: unknown;
+    /** Optional literal value. */
+    value?: unknown;
+}
+/** Named match whose source range has been validated for replacement. */
+interface RangedNamedInlineTypeMatch extends NamedInlineTypeMatch {
+    /** Inline object type with a required source range. */
+    node: TypeAnnotationNode & {
+        range: [number, number];
+    };
+}
+/** Minimal lexical scope surface required by autofix safety checks. */
+interface Scope {
+    /** AST node that owns the scope. */
+    block?: {
+        range?: [number, number];
+    };
+    /** References originating from the scope. */
+    references?: ScopeReference[];
+    /** Scope category reported by the TypeScript ESLint parser. */
+    type?: string;
+    /** Declarations visible through the scope. */
+    variables?: ScopeVariable[];
+}
+/** Minimal identifier surface exposed by scope references. */
+interface ScopeIdentifier {
+    /** Source range for the referenced identifier. */
+    range?: [number, number];
+}
+/** Scope manager surface exposed by the TypeScript ESLint parser. */
+interface ScopeManager {
+    /** Lexical scopes discovered in the source file. */
+    scopes: Scope[];
+}
+/** One identifier reference and its resolved declaration scope. */
+interface ScopeReference {
+    /** Referenced identifier node. */
+    identifier?: ScopeIdentifier;
+    /** Resolved declaration when the reference is locally bound. */
+    resolved?: null | {
+        scope?: Scope;
+    };
+}
+/** One declaration recorded by the scope manager. */
+interface ScopeVariable {
+    /** Declared identifier name. */
+    name?: string;
+}
+export type { FixSourceCode, InlineTypeMatch, NamedInlineTypeMatch, NamingNode, RangedNamedInlineTypeMatch, Scope, ScopeManager, };
+//# sourceMappingURL=types.d.ts.map

package/dist/domain/core/prefer-interface-types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAE3D,mEAAmE;AACnE,KAAK,aAAa,GAAG,IAAI,CACvB,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAC9B,KAAK,GAAG,SAAS,GAAG,MAAM,CAC3B,GAAG;IACF,gEAAgE;IAChE,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAEF,0EAA0E;AAC1E,UAAU,eAAe;IACvB,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAC;IAEjB,+CAA+C;IAC/C,IAAI,EAAE,kBAAkB,CAAC;CAC1B;AAED,0EAA0E;AAC1E,UAAU,oBAAqB,SAAQ,eAAe;IACpD,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;CACd;AAED,2DAA2D;AAC3D,UAAU,UAAU;IAClB,uCAAuC;IACvC,EAAE,CAAC,EAAE,OAAO,CAAC;IAEb,uCAAuC;IACvC,GAAG,CAAC,EAAE,OAAO,CAAC;IAEd,gCAAgC;IAChC,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,0CAA0C;IAC1C,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAE3B,+BAA+B;IAC/B,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,8BAA8B;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,yEAAyE;AACzE,UAAU,0BAA2B,SAAQ,oBAAoB;IAC/D,uDAAuD;IACvD,IAAI,EAAE,kBAAkB,GAAG;QAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC;CACxD;AAED,uEAAuE;AACvE,UAAU,KAAK;IACb,oCAAoC;IACpC,KAAK,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC;IAErC,6CAA6C;IAC7C,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;IAE9B,+DAA+D;IAC/D,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,8CAA8C;IAC9C,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;CAC7B;AAED,8DAA8D;AAC9D,UAAU,eAAe;IACvB,kDAAkD;IAClD,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1B;AAED,qEAAqE;AACrE,UAAU,YAAY;IACpB,oDAAoD;IACpD,MAAM,EAAE,KAAK,EAAE,CAAC;CACjB;AAED,mEAAmE;AACnE,UAAU,cAAc;IACtB,kCAAkC;IAClC,UAAU,CAAC,EAAE,eAAe,CAAC;IAE7B,gEAAgE;IAChE,QAAQ,CAAC,EAAE,IAAI,GAAG;QAAE,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAC;CACrC;AAED,qDAAqD;AACrD,UAAU,aAAa;IACrB,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,YAAY,EACV,aAAa,EACb,eAAe,EACf,oBAAoB,EACpB,UAAU,EACV,0BAA0B,EAC1B,KAAK,EACL,YAAY,GACb,CAAC"}

package/dist/domain/core/prefer-interface-types/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/docs/no-interface-member-docs/comment-removal-ranges.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"comment-removal-ranges.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-removal-ranges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe,GAAI,aAAa,MAAM,KAAG,WAAW,EAyBzD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,iBAAiB,GACrB,cAAc,MAAM,EACpB,aAAa,MAAM,EACnB,MAAM,WAAW,KAChB,CAAC,MAAM,EAAE,MAAM,CAuBjB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"comment-removal-ranges.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-removal-ranges.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe,GAAI,aAAa,MAAM,KAAG,WAAW,EAoBzD,CAAC;AAEF;;;;;;;;;;GAUG;AACH,QAAA,MAAM,iBAAiB,GACrB,cAAc,MAAM,EACpB,aAAa,MAAM,EACnB,MAAM,WAAW,KAChB,CAAC,MAAM,EAAE,MAAM,CAuBjB,CAAC;AAEF,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,CAAC"}

package/dist/domain/docs/no-interface-member-docs/comment-removal-ranges.js

@@ -19,12 +19,7 @@ const getCommentLines = (commentText) => {
             : nextSlice.startsWith("\n")
                 ? 1
                 : 0;
-        results.push({
-            end: lineEnd,
-            lineBreakLength,
-            start: offset,
-            text: line,
-        });
+        results.push({ end: lineEnd, lineBreakLength, start: offset, text: line });
         offset = lineEnd + lineBreakLength;
     }
     return results;
@@ -61,4 +56,4 @@ const buildRemovalRange = (commentStart, commentText, line) => {
     return [commentStart + line.start, commentStart + line.end];
 };
 export { buildRemovalRange, getCommentLines };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/docs/no-interface-member-docs/parameter-tags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parameter-tags.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/parameter-tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAmG/D;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,MAAM,WAAW,KAChB,kBAAkB,GAAG,SAmBvB,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}
+{"version":3,"file":"parameter-tags.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/parameter-tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAmG/D;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,MAAM,WAAW,KAChB,kBAAkB,GAAG,SAevB,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}