@codeperfect/eslint-plugin 2.6.0 → 2.8.0

package/dist/domain/architecture/no-import-export-extensions/no-import-export-extensions-rule.js

@@ -0,0 +1,171 @@
+/** Set of disallowed module-specifier file extensions. */
+const disallowedExtensions = new Set([
+    ".cjs",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".mts",
+    ".ts",
+    ".tsx",
+]);
+/**
+ * Gets the trailing extension from a module specifier string.
+ * @param source Module specifier text.
+ * @returns File extension including the leading dot when present.
+ * @example
+ * ```typescript
+ * const extension = getTrailingExtension("./feature.ts");
+ * ```
+ */
+const getSpecifierEndIndex = (source) => {
+    const queryIndex = source.indexOf("?");
+    const hashIndex = source.indexOf("#");
+    const endIndexCandidates = [queryIndex, hashIndex].filter((index) => index >= 0);
+    return endIndexCandidates.length === 0
+        ? source.length
+        : Math.min(...endIndexCandidates);
+};
+/**
+ * Gets the trailing extension from a module specifier string.
+ * @param source Module specifier text.
+ * @returns File extension including the leading dot when present.
+ * @example
+ * ```typescript
+ * const extension = getTrailingExtension("./feature.ts");
+ * ```
+ */
+const getTrailingExtension = (source) => {
+    const endIndex = getSpecifierEndIndex(source);
+    const cleanedSource = source.slice(0, endIndex);
+    const lastSlashIndex = Math.max(cleanedSource.lastIndexOf("/"), cleanedSource.lastIndexOf("\\"));
+    const basename = cleanedSource.slice(lastSlashIndex + 1);
+    const dotIndex = basename.lastIndexOf(".");
+    if (dotIndex <= 0) {
+        return void 0;
+    }
+    return basename.slice(dotIndex).toLowerCase();
+};
+/**
+ * Builds the fixed source literal text with the disallowed extension removed.
+ * @param sourceLiteral Source literal node to fix.
+ * @returns Fixed source text including surrounding quotes.
+ * @example
+ * ```typescript
+ * const fixed = buildFixedSource(sourceLiteral);
+ * ```
+ */
+const buildFixedSource = (sourceLiteral) => {
+    const raw = sourceLiteral.raw;
+    const value = sourceLiteral.value;
+    if (typeof value !== "string" || raw === void 0) {
+        return void 0;
+    }
+    const quoteChar = raw[0];
+    const endIndex = getSpecifierEndIndex(value);
+    const cleanedSource = value.slice(0, endIndex);
+    const suffix = value.slice(endIndex);
+    const lastSlashIndex = Math.max(cleanedSource.lastIndexOf("/"), cleanedSource.lastIndexOf("\\"));
+    const basename = cleanedSource.slice(lastSlashIndex + 1);
+    const dotIndex = basename.lastIndexOf(".");
+    if (dotIndex <= 0) {
+        return void 0;
+    }
+    const withoutExtension = cleanedSource.slice(0, cleanedSource.length - basename.length + dotIndex);
+    return `${String(quoteChar)}${withoutExtension}${suffix}${String(quoteChar)}`;
+};
+/**
+ * Checks whether a source literal should be reported.
+ * @param sourceLiteral Source literal node.
+ * @returns True when the source includes a disallowed file extension.
+ * @example
+ * ```typescript
+ * const forbidden = hasDisallowedExtension(sourceLiteral);
+ * ```
+ */
+const hasDisallowedExtension = (sourceLiteral) => {
+    if (typeof sourceLiteral.value !== "string") {
+        return false;
+    }
+    const extension = getTrailingExtension(sourceLiteral.value);
+    return extension !== void 0 && disallowedExtensions.has(extension);
+};
+/**
+ * Reports a statement when it references a source with disallowed extension.
+ * @param context Rule execution context.
+ * @param statement Statement that may include a source literal.
+ * @example
+ * ```typescript
+ * reportWhenSourceHasExtension(context, statement);
+ * ```
+ */
+const reportWhenSourceHasExtension = (context, statement) => {
+    const sourceLiteral = statement.source;
+    if (sourceLiteral === null || sourceLiteral === void 0) {
+        return;
+    }
+    if (!hasDisallowedExtension(sourceLiteral)) {
+        return;
+    }
+    const fixedSource = buildFixedSource(sourceLiteral);
+    const fix = fixedSource === void 0
+        ? void 0
+        : (fixer) => fixer.replaceText(sourceLiteral, fixedSource);
+    context.report({
+        ...(fix !== void 0 && { fix }),
+        messageId: "unexpectedExtension",
+        node: sourceLiteral,
+        ...(fix !== void 0 && { suggest: [{ fix, messageId: "removeExtension" }] }),
+    });
+};
+/**
+ * Narrows one program statement to the source-bearing declarations this rule inspects.
+ * @param statement Program statement node.
+ * @returns Source-bearing declaration when supported.
+ * @example
+ * ```typescript
+ * const declaration = asSourceDeclaration(statement);
+ * ```
+ */
+const asSourceDeclaration = (statement) => {
+    if (statement.type === "ExportAllDeclaration") {
+        return statement;
+    }
+    if (statement.type === "ExportNamedDeclaration") {
+        return statement;
+    }
+    if (statement.type === "ImportDeclaration") {
+        return statement;
+    }
+    return void 0;
+};
+/** ESLint rule that forbids import/export module specifiers with explicit file extensions. */
+const noImportExportExtensionsRule = {
+    create: (context) => ({
+        Program(node) {
+            for (const statement of node.body) {
+                const declaration = asSourceDeclaration(statement);
+                if (declaration !== void 0) {
+                    reportWhenSourceHasExtension(context, declaration);
+                }
+            }
+        },
+    }),
+    meta: {
+        docs: {
+            description: "Forbid explicit file extensions in import/export module specifiers.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-import-export-extensions.md",
+        },
+        fixable: "code",
+        hasSuggestions: true,
+        messages: {
+            removeExtension: "Remove the file extension from this module specifier.",
+            unexpectedExtension: "Avoid file extensions in import/export module specifiers.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { noImportExportExtensionsRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"no-import-export-extensions-rule.js","sourceRoot":"","sources":["../../../../src/domain/architecture/no-import-export-extensions/no-import-export-extensions-rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\n/** Set of disallowed module-specifier file extensions. */\nconst disallowedExtensions = new Set([\n  \".cjs\",\n  \".cts\",\n  \".js\",\n  \".jsx\",\n  \".mjs\",\n  \".mts\",\n  \".ts\",\n  \".tsx\",\n]);\n\n/**\n * Gets the trailing extension from a module specifier string.\n * @param source Module specifier text.\n * @returns File extension including the leading dot when present.\n * @example\n * ```typescript\n * const extension = getTrailingExtension(\"./feature.ts\");\n * ```\n */\nconst getSpecifierEndIndex = (source: string): number => {\n  const queryIndex = source.indexOf(\"?\");\n  const hashIndex = source.indexOf(\"#\");\n  const endIndexCandidates = [queryIndex, hashIndex].filter(\n    (index) => index >= 0,\n  );\n\n  return endIndexCandidates.length === 0\n    ? source.length\n    : Math.min(...endIndexCandidates);\n};\n\n/**\n * Gets the trailing extension from a module specifier string.\n * @param source Module specifier text.\n * @returns File extension including the leading dot when present.\n * @example\n * ```typescript\n * const extension = getTrailingExtension(\"./feature.ts\");\n * ```\n */\nconst getTrailingExtension = (source: string): string | undefined => {\n  const endIndex = getSpecifierEndIndex(source);\n  const cleanedSource = source.slice(0, endIndex);\n  const lastSlashIndex = Math.max(\n    cleanedSource.lastIndexOf(\"/\"),\n    cleanedSource.lastIndexOf(\"\\\\\"),\n  );\n  const basename = cleanedSource.slice(lastSlashIndex + 1);\n  const dotIndex = basename.lastIndexOf(\".\");\n\n  if (dotIndex <= 0) {\n    return void 0;\n  }\n\n  return basename.slice(dotIndex).toLowerCase();\n};\n\n/**\n * Builds the fixed source literal text with the disallowed extension removed.\n * @param sourceLiteral Source literal node to fix.\n * @returns Fixed source text including surrounding quotes.\n * @example\n * ```typescript\n * const fixed = buildFixedSource(sourceLiteral);\n * ```\n */\nconst buildFixedSource = (\n  sourceLiteral: ESTree.Literal,\n): string | undefined => {\n  const raw = sourceLiteral.raw;\n  const value = sourceLiteral.value;\n\n  if (typeof value !== \"string\" || raw === void 0) {\n    return void 0;\n  }\n\n  const quoteChar = raw[0];\n  const endIndex = getSpecifierEndIndex(value);\n  const cleanedSource = value.slice(0, endIndex);\n  const suffix = value.slice(endIndex);\n  const lastSlashIndex = Math.max(\n    cleanedSource.lastIndexOf(\"/\"),\n    cleanedSource.lastIndexOf(\"\\\\\"),\n  );\n  const basename = cleanedSource.slice(lastSlashIndex + 1);\n  const dotIndex = basename.lastIndexOf(\".\");\n\n  if (dotIndex <= 0) {\n    return void 0;\n  }\n\n  const withoutExtension = cleanedSource.slice(\n    0,\n    cleanedSource.length - basename.length + dotIndex,\n  );\n\n  return `${String(quoteChar)}${withoutExtension}${suffix}${String(quoteChar)}`;\n};\n\n/**\n * Checks whether a source literal should be reported.\n * @param sourceLiteral Source literal node.\n * @returns True when the source includes a disallowed file extension.\n * @example\n * ```typescript\n * const forbidden = hasDisallowedExtension(sourceLiteral);\n * ```\n */\nconst hasDisallowedExtension = (sourceLiteral: ESTree.Literal): boolean => {\n  if (typeof sourceLiteral.value !== \"string\") {\n    return false;\n  }\n\n  const extension = getTrailingExtension(sourceLiteral.value);\n\n  return extension !== void 0 && disallowedExtensions.has(extension);\n};\n\n/**\n * Reports a statement when it references a source with disallowed extension.\n * @param context Rule execution context.\n * @param statement Statement that may include a source literal.\n * @example\n * ```typescript\n * reportWhenSourceHasExtension(context, statement);\n * ```\n */\nconst reportWhenSourceHasExtension = (\n  context: Rule.RuleContext,\n  statement:\n    | ESTree.ExportAllDeclaration\n    | ESTree.ExportNamedDeclaration\n    | ESTree.ImportDeclaration,\n): void => {\n  const sourceLiteral = statement.source;\n\n  if (sourceLiteral === null || sourceLiteral === void 0) {\n    return;\n  }\n\n  if (!hasDisallowedExtension(sourceLiteral)) {\n    return;\n  }\n\n  const fixedSource = buildFixedSource(sourceLiteral);\n\n  const fix =\n    fixedSource === void 0\n      ? void 0\n      : (fixer: Rule.RuleFixer): Rule.Fix =>\n          fixer.replaceText(sourceLiteral, fixedSource);\n\n  context.report({\n    ...(fix !== void 0 && { fix }),\n    messageId: \"unexpectedExtension\",\n    node: sourceLiteral,\n    ...(fix !== void 0 && { suggest: [{ fix, messageId: \"removeExtension\" }] }),\n  });\n};\n\n/**\n * Narrows one program statement to the source-bearing declarations this rule inspects.\n * @param statement Program statement node.\n * @returns Source-bearing declaration when supported.\n * @example\n * ```typescript\n * const declaration = asSourceDeclaration(statement);\n * ```\n */\nconst asSourceDeclaration = (\n  statement: ESTree.Program[\"body\"][number],\n):\n  | ESTree.ExportAllDeclaration\n  | ESTree.ExportNamedDeclaration\n  | ESTree.ImportDeclaration\n  | undefined => {\n  if (statement.type === \"ExportAllDeclaration\") {\n    return statement;\n  }\n\n  if (statement.type === \"ExportNamedDeclaration\") {\n    return statement;\n  }\n\n  if (statement.type === \"ImportDeclaration\") {\n    return statement;\n  }\n\n  return void 0;\n};\n\n/** ESLint rule that forbids import/export module specifiers with explicit file extensions. */\nconst noImportExportExtensionsRule: Rule.RuleModule = {\n  create: (context: Rule.RuleContext): Rule.RuleListener => ({\n    Program(node: ESTree.Program): void {\n      for (const statement of node.body) {\n        const declaration = asSourceDeclaration(statement);\n\n        if (declaration !== void 0) {\n          reportWhenSourceHasExtension(context, declaration);\n        }\n      }\n    },\n  }),\n  meta: {\n    docs: {\n      description:\n        \"Forbid explicit file extensions in import/export module specifiers.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-import-export-extensions.md\",\n    },\n    fixable: \"code\",\n    hasSuggestions: true,\n    messages: {\n      removeExtension: \"Remove the file extension from this module specifier.\",\n      unexpectedExtension:\n        \"Avoid file extensions in import/export module specifiers.\",\n    },\n    schema: [],\n    type: \"problem\",\n  },\n};\n\nexport { noImportExportExtensionsRule };\n"]}

package/dist/domain/core/no-multiple-declarators/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAgFnC,4EAA4E;AAC5E,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UAqBrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-multiple-declarators/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAmFnC,4EAA4E;AAC5E,QAAA,MAAM,yBAAyB,EAAE,IAAI,CAAC,UAwBrC,CAAC;AAEF,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/dist/domain/core/no-multiple-declarators/rule.js

@@ -42,6 +42,9 @@ const reportVariableDeclaration = (context, node) => {
         ...(fix !== void 0 && { fix }),
         messageId: "singleDeclarator",
         node: node,
+        ...(fix !== void 0 && {
+            suggest: [{ fix, messageId: "splitDeclaration" }],
+        }),
     });
 };
 /** ESLint rule implementation for single-declarator variable statements. */
@@ -58,12 +61,14 @@ const noMultipleDeclaratorsRule = {
             url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-multiple-declarators.md",
         },
         fixable: "code",
+        hasSuggestions: true,
         messages: {
             singleDeclarator: "Declare exactly one variable per declaration statement.",
+            splitDeclaration: "Split this declaration into separate single-variable statements.",
         },
         schema: [],
         type: "suggestion",
     },
 };
 export { noMultipleDeclaratorsRule };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kb21haW4vY29yZS9uby1tdWx0aXBsZS1kZWNsYXJhdG9ycy9ydWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVFBLE9BQU8sRUFDTCxnQkFBZ0IsRUFDaEIsTUFBTSxFQUNOLHFCQUFxQixFQUNyQixhQUFhLEVBQ2IsYUFBYSxHQUNkLE1BQU0sa0JBQWtCLENBQUM7QUFDMUIsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUVyQzs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxvQkFBb0IsR0FBRyxDQUMzQixJQUE2QixFQUM3QixZQUErQyxFQUMvQyxVQUE0QixFQUN1QixFQUFFO0lBQ3JELE1BQU0sVUFBVSxHQUFHLGFBQWEsQ0FBQyxVQUFVLENBQUMsQ0FBQztJQUU3QyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksRUFBRSxZQUFZLEVBQUUsVUFBVSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQztRQUNqRSxPQUFPLEtBQUssQ0FBQyxDQUFDO0lBQ2hCLENBQUM7SUFFRCxNQUFNLGtCQUFrQixHQUFHLHFCQUFxQixDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQy9ELElBQUksa0JBQWtCLEtBQUssS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUNsQyxPQUFPLEtBQUssQ0FBQyxDQUFDO0lBQ2hCLENBQUM7SUFFRCxPQUFPLENBQUMsS0FBcUIsRUFBWSxFQUFFLENBQ3pDLEtBQUssQ0FBQyxnQkFBZ0IsQ0FDcEIsSUFBSSxDQUFDLEtBQUssRUFDVixnQkFBZ0IsQ0FBQyxJQUFJLEVBQUUsa0JBQWtCLEVBQUUsVUFBVSxDQUFDLENBQ3ZELENBQUM7QUFDTixDQUFDLENBQUM7QUFFRjs7Ozs7Ozs7R0FRRztBQUNILE1BQU0seUJBQXlCLEdBQUcsQ0FDaEMsT0FBeUIsRUFDekIsSUFBNkIsRUFDdkIsRUFBRTtJQUNSLE1BQU0sWUFBWSxHQUFHLElBQUksQ0FBQyxZQUFZLElBQUksRUFBRSxDQUFDO0lBRTdDLElBQUksWUFBWSxDQUFDLE1BQU0sSUFBSSxDQUFDLEVBQUUsQ0FBQztRQUM3QixPQUFPO0lBQ1QsQ0FBQztJQUVELE1BQU0sVUFBVSxHQUFHLGFBQWEsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUMxQyxNQUFNLEdBQUcsR0FBRyxvQkFBb0IsQ0FBQyxJQUFJLEVBQUUsWUFBWSxFQUFFLFVBQVUsQ0FBQyxDQUFDO0lBRWpFLE9BQU8sQ0FBQyxNQUFNLENBQUM7UUFDYixHQUFHLENBQUMsR0FBRyxLQUFLLEtBQUssQ0FBQyxJQUFJLEVBQUUsR0FBRyxFQUFFLENBQUM7UUFDOUIsU0FBUyxFQUFFLGtCQUFrQjtRQUM3QixJQUFJLEVBQUUsSUFBNEI7UUFDbEMsR0FBRyxDQUFDLEdBQUcsS0FBSyxLQUFLLENBQUMsSUFBSTtZQUNwQixPQUFPLEVBQUUsQ0FBQyxFQUFFLEdBQUcsRUFBRSxTQUFTLEVBQUUsa0JBQWtCLEVBQUUsQ0FBQztTQUNsRCxDQUFDO0tBQ0gsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDO0FBRUYsNEVBQTRFO0FBQzVFLE1BQU0seUJBQXlCLEdBQW9CO0lBQ2pELE1BQU0sRUFBRSxDQUFDLE9BQXlCLEVBQXFCLEVBQUUsQ0FBQyxDQUFDO1FBQ3pELG1CQUFtQixFQUFFLENBQUMsSUFBZSxFQUFRLEVBQUU7WUFDN0MseUJBQXlCLENBQUMsT0FBTyxFQUFFLElBQStCLENBQUMsQ0FBQztRQUN0RSxDQUFDO0tBQ0YsQ0FBQztJQUNGLElBQUksRUFBRTtRQUNKLElBQUksRUFBRTtZQUNKLFdBQVcsRUFDVCxnRkFBZ0Y7WUFDbEYsV0FBVyxFQUFFLEtBQUs7WUFDbEIsR0FBRyxFQUFFLDBGQUEwRjtTQUNoRztRQUNELE9BQU8sRUFBRSxNQUFNO1FBQ2YsY0FBYyxFQUFFLElBQUk7UUFDcEIsUUFBUSxFQUFFO1lBQ1IsZ0JBQWdCLEVBQ2QseURBQXlEO1lBQzNELGdCQUFnQixFQUNkLGtFQUFrRTtTQUNyRTtRQUNELE1BQU0sRUFBRSxFQUFFO1FBQ1YsSUFBSSxFQUFFLFlBQVk7S0FDbkI7Q0FDRixDQUFDO0FBRUYsT0FBTyxFQUFFLHlCQUF5QixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJ1bGUgfSBmcm9tIFwiZXNsaW50XCI7XG5cbmltcG9ydCB0eXBlIHtcbiAgU291cmNlQ29kZUFjY2VzcyxcbiAgVmFyaWFibGVEZWNsYXJhdGlvbk5vZGUsXG4gIFZhcmlhYmxlRGVjbGFyYXRvck5vZGUsXG59IGZyb20gXCIuL3R5cGVzXCI7XG5cbmltcG9ydCB7XG4gIGJ1aWxkUmVwbGFjZW1lbnQsXG4gIGNhbkZpeCxcbiAgZ2V0UmFuZ2VkRGVjbGFyYXRpb25zLFxuICBnZXRTb3VyY2VDb2RlLFxuICBnZXRTb3VyY2VUZXh0LFxufSBmcm9tIFwiLi9ydWxlLXV0aWxpdGllc1wiO1xuaW1wb3J0IHsgaGFzRml4RGF0YSB9IGZyb20gXCIuL3R5cGVzXCI7XG5cbi8qKlxuICogQ3JlYXRlcyBhbiBhdXRvZml4IGNhbGxiYWNrIHdoZW4gdGhlIGRlY2xhcmF0aW9uIGNhbiBiZSByZXdyaXR0ZW4gc2FmZWx5LlxuICogQHBhcmFtIG5vZGUgRGVjbGFyYXRpb24gbm9kZSB0byBpbnNwZWN0LlxuICogQHBhcmFtIGRlY2xhcmF0aW9ucyBEZWNsYXJhdG9ycyBmcm9tIHRoZSBkZWNsYXJhdGlvbiBzdGF0ZW1lbnQuXG4gKiBAcGFyYW0gc291cmNlQ29kZSBTb3VyY2UgYWNjZXNzIHdyYXBwZXIuXG4gKiBAcmV0dXJucyBGaXggY2FsbGJhY2sgd2hlbiB0aGUgZGVjbGFyYXRpb24gaXMgc2FmZSB0byBzcGxpdC5cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiBjb25zdCBmaXggPSBjcmVhdGVEZWNsYXJhdGlvbkZpeChub2RlLCBkZWNsYXJhdGlvbnMsIHNvdXJjZUNvZGUpO1xuICogYGBgXG4gKi9cbmNvbnN0IGNyZWF0ZURlY2xhcmF0aW9uRml4ID0gKFxuICBub2RlOiBWYXJpYWJsZURlY2xhcmF0aW9uTm9kZSxcbiAgZGVjbGFyYXRpb25zOiByZWFkb25seSBWYXJpYWJsZURlY2xhcmF0b3JOb2RlW10sXG4gIHNvdXJjZUNvZGU6IFNvdXJjZUNvZGVBY2Nlc3MsXG4pOiAoKGZpeGVyOiBSdWxlLlJ1bGVGaXhlcikgPT4gUnVsZS5GaXgpIHwgdW5kZWZpbmVkID0+IHtcbiAgY29uc3Qgc291cmNlVGV4dCA9IGdldFNvdXJjZVRleHQoc291cmNlQ29kZSk7XG5cbiAgaWYgKCFjYW5GaXgobm9kZSwgZGVjbGFyYXRpb25zLCBzb3VyY2VUZXh0KSB8fCAhaGFzRml4RGF0YShub2RlKSkge1xuICAgIHJldHVybiB2b2lkIDA7XG4gIH1cblxuICBjb25zdCByYW5nZWREZWNsYXJhdGlvbnMgPSBnZXRSYW5nZWREZWNsYXJhdGlvbnMoZGVjbGFyYXRpb25zKTtcbiAgaWYgKHJhbmdlZERlY2xhcmF0aW9ucyA9PT0gdm9pZCAwKSB7XG4gICAgcmV0dXJuIHZvaWQgMDtcbiAgfVxuXG4gIHJldHVybiAoZml4ZXI6IFJ1bGUuUnVsZUZpeGVyKTogUnVsZS5GaXggPT5cbiAgICBmaXhlci5yZXBsYWNlVGV4dFJhbmdlKFxuICAgICAgbm9kZS5yYW5nZSxcbiAgICAgIGJ1aWxkUmVwbGFjZW1lbnQobm9kZSwgcmFuZ2VkRGVjbGFyYXRpb25zLCBzb3VyY2VDb2RlKSxcbiAgICApO1xufTtcblxuLyoqXG4gKiBSZXBvcnRzIGRlY2xhcmF0aW9ucyB0aGF0IGNvbnRhaW4gbW9yZSB0aGFuIG9uZSBkZWNsYXJhdG9yLlxuICogQHBhcmFtIGNvbnRleHQgUnVsZSBleGVjdXRpb24gY29udGV4dC5cbiAqIEBwYXJhbSBub2RlIERlY2xhcmF0aW9uIG5vZGUgdG8gcmVwb3J0LlxuICogQGV4YW1wbGVcbiAqIGBgYHR5cGVzY3JpcHRcbiAqIHJlcG9ydFZhcmlhYmxlRGVjbGFyYXRpb24oY29udGV4dCwgbm9kZSk7XG4gKiBgYGBcbiAqL1xuY29uc3QgcmVwb3J0VmFyaWFibGVEZWNsYXJhdGlvbiA9IChcbiAgY29udGV4dDogUnVsZS5SdWxlQ29udGV4dCxcbiAgbm9kZTogVmFyaWFibGVEZWNsYXJhdGlvbk5vZGUsXG4pOiB2b2lkID0+IHtcbiAgY29uc3QgZGVjbGFyYXRpb25zID0gbm9kZS5kZWNsYXJhdGlvbnMgPz8gW107XG5cbiAgaWYgKGRlY2xhcmF0aW9ucy5sZW5ndGggPD0gMSkge1xuICAgIHJldHVybjtcbiAgfVxuXG4gIGNvbnN0IHNvdXJjZUNvZGUgPSBnZXRTb3VyY2VDb2RlKGNvbnRleHQpO1xuICBjb25zdCBmaXggPSBjcmVhdGVEZWNsYXJhdGlvbkZpeChub2RlLCBkZWNsYXJhdGlvbnMsIHNvdXJjZUNvZGUpO1xuXG4gIGNvbnRleHQucmVwb3J0KHtcbiAgICAuLi4oZml4ICE9PSB2b2lkIDAgJiYgeyBmaXggfSksXG4gICAgbWVzc2FnZUlkOiBcInNpbmdsZURlY2xhcmF0b3JcIixcbiAgICBub2RlOiBub2RlIGFzIHVua25vd24gYXMgUnVsZS5Ob2RlLFxuICAgIC4uLihmaXggIT09IHZvaWQgMCAmJiB7XG4gICAgICBzdWdnZXN0OiBbeyBmaXgsIG1lc3NhZ2VJZDogXCJzcGxpdERlY2xhcmF0aW9uXCIgfV0sXG4gICAgfSksXG4gIH0pO1xufTtcblxuLyoqIEVTTGludCBydWxlIGltcGxlbWVudGF0aW9uIGZvciBzaW5nbGUtZGVjbGFyYXRvciB2YXJpYWJsZSBzdGF0ZW1lbnRzLiAqL1xuY29uc3Qgbm9NdWx0aXBsZURlY2xhcmF0b3JzUnVsZTogUnVsZS5SdWxlTW9kdWxlID0ge1xuICBjcmVhdGU6IChjb250ZXh0OiBSdWxlLlJ1bGVDb250ZXh0KTogUnVsZS5SdWxlTGlzdGVuZXIgPT4gKHtcbiAgICBWYXJpYWJsZURlY2xhcmF0aW9uOiAobm9kZTogUnVsZS5Ob2RlKTogdm9pZCA9PiB7XG4gICAgICByZXBvcnRWYXJpYWJsZURlY2xhcmF0aW9uKGNvbnRleHQsIG5vZGUgYXMgVmFyaWFibGVEZWNsYXJhdGlvbk5vZGUpO1xuICAgIH0sXG4gIH0pLFxuICBtZXRhOiB7XG4gICAgZG9jczoge1xuICAgICAgZGVzY3JpcHRpb246XG4gICAgICAgIFwiUmVxdWlyZSB2YXJpYWJsZSBkZWNsYXJhdGlvbnMgdG8gY29udGFpbiBleGFjdGx5IG9uZSBkZWNsYXJhdG9yIHBlciBzdGF0ZW1lbnQuXCIsXG4gICAgICByZWNvbW1lbmRlZDogZmFsc2UsXG4gICAgICB1cmw6IFwiaHR0cHM6Ly9naXRodWIuY29tL3BhcmxvdGkvZXNsaW50LXBsdWdpbi9ibG9iL21haW4vZG9jcy9ydWxlcy9uby1tdWx0aXBsZS1kZWNsYXJhdG9ycy5tZFwiLFxuICAgIH0sXG4gICAgZml4YWJsZTogXCJjb2RlXCIsXG4gICAgaGFzU3VnZ2VzdGlvbnM6IHRydWUsXG4gICAgbWVzc2FnZXM6IHtcbiAgICAgIHNpbmdsZURlY2xhcmF0b3I6XG4gICAgICAgIFwiRGVjbGFyZSBleGFjdGx5IG9uZSB2YXJpYWJsZSBwZXIgZGVjbGFyYXRpb24gc3RhdGVtZW50LlwiLFxuICAgICAgc3BsaXREZWNsYXJhdGlvbjpcbiAgICAgICAgXCJTcGxpdCB0aGlzIGRlY2xhcmF0aW9uIGludG8gc2VwYXJhdGUgc2luZ2xlLXZhcmlhYmxlIHN0YXRlbWVudHMuXCIsXG4gICAgfSxcbiAgICBzY2hlbWE6IFtdLFxuICAgIHR5cGU6IFwic3VnZ2VzdGlvblwiLFxuICB9LFxufTtcblxuZXhwb3J0IHsgbm9NdWx0aXBsZURlY2xhcmF0b3JzUnVsZSB9O1xuIl19

