@codeperfect/eslint-plugin 2.6.0 → 2.8.0

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

@@ -0,0 +1,196 @@
+const generatedNameTodo = "// TODO: Review this autogenerated type name";
+/**
+ * Checks whether an AST subtree contains a contextual `this` type.
+ * @param value Candidate AST value.
+ * @returns Whether moving the value would change `this` semantics.
+ * @example
+ * ```typescript
+ * const contextual = containsContextualThis(typeLiteral);
+ * ```
+ */
+function containsContextualThis(value) {
+    if (Array.isArray(value)) {
+        return value.some((item) => containsContextualThis(item));
+    }
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    const node = value;
+    if (node["type"] === "TSThisType" || node["type"] === "ThisExpression") {
+        return true;
+    }
+    return Object.entries(node).some(([key, child]) => key !== "parent" && containsContextualThis(child));
+}
+/**
+ * Checks whether an inner range is fully contained by an outer range.
+ * @param outerRange Candidate containing range.
+ * @param innerRange Candidate contained range.
+ * @returns Whether the inner range is contained by the outer range.
+ * @example
+ * ```typescript
+ * const contained = containsRange([0, 5], [1, 4]);
+ * ```
+ */
+function containsRange(outerRange, innerRange) {
+    return innerRange[0] >= outerRange[0] && innerRange[1] <= outerRange[1];
+}
+/**
+ * Creates the sole aggregate fix for all findings when every source range is safe.
+ * @param context Rule execution context.
+ * @param matches Named inline object type matches.
+ * @returns Aggregate fix callback, or undefined when source data is incomplete.
+ * @example
+ * ```typescript
+ * const fix = createAggregateFix(context, matches);
+ * ```
+ */
+function createAggregateFix(context, matches) {
+    const sourceCode = getFixSourceCode(context);
+    if (sourceCode === void 0 ||
+        !hasSafeRanges(matches, sourceCode.text.length) ||
+        !hasRelocatableMatches(matches, sourceCode)) {
+        return void 0;
+    }
+    const lineEnding = sourceCode.text.includes("\r\n") ? "\r\n" : "\n";
+    const declarations = matches
+        .map((match) => `${generatedNameTodo}${lineEnding}interface ${match.name} ${sourceCode.getText(match.node)}`)
+        .join(`${lineEnding}${lineEnding}`);
+    const appendText = `${getBlockSeparator(sourceCode.text, lineEnding)}${declarations}${lineEnding}`;
+    return (fixer) => [
+        ...matches.map((match) => fixer.replaceTextRange(match.node.range, match.name)),
+        fixer.insertTextAfterRange([sourceCode.text.length, sourceCode.text.length], appendText),
+    ];
+}
+/**
+ * Returns the blank-line separator required before the generated block.
+ * @param sourceText Existing source text.
+ * @param lineEnding Detected source line ending.
+ * @returns Separator required before generated declarations.
+ * @example
+ * ```typescript
+ * const separator = getBlockSeparator("const value = 1;", "\n");
+ * ```
+ */
+function getBlockSeparator(sourceText, lineEnding) {
+    if (sourceText.length === 0 || sourceText.endsWith(lineEnding + lineEnding)) {
+        return "";
+    }
+    return sourceText.endsWith(lineEnding) ? lineEnding : lineEnding + lineEnding;
+}
+/**
+ * Gets the source-code methods only when a complete source payload is available.
+ * @param context Rule execution context.
+ * @returns Complete source-code payload when available.
+ * @example
+ * ```typescript
+ * const sourceCode = getFixSourceCode(context);
+ * ```
+ */
+function getFixSourceCode(context) {
+    const sourceCode = context.sourceCode;
+    return sourceCode !== void 0 &&
+        typeof sourceCode.text === "string" &&
+        typeof sourceCode.getText === "function" &&
+        sourceCode.ast !== void 0
+        ? sourceCode
+        : void 0;
+}
+/**
+ * Checks whether a literal belongs to a namespace or ambient module.
+ * @param node Inline type literal node.
+ * @returns Whether EOF insertion would move the declaration outside its module.
+ * @example
+ * ```typescript
+ * const nested = hasModuleAncestor(typeLiteral);
+ * ```
+ */
+function hasModuleAncestor(node) {
+    let current = node.parent;
+    while (current !== null && current !== void 0) {
+        if (current.type === "TSModuleDeclaration") {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * Checks whether moving every literal to module scope preserves its bindings.
+ * @param matches Ranged inline type matches.
+ * @param sourceCode Source and scope information for the active file.
+ * @returns Whether every literal can safely move to module scope.
+ * @example
+ * ```typescript
+ * const relocatable = hasRelocatableMatches(matches, sourceCode);
+ * ```
+ */
+function hasRelocatableMatches(matches, sourceCode) {
+    const scopes = sourceCode.scopeManager?.scopes;
+    if (scopes === void 0) {
+        return false;
+    }
+    for (const match of matches) {
+        if (containsContextualThis(match.node) || hasModuleAncestor(match.node)) {
+            return false;
+        }
+        for (const scope of scopes) {
+            const references = scope.references ?? [];
+            for (const reference of references) {
+                const referenceRange = reference.identifier?.range;
+                if (referenceRange !== void 0 &&
+                    containsRange(match.node.range, referenceRange) &&
+                    !isRelocatableReference(match.node.range, reference.resolved?.scope)) {
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Checks that all replacement ranges exist, are ordered, and do not overlap.
+ * @param matches Named inline object type matches.
+ * @param sourceLength Existing source length.
+ * @returns Whether every replacement range is safe.
+ * @example
+ * ```typescript
+ * const safe = hasSafeRanges(matches, sourceText.length);
+ * ```
+ */
+function hasSafeRanges(matches, sourceLength) {
+    let previousEnd = -1;
+    const orderedMatches = matches.toSorted((left, right) => (left.node.range?.[0] ?? -1) - (right.node.range?.[0] ?? -1));
+    for (const match of orderedMatches) {
+        const range = match.node.range;
+        if (range === void 0 ||
+            range[0] < 0 ||
+            range[0] < previousEnd ||
+            range[1] < range[0] ||
+            range[1] > sourceLength) {
+            return false;
+        }
+        previousEnd = range[1];
+    }
+    return matches.length > 0;
+}
+/**
+ * Determines whether a reference keeps the same binding at module scope.
+ * @param literalRange Range of the type literal being moved.
+ * @param resolvedScope Scope containing the referenced declaration.
+ * @returns Whether the reference is module-safe or moves with the literal.
+ * @example
+ * ```typescript
+ * const relocatable = isRelocatableReference(literalRange, resolvedScope);
+ * ```
+ */
+function isRelocatableReference(literalRange, resolvedScope) {
+    if (resolvedScope === void 0 ||
+        resolvedScope.type === "global" ||
+        resolvedScope.type === "module") {
+        return true;
+    }
+    const scopeRange = resolvedScope.block?.range;
+    return scopeRange !== void 0 && containsRange(literalRange, scopeRange);
+}
+export { createAggregateFix };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autofix.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/autofix.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type {\n  FixSourceCode,\n  NamedInlineTypeMatch,\n  NamingNode,\n  RangedNamedInlineTypeMatch,\n} from \"./types\";\n\nconst generatedNameTodo = \"// TODO: Review this autogenerated type name\";\n\n/**\n * Checks whether an AST subtree contains a contextual `this` type.\n * @param value Candidate AST value.\n * @returns Whether moving the value would change `this` semantics.\n * @example\n * ```typescript\n * const contextual = containsContextualThis(typeLiteral);\n * ```\n */\nfunction containsContextualThis(value: unknown): boolean {\n  if (Array.isArray(value)) {\n    return value.some((item) => containsContextualThis(item));\n  }\n\n  if (value === null || typeof value !== \"object\") {\n    return false;\n  }\n\n  const node = value as Record<string, unknown>;\n\n  if (node[\"type\"] === \"TSThisType\" || node[\"type\"] === \"ThisExpression\") {\n    return true;\n  }\n\n  return Object.entries(node).some(\n    ([key, child]) => key !== \"parent\" && containsContextualThis(child),\n  );\n}\n\n/**\n * Checks whether an inner range is fully contained by an outer range.\n * @param outerRange Candidate containing range.\n * @param innerRange Candidate contained range.\n * @returns Whether the inner range is contained by the outer range.\n * @example\n * ```typescript\n * const contained = containsRange([0, 5], [1, 4]);\n * ```\n */\nfunction containsRange(\n  outerRange: [number, number],\n  innerRange: [number, number],\n): boolean {\n  return innerRange[0] >= outerRange[0] && innerRange[1] <= outerRange[1];\n}\n\n/**\n * Creates the sole aggregate fix for all findings when every source range is safe.\n * @param context Rule execution context.\n * @param matches Named inline object type matches.\n * @returns Aggregate fix callback, or undefined when source data is incomplete.\n * @example\n * ```typescript\n * const fix = createAggregateFix(context, matches);\n * ```\n */\nfunction createAggregateFix(\n  context: Rule.RuleContext,\n  matches: readonly NamedInlineTypeMatch[],\n): ((fixer: Rule.RuleFixer) => Rule.Fix[]) | undefined {\n  const sourceCode = getFixSourceCode(context);\n\n  if (\n    sourceCode === void 0 ||\n    !hasSafeRanges(matches, sourceCode.text.length) ||\n    !hasRelocatableMatches(matches, sourceCode)\n  ) {\n    return void 0;\n  }\n\n  const lineEnding = sourceCode.text.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\n  const declarations = matches\n    .map(\n      (match) =>\n        `${generatedNameTodo}${lineEnding}interface ${match.name} ${sourceCode.getText(match.node as never)}`,\n    )\n    .join(`${lineEnding}${lineEnding}`);\n  const appendText = `${getBlockSeparator(sourceCode.text, lineEnding)}${declarations}${lineEnding}`;\n\n  return (fixer: Rule.RuleFixer): Rule.Fix[] => [\n    ...matches.map((match) =>\n      fixer.replaceTextRange(match.node.range, match.name),\n    ),\n    fixer.insertTextAfterRange(\n      [sourceCode.text.length, sourceCode.text.length],\n      appendText,\n    ),\n  ];\n}\n\n/**\n * Returns the blank-line separator required before the generated block.\n * @param sourceText Existing source text.\n * @param lineEnding Detected source line ending.\n * @returns Separator required before generated declarations.\n * @example\n * ```typescript\n * const separator = getBlockSeparator(\"const value = 1;\", \"\\n\");\n * ```\n */\nfunction getBlockSeparator(sourceText: string, lineEnding: string): string {\n  if (sourceText.length === 0 || sourceText.endsWith(lineEnding + lineEnding)) {\n    return \"\";\n  }\n\n  return sourceText.endsWith(lineEnding) ? lineEnding : lineEnding + lineEnding;\n}\n\n/**\n * Gets the source-code methods only when a complete source payload is available.\n * @param context Rule execution context.\n * @returns Complete source-code payload when available.\n * @example\n * ```typescript\n * const sourceCode = getFixSourceCode(context);\n * ```\n */\nfunction getFixSourceCode(\n  context: Rule.RuleContext,\n): FixSourceCode | undefined {\n  const sourceCode = context.sourceCode as Partial<FixSourceCode> | undefined;\n\n  return sourceCode !== void 0 &&\n    typeof sourceCode.text === \"string\" &&\n    typeof sourceCode.getText === \"function\" &&\n    sourceCode.ast !== void 0\n    ? (sourceCode as FixSourceCode)\n    : void 0;\n}\n\n/**\n * Checks whether a literal belongs to a namespace or ambient module.\n * @param node Inline type literal node.\n * @returns Whether EOF insertion would move the declaration outside its module.\n * @example\n * ```typescript\n * const nested = hasModuleAncestor(typeLiteral);\n * ```\n */\nfunction hasModuleAncestor(node: NamedInlineTypeMatch[\"node\"]): boolean {\n  let current = (node as NamingNode).parent;\n\n  while (current !== null && current !== void 0) {\n    if (current.type === \"TSModuleDeclaration\") {\n      return true;\n    }\n\n    current = current.parent;\n  }\n\n  return false;\n}\n\n/**\n * Checks whether moving every literal to module scope preserves its bindings.\n * @param matches Ranged inline type matches.\n * @param sourceCode Source and scope information for the active file.\n * @returns Whether every literal can safely move to module scope.\n * @example\n * ```typescript\n * const relocatable = hasRelocatableMatches(matches, sourceCode);\n * ```\n */\nfunction hasRelocatableMatches(\n  matches: readonly RangedNamedInlineTypeMatch[],\n  sourceCode: FixSourceCode,\n): boolean {\n  const scopes = sourceCode.scopeManager?.scopes;\n\n  if (scopes === void 0) {\n    return false;\n  }\n\n  for (const match of matches) {\n    if (containsContextualThis(match.node) || hasModuleAncestor(match.node)) {\n      return false;\n    }\n\n    for (const scope of scopes) {\n      const references = scope.references ?? [];\n\n      for (const reference of references) {\n        const referenceRange = reference.identifier?.range;\n\n        if (\n          referenceRange !== void 0 &&\n          containsRange(match.node.range, referenceRange) &&\n          !isRelocatableReference(match.node.range, reference.resolved?.scope)\n        ) {\n          return false;\n        }\n      }\n    }\n  }\n\n  return true;\n}\n\n/**\n * Checks that all replacement ranges exist, are ordered, and do not overlap.\n * @param matches Named inline object type matches.\n * @param sourceLength Existing source length.\n * @returns Whether every replacement range is safe.\n * @example\n * ```typescript\n * const safe = hasSafeRanges(matches, sourceText.length);\n * ```\n */\nfunction hasSafeRanges(\n  matches: readonly NamedInlineTypeMatch[],\n  sourceLength: number,\n): matches is readonly RangedNamedInlineTypeMatch[] {\n  let previousEnd = -1;\n\n  const orderedMatches = matches.toSorted(\n    (left, right) =>\n      (left.node.range?.[0] ?? -1) - (right.node.range?.[0] ?? -1),\n  );\n\n  for (const match of orderedMatches) {\n    const range = match.node.range;\n\n    if (\n      range === void 0 ||\n      range[0] < 0 ||\n      range[0] < previousEnd ||\n      range[1] < range[0] ||\n      range[1] > sourceLength\n    ) {\n      return false;\n    }\n\n    previousEnd = range[1];\n  }\n\n  return matches.length > 0;\n}\n\n/**\n * Determines whether a reference keeps the same binding at module scope.\n * @param literalRange Range of the type literal being moved.\n * @param resolvedScope Scope containing the referenced declaration.\n * @returns Whether the reference is module-safe or moves with the literal.\n * @example\n * ```typescript\n * const relocatable = isRelocatableReference(literalRange, resolvedScope);\n * ```\n */\nfunction isRelocatableReference(\n  literalRange: [number, number],\n  resolvedScope: import(\"./types\").Scope | undefined,\n): boolean {\n  if (\n    resolvedScope === void 0 ||\n    resolvedScope.type === \"global\" ||\n    resolvedScope.type === \"module\"\n  ) {\n    return true;\n  }\n\n  const scopeRange = resolvedScope.block?.range;\n\n  return scopeRange !== void 0 && containsRange(literalRange, scopeRange);\n}\n\nexport { createAggregateFix };\n"]}

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

@@ -0,0 +1,23 @@
+import type { ScopeManager } from "./types.js";
+/**
+ * Collects declarations from every lexical scope in a source file.
+ * @param scopeManager Parser scope information.
+ * @returns Names that could capture a generated type reference.
+ * @example
+ * ```typescript
+ * const names = collectScopeNames(sourceCode.scopeManager);
+ * ```
+ */
+declare function collectScopeNames(scopeManager: ScopeManager | undefined): Set<string>;
+/**
+ * Collects all import, value, and type names declared at module scope.
+ * @param statements Program statements to inspect.
+ * @returns Names already declared at module scope.
+ * @example
+ * ```typescript
+ * const names = collectTopLevelNames(program.body);
+ * ```
+ */
+declare function collectTopLevelNames(statements: readonly unknown[]): Set<string>;
+export { collectScopeNames, collectTopLevelNames };
+//# sourceMappingURL=declaration-names.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"declaration-names.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/declaration-names.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAmG5C;;;;;;;;GAQG;AACH,iBAAS,iBAAiB,CACxB,YAAY,EAAE,YAAY,GAAG,SAAS,GACrC,GAAG,CAAC,MAAM,CAAC,CAeb;AAED;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAAC,UAAU,EAAE,SAAS,OAAO,EAAE,GAAG,GAAG,CAAC,MAAM,CAAC,CA8BzE;AAeD,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,CAAC"}

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

@@ -0,0 +1,139 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+const namedDeclarationTypes = new Set([
+    AST_NODE_TYPES.ClassDeclaration,
+    AST_NODE_TYPES.FunctionDeclaration,
+    AST_NODE_TYPES.TSDeclareFunction,
+    AST_NODE_TYPES.TSEnumDeclaration,
+    AST_NODE_TYPES.TSInterfaceDeclaration,
+    AST_NODE_TYPES.TSModuleDeclaration,
+    AST_NODE_TYPES.TSTypeAliasDeclaration,
+    AST_NODE_TYPES.VariableDeclaration,
+]);
+/**
+ * Adds names introduced by one supported top-level declaration.
+ * @param declaration Top-level declaration to inspect.
+ * @param names Mutable output set.
+ * @example
+ * ```typescript
+ * collectDeclarationNames(declaration, names);
+ * ```
+ */
+function collectDeclarationNames(declaration, names) {
+    if (declaration.type === AST_NODE_TYPES.VariableDeclaration) {
+        for (const variable of declaration.declarations) {
+            collectPatternNames(variable.id, names);
+        }
+        return;
+    }
+    if ("id" in declaration &&
+        declaration.id !== null &&
+        declaration.id.type === AST_NODE_TYPES.Identifier) {
+        names.add(declaration.id.name);
+    }
+}
+/**
+ * Adds identifiers introduced by a top-level binding pattern.
+ * @param pattern Binding pattern to inspect.
+ * @param names Mutable output set.
+ * @example
+ * ```typescript
+ * collectPatternNames(pattern, names);
+ * ```
+ */
+function collectPatternNames(pattern, names) {
+    if (pattern.type === AST_NODE_TYPES.Identifier) {
+        names.add(pattern.name);
+        return;
+    }
+    if (pattern.type === AST_NODE_TYPES.AssignmentPattern) {
+        collectPatternNames(pattern.left, names);
+        return;
+    }
+    if (pattern.type === AST_NODE_TYPES.RestElement) {
+        collectPatternNames(pattern.argument, names);
+        return;
+    }
+    if (pattern.type === AST_NODE_TYPES.ArrayPattern) {
+        for (const element of pattern.elements) {
+            if (element !== null) {
+                collectPatternNames(element, names);
+            }
+        }
+        return;
+    }
+    if (pattern.type === AST_NODE_TYPES.ObjectPattern) {
+        for (const property of pattern.properties) {
+            collectPatternNames(property.type === AST_NODE_TYPES.Property
+                ? property.value
+                : property.argument, names);
+        }
+    }
+}
+/**
+ * Collects declarations from every lexical scope in a source file.
+ * @param scopeManager Parser scope information.
+ * @returns Names that could capture a generated type reference.
+ * @example
+ * ```typescript
+ * const names = collectScopeNames(sourceCode.scopeManager);
+ * ```
+ */
+function collectScopeNames(scopeManager) {
+    const names = new Set();
+    const scopes = scopeManager?.scopes ?? [];
+    for (const scope of scopes) {
+        const variables = scope.variables ?? [];
+        for (const variable of variables) {
+            if (typeof variable.name === "string") {
+                names.add(variable.name);
+            }
+        }
+    }
+    return names;
+}
+/**
+ * Collects all import, value, and type names declared at module scope.
+ * @param statements Program statements to inspect.
+ * @returns Names already declared at module scope.
+ * @example
+ * ```typescript
+ * const names = collectTopLevelNames(program.body);
+ * ```
+ */
+function collectTopLevelNames(statements) {
+    const names = new Set();
+    for (const statement of statements) {
+        if (statement.type === AST_NODE_TYPES.ImportDeclaration) {
+            for (const specifier of statement.specifiers) {
+                names.add(specifier.local.name);
+            }
+            continue;
+        }
+        if (statement.type === AST_NODE_TYPES.ExportNamedDeclaration ||
+            statement.type === AST_NODE_TYPES.ExportDefaultDeclaration) {
+            if (statement.declaration !== null &&
+                isNamedDeclaration(statement.declaration)) {
+                collectDeclarationNames(statement.declaration, names);
+            }
+            continue;
+        }
+        if (isNamedDeclaration(statement)) {
+            collectDeclarationNames(statement, names);
+        }
+    }
+    return names;
+}
+/**
+ * Checks whether a program statement contains a supported declaration.
+ * @param node Program node to inspect.
+ * @returns Whether the node is a supported declaration.
+ * @example
+ * ```typescript
+ * const named = isNamedDeclaration(statement);
+ * ```
+ */
+function isNamedDeclaration(node) {
+    return namedDeclarationTypes.has(node.type);
+}
+export { collectScopeNames, collectTopLevelNames };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"declaration-names.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/declaration-names.ts"],"names":[],"mappings":"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","sourcesContent":["import { AST_NODE_TYPES, type TSESTree } from \"@typescript-eslint/utils\";\n\nimport type { ScopeManager } from \"./types\";\n\n/** Declaration shapes that introduce names at module scope. */\ntype NamedDeclaration =\n  | TSESTree.ClassDeclaration\n  | TSESTree.FunctionDeclaration\n  | TSESTree.TSDeclareFunction\n  | TSESTree.TSEnumDeclaration\n  | TSESTree.TSInterfaceDeclaration\n  | TSESTree.TSModuleDeclaration\n  | TSESTree.TSTypeAliasDeclaration\n  | TSESTree.VariableDeclaration;\n\nconst namedDeclarationTypes = new Set<string>([\n  AST_NODE_TYPES.ClassDeclaration,\n  AST_NODE_TYPES.FunctionDeclaration,\n  AST_NODE_TYPES.TSDeclareFunction,\n  AST_NODE_TYPES.TSEnumDeclaration,\n  AST_NODE_TYPES.TSInterfaceDeclaration,\n  AST_NODE_TYPES.TSModuleDeclaration,\n  AST_NODE_TYPES.TSTypeAliasDeclaration,\n  AST_NODE_TYPES.VariableDeclaration,\n]);\n\n/**\n * Adds names introduced by one supported top-level declaration.\n * @param declaration Top-level declaration to inspect.\n * @param names Mutable output set.\n * @example\n * ```typescript\n * collectDeclarationNames(declaration, names);\n * ```\n */\nfunction collectDeclarationNames(\n  declaration: NamedDeclaration,\n  names: Set<string>,\n): void {\n  if (declaration.type === AST_NODE_TYPES.VariableDeclaration) {\n    for (const variable of declaration.declarations) {\n      collectPatternNames(variable.id, names);\n    }\n    return;\n  }\n\n  if (\n    \"id\" in declaration &&\n    declaration.id !== null &&\n    declaration.id.type === AST_NODE_TYPES.Identifier\n  ) {\n    names.add(declaration.id.name);\n  }\n}\n\n/**\n * Adds identifiers introduced by a top-level binding pattern.\n * @param pattern Binding pattern to inspect.\n * @param names Mutable output set.\n * @example\n * ```typescript\n * collectPatternNames(pattern, names);\n * ```\n */\nfunction collectPatternNames(pattern: TSESTree.Node, names: Set<string>): void {\n  if (pattern.type === AST_NODE_TYPES.Identifier) {\n    names.add(pattern.name);\n    return;\n  }\n\n  if (pattern.type === AST_NODE_TYPES.AssignmentPattern) {\n    collectPatternNames(pattern.left, names);\n    return;\n  }\n\n  if (pattern.type === AST_NODE_TYPES.RestElement) {\n    collectPatternNames(pattern.argument, names);\n    return;\n  }\n\n  if (pattern.type === AST_NODE_TYPES.ArrayPattern) {\n    for (const element of pattern.elements) {\n      if (element !== null) {\n        collectPatternNames(element, names);\n      }\n    }\n    return;\n  }\n\n  if (pattern.type === AST_NODE_TYPES.ObjectPattern) {\n    for (const property of pattern.properties) {\n      collectPatternNames(\n        property.type === AST_NODE_TYPES.Property\n          ? property.value\n          : property.argument,\n        names,\n      );\n    }\n  }\n}\n\n/**\n * Collects declarations from every lexical scope in a source file.\n * @param scopeManager Parser scope information.\n * @returns Names that could capture a generated type reference.\n * @example\n * ```typescript\n * const names = collectScopeNames(sourceCode.scopeManager);\n * ```\n */\nfunction collectScopeNames(\n  scopeManager: ScopeManager | undefined,\n): Set<string> {\n  const names = new Set<string>();\n  const scopes = scopeManager?.scopes ?? [];\n\n  for (const scope of scopes) {\n    const variables = scope.variables ?? [];\n\n    for (const variable of variables) {\n      if (typeof variable.name === \"string\") {\n        names.add(variable.name);\n      }\n    }\n  }\n\n  return names;\n}\n\n/**\n * Collects all import, value, and type names declared at module scope.\n * @param statements Program statements to inspect.\n * @returns Names already declared at module scope.\n * @example\n * ```typescript\n * const names = collectTopLevelNames(program.body);\n * ```\n */\nfunction collectTopLevelNames(statements: readonly unknown[]): Set<string> {\n  const names = new Set<string>();\n\n  for (const statement of statements as TSESTree.ProgramStatement[]) {\n    if (statement.type === AST_NODE_TYPES.ImportDeclaration) {\n      for (const specifier of statement.specifiers) {\n        names.add(specifier.local.name);\n      }\n      continue;\n    }\n\n    if (\n      statement.type === AST_NODE_TYPES.ExportNamedDeclaration ||\n      statement.type === AST_NODE_TYPES.ExportDefaultDeclaration\n    ) {\n      if (\n        statement.declaration !== null &&\n        isNamedDeclaration(statement.declaration)\n      ) {\n        collectDeclarationNames(statement.declaration, names);\n      }\n      continue;\n    }\n\n    if (isNamedDeclaration(statement)) {\n      collectDeclarationNames(statement, names);\n    }\n  }\n\n  return names;\n}\n\n/**\n * Checks whether a program statement contains a supported declaration.\n * @param node Program node to inspect.\n * @returns Whether the node is a supported declaration.\n * @example\n * ```typescript\n * const named = isNamedDeclaration(statement);\n * ```\n */\nfunction isNamedDeclaration(node: TSESTree.Node): node is NamedDeclaration {\n  return namedDeclarationTypes.has(node.type);\n}\n\nexport { collectScopeNames, collectTopLevelNames };\n"]}

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

@@ -0,0 +1,45 @@
+import type { InlineTypeMatch, NamedInlineTypeMatch } from "./types.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);
+ * ```
+ */
+declare function allocateNames(matches: readonly InlineTypeMatch[], topLevelStatements: readonly unknown[], reservedNames?: ReadonlySet<string>): NamedInlineTypeMatch[];
+/**
+ * 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);
+ * ```
+ */
+declare function getParameterBaseName(parameter: unknown): string;
+/**
+ * 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);
+ * ```
+ */
+declare function getReturnBaseName(functionNode: unknown): string;
+/**
+ * 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);
+ * ```
+ */
+declare function getVariableBaseName(variableNode: unknown): string;
+export { allocateNames, getParameterBaseName, getReturnBaseName, getVariableBaseName, };
+//# sourceMappingURL=naming.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/naming.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EAErB,MAAM,SAAS,CAAC;AAIjB;;;;;;;;;;GAUG;AACH,iBAAS,aAAa,CACpB,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,kBAAkB,EAAE,SAAS,OAAO,EAAE,EACtC,aAAa,GAAE,WAAW,CAAC,MAAM,CAAa,GAC7C,oBAAoB,EAAE,CAsBxB;AAiCD;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CA8BxD;AA8BD;;;;;;;;GAQG;AACH,iBAAS,iBAAiB,CAAC,YAAY,EAAE,OAAO,GAAG,MAAM,CA8BxD;AAED;;;;;;;;GAQG;AACH,iBAAS,mBAAmB,CAAC,YAAY,EAAE,OAAO,GAAG,MAAM,CAE1D;AA2BD,OAAO,EACL,aAAa,EACb,oBAAoB,EACpB,iBAAiB,EACjB,mBAAmB,GACpB,CAAC"}