package/dist/domain/core/no-multiple-declarators/types.js

@@ -38,4 +38,4 @@ function isRange(value) {
         value[0] <= value[1]);
 }
 export { hasFixData, hasRange };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/core/no-useless-delegation/rule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-useless-delegation/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AA0OnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAqCnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/no-useless-delegation/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AA6OnC,kFAAkF;AAClF,QAAA,MAAM,uBAAuB,EAAE,IAAI,CAAC,UAqCnC,CAAC;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/domain/core/no-useless-delegation/rule.js

@@ -106,16 +106,15 @@ const forwardsParameter = (argument, parameter) => {
     return getIdentifierName(argument) === parameter.name;
 };
 /**
- * Determines whether a call invokes a method on a literal value.
- * @param callee Call target to inspect.
- * @returns Whether the target is a member access on a literal receiver.
+ * Determines whether a node is a plain named reference.
+ * @param node Candidate receiver node to inspect.
+ * @returns Whether the node is a plain identifier reference.
  * @example
  * ```typescript
- * const isLiteralCall = isLiteralMemberCall(callee);
+ * const isNamed = isNamedReceiver({ type: "Identifier" });
  * ```
  */
-const isLiteralMemberCall = (callee) => callee.type === "MemberExpression" &&
-    asNode(callee["object"])?.type === "Literal";
+const isNamedReceiver = (node) => node?.type === "Identifier";
 /**
  * Determines whether a function does nothing except directly call another function.
  * @param functionNode Function node to inspect.
@@ -135,7 +134,12 @@ const isUselessDelegation = (functionNode, functionName) => {
         parameters === void 0 ||
         arguments_ === void 0 ||
         callee === void 0 ||
-        isLiteralMemberCall(callee) ||
+        // A method call is only a replaceable delegation when its receiver is a
+        // plain named reference (e.g. `service.run`). Expression receivers such
+        // as type assertions, calls, or literals cannot be inlined at the call
+        // site, so the wrapper is not useless.
+        (callee.type === "MemberExpression" &&
+            !isNamedReceiver(asNode(callee["object"]))) ||
         getIdentifierName(callee) === functionName ||
         arguments_.length !== parameters.length) {
         return false;
@@ -197,4 +201,4 @@ const noUselessDelegationRule = {
     },
 };
 export { noUselessDelegationRule };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/no-useless-delegation/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\n/** One named parameter and whether it must be spread at the call site. */\ninterface DelegatedParameter {\n  /** Whether this parameter uses rest syntax. */\n  isRest: boolean;\n  /** Parameter identifier name. */\n  name: string;\n}\n\n/** Minimal ESTree node shape used to inspect pass-through functions. */\ninterface Node {\n  /** Dynamically read child nodes and parser-specific properties. */\n  [key: string]: unknown;\n  /** Whether the function is asynchronous. */\n  async?: boolean;\n  /** Whether the function is a generator. */\n  generator?: boolean;\n  /** ESTree discriminator. */\n  type: string;\n}\n\n/**\n * Resolves a node value when it is an ESTree node.\n * @param value Candidate AST value.\n * @returns The value as an ESTree node when it has a type discriminator.\n * @example\n * ```typescript\n * const node = asNode({ type: \"Identifier\" });\n * ```\n */\nconst asNode = (value: unknown): Node | undefined =>\n  typeof value === \"object\" && value !== null && \"type\" in value\n    ? (value as Node)\n    : void 0;\n\n/**\n * Resolves a node array while rejecting malformed AST data.\n * @param value Candidate AST value.\n * @returns AST nodes when every array item is a node.\n * @example\n * ```typescript\n * const nodes = asNodeArray([{ type: \"Identifier\" }]);\n * ```\n */\nconst asNodeArray = (value: unknown): Node[] | undefined =>\n  Array.isArray(value) && value.every((item) => asNode(item) !== void 0)\n    ? (value as Node[])\n    : void 0;\n\n/**\n * Reads an identifier name from a node.\n * @param node Candidate identifier node.\n * @returns Identifier name when the node is an identifier.\n * @example\n * ```typescript\n * const name = getIdentifierName({ name: \"run\", type: \"Identifier\" });\n * ```\n */\nconst getIdentifierName = (node: Node | undefined): string | undefined =>\n  node?.type === \"Identifier\" && typeof node[\"name\"] === \"string\"\n    ? node[\"name\"]\n    : void 0;\n\n/**\n * Gets the called expression from a function with one return statement.\n * @param functionNode Function node to inspect.\n * @returns The directly returned call expression when present.\n * @example\n * ```typescript\n * const call = getDelegatedCall(functionNode);\n * ```\n */\nconst getDelegatedCall = (functionNode: Node): Node | undefined => {\n  if (functionNode.async === true || functionNode.generator === true) {\n    return void 0;\n  }\n\n  const body = asNode(functionNode[\"body\"]);\n  if (body === void 0) {\n    return void 0;\n  }\n\n  if (body.type === \"CallExpression\") {\n    return body;\n  }\n\n  const statements = asNodeArray(body[\"body\"]);\n  if (body.type !== \"BlockStatement\" || statements?.length !== 1) {\n    return void 0;\n  }\n\n  const returnStatement = statements[0];\n  return returnStatement?.type === \"ReturnStatement\"\n    ? asNode(returnStatement[\"argument\"])\n    : void 0;\n};\n\n/**\n * Gets parameter names and whether each parameter is a rest parameter.\n * @param functionNode Function node to inspect.\n * @returns Named parameter metadata when every parameter is supported.\n * @example\n * ```typescript\n * const parameters = getParameters(functionNode);\n * ```\n */\nconst getParameters = (\n  functionNode: Node,\n): DelegatedParameter[] | undefined => {\n  const parameters = asNodeArray(functionNode[\"params\"]);\n  if (parameters === void 0) {\n    return void 0;\n  }\n\n  const result: DelegatedParameter[] = [];\n  for (const parameter of parameters) {\n    const isRest = parameter.type === \"RestElement\";\n    const name = getIdentifierName(\n      isRest ? asNode(parameter[\"argument\"]) : parameter,\n    );\n    if (name === void 0) {\n      return void 0;\n    }\n\n    result.push({ isRest, name });\n  }\n\n  return result;\n};\n\n/**\n * Determines whether one call argument forwards its corresponding parameter.\n * @param argument Call argument to inspect.\n * @param parameter Corresponding function parameter.\n * @returns Whether the argument forwards the parameter without change.\n * @example\n * ```typescript\n * const forwards = forwardsParameter(argument, parameter);\n * ```\n */\nconst forwardsParameter = (\n  argument: Node,\n  parameter: DelegatedParameter,\n): boolean => {\n  if (parameter.isRest) {\n    return (\n      argument.type === \"SpreadElement\" &&\n      getIdentifierName(asNode(argument[\"argument\"])) === parameter.name\n    );\n  }\n\n  return getIdentifierName(argument) === parameter.name;\n};\n\n/**\n * Determines whether a call invokes a method on a literal value.\n * @param callee Call target to inspect.\n * @returns Whether the target is a member access on a literal receiver.\n * @example\n * ```typescript\n * const isLiteralCall = isLiteralMemberCall(callee);\n * ```\n */\nconst isLiteralMemberCall = (callee: Node): boolean =>\n  callee.type === \"MemberExpression\" &&\n  asNode(callee[\"object\"])?.type === \"Literal\";\n\n/**\n * Determines whether a function does nothing except directly call another function.\n * @param functionNode Function node to inspect.\n * @param functionName Declared wrapper function name.\n * @returns Whether the function is an exact synchronous delegation.\n * @example\n * ```typescript\n * const isDelegation = isUselessDelegation(functionNode, \"run\");\n * ```\n */\nconst isUselessDelegation = (\n  functionNode: Node,\n  functionName: string,\n): boolean => {\n  const call = getDelegatedCall(functionNode);\n  const parameters = getParameters(functionNode);\n  const arguments_ = asNodeArray(call?.[\"arguments\"]);\n  const callee = asNode(call?.[\"callee\"]);\n\n  if (\n    call?.type !== \"CallExpression\" ||\n    parameters === void 0 ||\n    arguments_ === void 0 ||\n    callee === void 0 ||\n    isLiteralMemberCall(callee) ||\n    getIdentifierName(callee) === functionName ||\n    arguments_.length !== parameters.length\n  ) {\n    return false;\n  }\n\n  return arguments_.every((argument, index) => {\n    const parameter = parameters[index];\n    return parameter !== void 0 && forwardsParameter(argument, parameter);\n  });\n};\n\n/**\n * Reports a function when it is a no-op delegation.\n * @param context Rule execution context.\n * @param functionNode Function node to inspect.\n * @param nameNode Declared wrapper name node.\n * @example\n * ```typescript\n * reportIfUselessDelegation(context, functionNode, nameNode);\n * ```\n */\nconst reportIfUselessDelegation = (\n  context: Rule.RuleContext,\n  functionNode: Node,\n  nameNode: Node | undefined,\n): void => {\n  const functionName = getIdentifierName(nameNode);\n  if (\n    functionName === void 0 ||\n    !isUselessDelegation(functionNode, functionName)\n  ) {\n    return;\n  }\n\n  context.report({\n    messageId: \"uselessDelegation\",\n    node: nameNode as unknown as Rule.Node,\n  });\n};\n\n/** ESLint rule implementation for functions that only forward their arguments. */\nconst noUselessDelegationRule: Rule.RuleModule = {\n  create: (context: Rule.RuleContext): Rule.RuleListener => ({\n    FunctionDeclaration: (node: Rule.Node): void => {\n      const functionNode = node as unknown as Node;\n      reportIfUselessDelegation(\n        context,\n        functionNode,\n        asNode(functionNode[\"id\"]),\n      );\n    },\n    VariableDeclarator: (node: Rule.Node): void => {\n      const declarator = node as unknown as Node;\n      const initializer = asNode(declarator[\"init\"]);\n      if (\n        initializer?.type !== \"ArrowFunctionExpression\" &&\n        initializer?.type !== \"FunctionExpression\"\n      ) {\n        return;\n      }\n\n      reportIfUselessDelegation(context, initializer, asNode(declarator[\"id\"]));\n    },\n  }),\n  meta: {\n    docs: {\n      description:\n        \"Disallow named functions that only delegate directly to another call.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-useless-delegation.md\",\n    },\n    messages: {\n      uselessDelegation:\n        \"This function only delegates to another call; remove the wrapper or call the target directly.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { noUselessDelegationRule };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/no-useless-delegation/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\n/** One named parameter and whether it must be spread at the call site. */\ninterface DelegatedParameter {\n  /** Whether this parameter uses rest syntax. */\n  isRest: boolean;\n  /** Parameter identifier name. */\n  name: string;\n}\n\n/** Minimal ESTree node shape used to inspect pass-through functions. */\ninterface Node {\n  /** Dynamically read child nodes and parser-specific properties. */\n  [key: string]: unknown;\n  /** Whether the function is asynchronous. */\n  async?: boolean;\n  /** Whether the function is a generator. */\n  generator?: boolean;\n  /** ESTree discriminator. */\n  type: string;\n}\n\n/**\n * Resolves a node value when it is an ESTree node.\n * @param value Candidate AST value.\n * @returns The value as an ESTree node when it has a type discriminator.\n * @example\n * ```typescript\n * const node = asNode({ type: \"Identifier\" });\n * ```\n */\nconst asNode = (value: unknown): Node | undefined =>\n  typeof value === \"object\" && value !== null && \"type\" in value\n    ? (value as Node)\n    : void 0;\n\n/**\n * Resolves a node array while rejecting malformed AST data.\n * @param value Candidate AST value.\n * @returns AST nodes when every array item is a node.\n * @example\n * ```typescript\n * const nodes = asNodeArray([{ type: \"Identifier\" }]);\n * ```\n */\nconst asNodeArray = (value: unknown): Node[] | undefined =>\n  Array.isArray(value) && value.every((item) => asNode(item) !== void 0)\n    ? (value as Node[])\n    : void 0;\n\n/**\n * Reads an identifier name from a node.\n * @param node Candidate identifier node.\n * @returns Identifier name when the node is an identifier.\n * @example\n * ```typescript\n * const name = getIdentifierName({ name: \"run\", type: \"Identifier\" });\n * ```\n */\nconst getIdentifierName = (node: Node | undefined): string | undefined =>\n  node?.type === \"Identifier\" && typeof node[\"name\"] === \"string\"\n    ? node[\"name\"]\n    : void 0;\n\n/**\n * Gets the called expression from a function with one return statement.\n * @param functionNode Function node to inspect.\n * @returns The directly returned call expression when present.\n * @example\n * ```typescript\n * const call = getDelegatedCall(functionNode);\n * ```\n */\nconst getDelegatedCall = (functionNode: Node): Node | undefined => {\n  if (functionNode.async === true || functionNode.generator === true) {\n    return void 0;\n  }\n\n  const body = asNode(functionNode[\"body\"]);\n  if (body === void 0) {\n    return void 0;\n  }\n\n  if (body.type === \"CallExpression\") {\n    return body;\n  }\n\n  const statements = asNodeArray(body[\"body\"]);\n  if (body.type !== \"BlockStatement\" || statements?.length !== 1) {\n    return void 0;\n  }\n\n  const returnStatement = statements[0];\n  return returnStatement?.type === \"ReturnStatement\"\n    ? asNode(returnStatement[\"argument\"])\n    : void 0;\n};\n\n/**\n * Gets parameter names and whether each parameter is a rest parameter.\n * @param functionNode Function node to inspect.\n * @returns Named parameter metadata when every parameter is supported.\n * @example\n * ```typescript\n * const parameters = getParameters(functionNode);\n * ```\n */\nconst getParameters = (\n  functionNode: Node,\n): DelegatedParameter[] | undefined => {\n  const parameters = asNodeArray(functionNode[\"params\"]);\n  if (parameters === void 0) {\n    return void 0;\n  }\n\n  const result: DelegatedParameter[] = [];\n  for (const parameter of parameters) {\n    const isRest = parameter.type === \"RestElement\";\n    const name = getIdentifierName(\n      isRest ? asNode(parameter[\"argument\"]) : parameter,\n    );\n    if (name === void 0) {\n      return void 0;\n    }\n\n    result.push({ isRest, name });\n  }\n\n  return result;\n};\n\n/**\n * Determines whether one call argument forwards its corresponding parameter.\n * @param argument Call argument to inspect.\n * @param parameter Corresponding function parameter.\n * @returns Whether the argument forwards the parameter without change.\n * @example\n * ```typescript\n * const forwards = forwardsParameter(argument, parameter);\n * ```\n */\nconst forwardsParameter = (\n  argument: Node,\n  parameter: DelegatedParameter,\n): boolean => {\n  if (parameter.isRest) {\n    return (\n      argument.type === \"SpreadElement\" &&\n      getIdentifierName(asNode(argument[\"argument\"])) === parameter.name\n    );\n  }\n\n  return getIdentifierName(argument) === parameter.name;\n};\n\n/**\n * Determines whether a node is a plain named reference.\n * @param node Candidate receiver node to inspect.\n * @returns Whether the node is a plain identifier reference.\n * @example\n * ```typescript\n * const isNamed = isNamedReceiver({ type: \"Identifier\" });\n * ```\n */\nconst isNamedReceiver = (node?: Node): boolean => node?.type === \"Identifier\";\n\n/**\n * Determines whether a function does nothing except directly call another function.\n * @param functionNode Function node to inspect.\n * @param functionName Declared wrapper function name.\n * @returns Whether the function is an exact synchronous delegation.\n * @example\n * ```typescript\n * const isDelegation = isUselessDelegation(functionNode, \"run\");\n * ```\n */\nconst isUselessDelegation = (\n  functionNode: Node,\n  functionName: string,\n): boolean => {\n  const call = getDelegatedCall(functionNode);\n  const parameters = getParameters(functionNode);\n  const arguments_ = asNodeArray(call?.[\"arguments\"]);\n  const callee = asNode(call?.[\"callee\"]);\n\n  if (\n    call?.type !== \"CallExpression\" ||\n    parameters === void 0 ||\n    arguments_ === void 0 ||\n    callee === void 0 ||\n    // A method call is only a replaceable delegation when its receiver is a\n    // plain named reference (e.g. `service.run`). Expression receivers such\n    // as type assertions, calls, or literals cannot be inlined at the call\n    // site, so the wrapper is not useless.\n    (callee.type === \"MemberExpression\" &&\n      !isNamedReceiver(asNode(callee[\"object\"]))) ||\n    getIdentifierName(callee) === functionName ||\n    arguments_.length !== parameters.length\n  ) {\n    return false;\n  }\n\n  return arguments_.every((argument, index) => {\n    const parameter = parameters[index];\n    return parameter !== void 0 && forwardsParameter(argument, parameter);\n  });\n};\n\n/**\n * Reports a function when it is a no-op delegation.\n * @param context Rule execution context.\n * @param functionNode Function node to inspect.\n * @param nameNode Declared wrapper name node.\n * @example\n * ```typescript\n * reportIfUselessDelegation(context, functionNode, nameNode);\n * ```\n */\nconst reportIfUselessDelegation = (\n  context: Rule.RuleContext,\n  functionNode: Node,\n  nameNode: Node | undefined,\n): void => {\n  const functionName = getIdentifierName(nameNode);\n  if (\n    functionName === void 0 ||\n    !isUselessDelegation(functionNode, functionName)\n  ) {\n    return;\n  }\n\n  context.report({\n    messageId: \"uselessDelegation\",\n    node: nameNode as unknown as Rule.Node,\n  });\n};\n\n/** ESLint rule implementation for functions that only forward their arguments. */\nconst noUselessDelegationRule: Rule.RuleModule = {\n  create: (context: Rule.RuleContext): Rule.RuleListener => ({\n    FunctionDeclaration: (node: Rule.Node): void => {\n      const functionNode = node as unknown as Node;\n      reportIfUselessDelegation(\n        context,\n        functionNode,\n        asNode(functionNode[\"id\"]),\n      );\n    },\n    VariableDeclarator: (node: Rule.Node): void => {\n      const declarator = node as unknown as Node;\n      const initializer = asNode(declarator[\"init\"]);\n      if (\n        initializer?.type !== \"ArrowFunctionExpression\" &&\n        initializer?.type !== \"FunctionExpression\"\n      ) {\n        return;\n      }\n\n      reportIfUselessDelegation(context, initializer, asNode(declarator[\"id\"]));\n    },\n  }),\n  meta: {\n    docs: {\n      description:\n        \"Disallow named functions that only delegate directly to another call.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-useless-delegation.md\",\n    },\n    messages: {\n      uselessDelegation:\n        \"This function only delegates to another call; remove the wrapper or call the target directly.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { noUselessDelegationRule };\n"]}

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

@@ -0,0 +1,15 @@
+import type { Rule } from "eslint";
+import type { NamedInlineTypeMatch } from "./types.js";
+/**
+ * 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);
+ * ```
+ */
+declare function createAggregateFix(context: Rule.RuleContext, matches: readonly NamedInlineTypeMatch[]): ((fixer: Rule.RuleFixer) => Rule.Fix[]) | undefined;
+export { createAggregateFix };
+//# sourceMappingURL=autofix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"autofix.d.ts","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/autofix.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAEV,oBAAoB,EAGrB,MAAM,SAAS,CAAC;AAkDjB;;;;;;;;;GASG;AACH,iBAAS,kBAAkB,CACzB,OAAO,EAAE,IAAI,CAAC,WAAW,EACzB,OAAO,EAAE,SAAS,oBAAoB,EAAE,GACvC,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,SAAS,CA6BrD;AAiLD,OAAO,EAAE,kBAAkB,EAAE,CAAC"}