@codeperfect/eslint-plugin 1.0.0

package/dist/codeperfect-plugin.js

@@ -0,0 +1,29 @@
+import { assertActualExpectedNamesRule, barrelFilesExportsOnlyRule, consistentBarrelFilesRule, enforceAaaPhasePurityRule, enforceAaaStructureRule, noInterfaceMemberDocumentationRule, noMultipleDeclaratorsRule, noReexportsOutsideBarrelsRule, preferInterfaceTypesRule, preferViMockedImportRule, requireAaaSectionsRule, requireActResultCaptureRule, requireExampleLanguageRule, requireTestCompanionRule, singleActStatementRule, singleLineJsdocRule, } from "./rules";
+/** Rule registry exposed by the package plugin. */
+const codeperfectRules = {
+    "assert-actual-expected-names": assertActualExpectedNamesRule,
+    "barrel-files-exports-only": barrelFilesExportsOnlyRule,
+    "consistent-barrel-files": consistentBarrelFilesRule,
+    "enforce-aaa-phase-purity": enforceAaaPhasePurityRule,
+    "enforce-aaa-structure": enforceAaaStructureRule,
+    "no-interface-member-docs": noInterfaceMemberDocumentationRule,
+    "no-multiple-declarators": noMultipleDeclaratorsRule,
+    "no-reexports-outside-barrels": noReexportsOutsideBarrelsRule,
+    "prefer-interface-types": preferInterfaceTypesRule,
+    "prefer-vi-mocked-import": preferViMockedImportRule,
+    "require-aaa-sections": requireAaaSectionsRule,
+    "require-act-result-capture": requireActResultCaptureRule,
+    "require-example-language": requireExampleLanguageRule,
+    "require-test-companion": requireTestCompanionRule,
+    "single-act-statement": singleActStatementRule,
+    "single-line-jsdoc": singleLineJsdocRule,
+};
+/** ESLint plugin object exported by the package. */
+const codeperfectPlugin = {
+    meta: {
+        name: "@codeperfect/eslint-plugin",
+    },
+    rules: codeperfectRules,
+};
+export { codeperfectPlugin, codeperfectRules };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/core/index.d.ts

@@ -0,0 +1,3 @@
+export { noMultipleDeclaratorsRule } from "./no-multiple-declarators";
+export { preferInterfaceTypesRule } from "./prefer-interface-types";
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC"}

package/dist/core/index.js

@@ -0,0 +1,3 @@
+export { noMultipleDeclaratorsRule } from "./no-multiple-declarators";
+export { preferInterfaceTypesRule } from "./prefer-interface-types";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUN0RSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IG5vTXVsdGlwbGVEZWNsYXJhdG9yc1J1bGUgfSBmcm9tIFwiLi9uby1tdWx0aXBsZS1kZWNsYXJhdG9yc1wiO1xuZXhwb3J0IHsgcHJlZmVySW50ZXJmYWNlVHlwZXNSdWxlIH0gZnJvbSBcIi4vcHJlZmVyLWludGVyZmFjZS10eXBlc1wiO1xuIl19

package/dist/core/no-multiple-declarators/index.d.ts

@@ -0,0 +1,2 @@
+export { noMultipleDeclaratorsRule } from "./rule";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/no-multiple-declarators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/core/no-multiple-declarators/index.js

@@ -0,0 +1,2 @@
+export { noMultipleDeclaratorsRule } from "./rule";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29yZS9uby1tdWx0aXBsZS1kZWNsYXJhdG9ycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBub011bHRpcGxlRGVjbGFyYXRvcnNSdWxlIH0gZnJvbSBcIi4vcnVsZVwiO1xuIl19

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

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+declare const noMultipleDeclaratorsRule: Rule.RuleModule;
+export { noMultipleDeclaratorsRule };
+//# sourceMappingURL=rule.d.ts.map

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

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

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

@@ -0,0 +1,100 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+const commentPattern = /\/\/|\/\*/u;
+const loopParentTypes = new Set(["ForInStatement", "ForOfStatement"]);
+const getSourceCode = (context) => context.sourceCode;
+const getSourceText = (sourceCode) => typeof sourceCode.text === "string" ? sourceCode.text : sourceCode.getText();
+const hasRange = (node) => Array.isArray(node?.range) && node.range.length === 2;
+const hasFixData = (node) => Array.isArray(node.range) &&
+    node.range.length === 2 &&
+    typeof node.kind === "string";
+const isLoopInitializer = (node) => {
+    const { parent } = node;
+    if (parent?.type === "ForStatement") {
+        return parent.init === node;
+    }
+    if (parent !== void 0 && loopParentTypes.has(parent.type)) {
+        return parent.left === node;
+    }
+    return false;
+};
+const isWrappedExport = (node) => node.parent?.type === "ExportDefaultDeclaration" ||
+    node.parent?.type === "ExportNamedDeclaration";
+const getLineIndent = (sourceText, start) => {
+    const lineStart = sourceText.lastIndexOf("\n", start - 1) + 1;
+    const linePrefix = sourceText.slice(lineStart, start);
+    return linePrefix.replace(/[^\t ].*$/u, "");
+};
+const hasSeparatorComment = (declarations, sourceText) => {
+    for (const [index, declaration] of declarations.entries()) {
+        const nextDeclaration = declarations[index + 1];
+        if (nextDeclaration === void 0) {
+            break;
+        }
+        if (!hasRange(declaration) || !hasRange(nextDeclaration)) {
+            return true;
+        }
+        const separatorText = sourceText.slice(declaration.range[1], nextDeclaration.range[0]);
+        if (commentPattern.test(separatorText)) {
+            return true;
+        }
+    }
+    return false;
+};
+const canFix = (node, declarations, sourceText) => {
+    if (!hasFixData(node)) {
+        return false;
+    }
+    if (isLoopInitializer(node) || isWrappedExport(node)) {
+        return false;
+    }
+    return !hasSeparatorComment(declarations, sourceText);
+};
+const buildReplacement = (node, declarations, sourceCode) => {
+    const sourceText = getSourceText(sourceCode);
+    const indent = getLineIndent(sourceText, node.range[0]);
+    return declarations
+        .map((declaration) => `${node.kind} ${sourceCode.getText(declaration)};`)
+        .join(`\n${indent}`);
+};
+const reportVariableDeclaration = (context, node) => {
+    const declarations = node.declarations ?? [];
+    if (declarations.length <= 1) {
+        return;
+    }
+    const sourceCode = getSourceCode(context);
+    const sourceText = getSourceText(sourceCode);
+    const fixable = canFix(node, declarations, sourceText);
+    if (fixable) {
+        const fixedNode = node;
+        context.report({
+            fix: (fixer) => fixer.replaceTextRange(fixedNode.range, buildReplacement(fixedNode, declarations, sourceCode)),
+            messageId: "singleDeclarator",
+            node: node,
+        });
+        return;
+    }
+    context.report({
+        messageId: "singleDeclarator",
+        node: node,
+    });
+};
+const noMultipleDeclaratorsRule = {
+    create(context) {
+        return {
+            VariableDeclaration: (node) => {
+                reportVariableDeclaration(context, node);
+            },
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("no-multiple-declarators", "Require variable declarations to contain exactly one declarator per statement."),
+        fixable: "code",
+        messages: {
+            singleDeclarator: "Declare exactly one variable per declaration statement.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { noMultipleDeclaratorsRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/core/no-multiple-declarators/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { createRuleDocumentation } from \"../../custom-rule-documentation\";\n\ntype Range = [number, number];\n\ninterface BaseNode {\n  parent?: BaseNode;\n  range?: Range;\n  type: string;\n}\n\ninterface ForInOrOfStatementNode extends BaseNode {\n  left?: BaseNode;\n}\n\ninterface ForStatementNode extends BaseNode {\n  init?: BaseNode | null;\n}\n\ninterface SourceCodeAccess {\n  getText: (node?: BaseNode) => string;\n  text?: string;\n}\n\ninterface VariableDeclarationNode extends BaseNode {\n  declarations?: VariableDeclaratorNode[];\n  kind?: string;\n}\n\ninterface VariableDeclaratorNode extends BaseNode {}\n\nconst commentPattern = /\\/\\/|\\/\\*/u;\nconst loopParentTypes = new Set([\"ForInStatement\", \"ForOfStatement\"]);\n\nconst getSourceCode = (context: Rule.RuleContext): SourceCodeAccess =>\n  context.sourceCode as unknown as SourceCodeAccess;\n\nconst getSourceText = (sourceCode: SourceCodeAccess): string =>\n  typeof sourceCode.text === \"string\" ? sourceCode.text : sourceCode.getText();\n\nconst hasRange = (\n  node: BaseNode | undefined,\n): node is BaseNode & { range: Range } =>\n  Array.isArray(node?.range) && node.range.length === 2;\n\nconst hasFixData = (\n  node: VariableDeclarationNode,\n): node is VariableDeclarationNode & { kind: string; range: Range } =>\n  Array.isArray(node.range) &&\n  node.range.length === 2 &&\n  typeof node.kind === \"string\";\n\nconst isLoopInitializer = (node: VariableDeclarationNode): boolean => {\n  const { parent } = node;\n\n  if (parent?.type === \"ForStatement\") {\n    return (parent as ForStatementNode).init === node;\n  }\n\n  if (parent !== void 0 && loopParentTypes.has(parent.type)) {\n    return (parent as ForInOrOfStatementNode).left === node;\n  }\n\n  return false;\n};\n\nconst isWrappedExport = (node: VariableDeclarationNode): boolean =>\n  node.parent?.type === \"ExportDefaultDeclaration\" ||\n  node.parent?.type === \"ExportNamedDeclaration\";\n\nconst getLineIndent = (sourceText: string, start: number): string => {\n  const lineStart = sourceText.lastIndexOf(\"\\n\", start - 1) + 1;\n  const linePrefix = sourceText.slice(lineStart, start);\n\n  return linePrefix.replace(/[^\\t ].*$/u, \"\");\n};\n\nconst hasSeparatorComment = (\n  declarations: readonly VariableDeclaratorNode[],\n  sourceText: string,\n): boolean => {\n  for (const [index, declaration] of declarations.entries()) {\n    const nextDeclaration = declarations[index + 1];\n\n    if (nextDeclaration === void 0) {\n      break;\n    }\n\n    if (!hasRange(declaration) || !hasRange(nextDeclaration)) {\n      return true;\n    }\n\n    const separatorText = sourceText.slice(\n      declaration.range[1],\n      nextDeclaration.range[0],\n    );\n\n    if (commentPattern.test(separatorText)) {\n      return true;\n    }\n  }\n\n  return false;\n};\n\nconst canFix = (\n  node: VariableDeclarationNode,\n  declarations: readonly VariableDeclaratorNode[],\n  sourceText: string,\n): boolean => {\n  if (!hasFixData(node)) {\n    return false;\n  }\n\n  if (isLoopInitializer(node) || isWrappedExport(node)) {\n    return false;\n  }\n\n  return !hasSeparatorComment(declarations, sourceText);\n};\n\nconst buildReplacement = (\n  node: VariableDeclarationNode & { kind: string; range: Range },\n  declarations: readonly (VariableDeclaratorNode & { range: Range })[],\n  sourceCode: SourceCodeAccess,\n): string => {\n  const sourceText = getSourceText(sourceCode);\n  const indent = getLineIndent(sourceText, node.range[0]);\n\n  return declarations\n    .map((declaration) => `${node.kind} ${sourceCode.getText(declaration)};`)\n    .join(`\\n${indent}`);\n};\n\nconst reportVariableDeclaration = (\n  context: Rule.RuleContext,\n  node: VariableDeclarationNode,\n): void => {\n  const declarations = node.declarations ?? [];\n\n  if (declarations.length <= 1) {\n    return;\n  }\n\n  const sourceCode = getSourceCode(context);\n  const sourceText = getSourceText(sourceCode);\n  const fixable = canFix(node, declarations, sourceText);\n\n  if (fixable) {\n    const fixedNode = node as VariableDeclarationNode & {\n      kind: string;\n      range: Range;\n    };\n\n    context.report({\n      fix: (fixer: Rule.RuleFixer): Rule.Fix =>\n        fixer.replaceTextRange(\n          fixedNode.range,\n          buildReplacement(\n            fixedNode,\n            declarations as (VariableDeclaratorNode & { range: Range })[],\n            sourceCode,\n          ),\n        ),\n      messageId: \"singleDeclarator\",\n      node: node as unknown as Rule.Node,\n    });\n\n    return;\n  }\n\n  context.report({\n    messageId: \"singleDeclarator\",\n    node: node as unknown as Rule.Node,\n  });\n};\n\nconst noMultipleDeclaratorsRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    return {\n      VariableDeclaration: (node: Rule.Node): void => {\n        reportVariableDeclaration(context, node as VariableDeclarationNode);\n      },\n    };\n  },\n  meta: {\n    docs: createRuleDocumentation(\n      \"no-multiple-declarators\",\n      \"Require variable declarations to contain exactly one declarator per statement.\",\n    ),\n    fixable: \"code\",\n    messages: {\n      singleDeclarator:\n        \"Declare exactly one variable per declaration statement.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { noMultipleDeclaratorsRule };\n"]}

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

@@ -0,0 +1,2 @@
+export { preferInterfaceTypesRule } from "./rule";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/prefer-interface-types/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC"}

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

@@ -0,0 +1,2 @@
+export { preferInterfaceTypesRule } from "./rule";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29yZS9wcmVmZXItaW50ZXJmYWNlLXR5cGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IHByZWZlckludGVyZmFjZVR5cGVzUnVsZSB9IGZyb20gXCIuL3J1bGVcIjtcbiJdfQ==

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

@@ -0,0 +1,5 @@
+import type { Rule } from "eslint";
+/** ESLint rule requiring named interface/type aliases for object types. */
+declare const preferInterfaceTypesRule: Rule.RuleModule;
+export { preferInterfaceTypesRule };
+//# sourceMappingURL=rule.d.ts.map

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

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

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

@@ -0,0 +1,145 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+/**
+ * Gets a nested type annotation from parameter wrappers.
+ * @param node Parameter wrapper node.
+ * @returns The nested type annotation when present.
+ * @example
+ * ```typescript
+ * const annotation = getNestedTypeAnnotation({ argument: node });
+ * ```
+ */
+const getNestedTypeAnnotation = (node) => {
+    if (node.argument !== void 0) {
+        return getTypeAnnotationNode(node.argument);
+    }
+    if (node.parameter !== void 0) {
+        return getTypeAnnotationNode(node.parameter);
+    }
+    return void 0;
+};
+/**
+ * Extracts the type annotation from a node.
+ * @param node Node that may contain a type annotation.
+ * @returns The type annotation when present.
+ * @example
+ * ```typescript
+ * const annotation = getTypeAnnotationNode(node);
+ * ```
+ */
+const getTypeAnnotationNode = (node) => {
+    if (node === null || typeof node !== "object") {
+        return void 0;
+    }
+    const directTypeAnnotation = node.typeAnnotation
+        ?.typeAnnotation;
+    if (directTypeAnnotation !== void 0) {
+        return directTypeAnnotation;
+    }
+    return getNestedTypeAnnotation(node);
+};
+/**
+ * Gets the return type annotation for a function-like node.
+ * @param node Node that may contain a return type.
+ * @returns The return type annotation when present.
+ * @example
+ * ```typescript
+ * const annotation = getReturnTypeAnnotation(node);
+ * ```
+ */
+const getReturnTypeAnnotation = (node) => {
+    if (node === null || typeof node !== "object") {
+        return void 0;
+    }
+    const typedNode = node;
+    return typedNode.returnType?.typeAnnotation;
+};
+/**
+ * Gets getParameters.
+ * @param node Input node value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getParameters();
+ * ```
+ */
+const getParameters = (node) => {
+    if (node === null || typeof node !== "object") {
+        return [];
+    }
+    const typedNode = node;
+    return Array.isArray(typedNode.params) ? typedNode.params : [];
+};
+/**
+ * Checks whether the node represents a type literal.
+ * @param node Type annotation node to check.
+ * @returns True when the node is a type literal.
+ * @example
+ * ```typescript
+ * const isLiteral = isTypeLiteral(annotation);
+ * ```
+ */
+const isTypeLiteral = (node) => node?.type === "TSTypeLiteral";
+/**
+ * Reports an inline object type annotation.
+ * @param context Rule execution context.
+ * @param typeAnnotation Type annotation node to report.
+ * @example
+ * ```typescript
+ * reportTypeLiteral(context, typeAnnotation);
+ * ```
+ */
+const reportTypeLiteral = (context, typeAnnotation) => {
+    context.report({
+        messageId: "preferNamedObject",
+        node: typeAnnotation,
+    });
+};
+/**
+ * Checks function-like nodes for inline object types.
+ * @param context Rule execution context.
+ * @param node Function-like node to check.
+ * @example
+ * ```typescript
+ * checkFunctionLike(context, node);
+ * ```
+ */
+const checkFunctionLike = (context, node) => {
+    for (const parameter of getParameters(node)) {
+        const typeAnnotation = getTypeAnnotationNode(parameter);
+        if (isTypeLiteral(typeAnnotation)) {
+            reportTypeLiteral(context, typeAnnotation);
+        }
+    }
+    const returnTypeAnnotation = getReturnTypeAnnotation(node);
+    if (isTypeLiteral(returnTypeAnnotation)) {
+        reportTypeLiteral(context, returnTypeAnnotation);
+    }
+};
+/** ESLint rule requiring named interface/type aliases for object types. */
+const preferInterfaceTypesRule = {
+    create(context) {
+        const listener = (node) => {
+            checkFunctionLike(context, node);
+        };
+        return {
+            ArrowFunctionExpression: listener,
+            FunctionDeclaration: listener,
+            FunctionExpression: listener,
+            TSCallSignatureDeclaration: listener,
+            TSConstructSignatureDeclaration: listener,
+            TSDeclareFunction: listener,
+            TSFunctionType: listener,
+            TSMethodSignature: listener,
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("prefer-interface-types", "Require named interfaces or type aliases for object types in parameters and return types."),
+        messages: {
+            preferNamedObject: "Use a named interface or type alias instead of an inline object type.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { preferInterfaceTypesRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/core/prefer-interface-types/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { createRuleDocumentation } from \"../../custom-rule-documentation\";\n/** Type definition for rule data. */\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 rule data. */\ninterface ParameterContainer {\n  /** Argument helper value. */\n  argument?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n}\n\n/** Type definition for rule data. */\ninterface TypeAnnotationContainer {\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for rule data. */\ninterface TypeAnnotationNode {\n  /** Type field value. */\n  type: string;\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.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 as ParameterContainer);\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 * Checks whether the node represents a type literal.\n * @param node Type annotation node to check.\n * @returns True when the node is a type literal.\n * @example\n * ```typescript\n * const isLiteral = isTypeLiteral(annotation);\n * ```\n */\nconst isTypeLiteral = (\n  node: TypeAnnotationNode | undefined,\n): node is TypeAnnotationNode => node?.type === \"TSTypeLiteral\";\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 typeAnnotation = getTypeAnnotationNode(parameter);\n\n    if (isTypeLiteral(typeAnnotation)) {\n      reportTypeLiteral(context, typeAnnotation);\n    }\n  }\n\n  const returnTypeAnnotation = getReturnTypeAnnotation(node);\n\n  if (isTypeLiteral(returnTypeAnnotation)) {\n    reportTypeLiteral(context, returnTypeAnnotation);\n  }\n};\n\n/** ESLint rule requiring named interface/type aliases for object types. */\nconst preferInterfaceTypesRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    const listener = (node: Rule.Node): void => {\n      checkFunctionLike(context, node);\n    };\n\n    return {\n      ArrowFunctionExpression: listener,\n      FunctionDeclaration: listener,\n      FunctionExpression: listener,\n      TSCallSignatureDeclaration: listener,\n      TSConstructSignatureDeclaration: listener,\n      TSDeclareFunction: listener,\n      TSFunctionType: listener,\n      TSMethodSignature: listener,\n    };\n  },\n  meta: {\n    docs: createRuleDocumentation(\n      \"prefer-interface-types\",\n      \"Require named interfaces or type aliases for object types in parameters and return types.\",\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"]}

package/dist/core/prefer-interface-types/test-helpers.d.ts

@@ -0,0 +1,110 @@
+import type { Rule } from "eslint";
+/** Type definition for rule data. */
+interface MockNode {
+    /** Index signature value map. */
+    [key: string]: unknown;
+    /** Type field value. */
+    type: string;
+}
+/** Type definition for rule data. */
+interface ReportEntry {
+    /** MessageId helper value. */
+    messageId: string | undefined;
+    /** NodeType field value. */
+    nodeType: string | undefined;
+}
+/** Type definition for rule data. */
+interface RuleContextState {
+    /** Context field value. */
+    context: Rule.RuleContext;
+    /** Reports field value. */
+    reports: ReportEntry[];
+}
+/** Type definition for rule data. */
+interface TypeAnnotationWrapper {
+    /** TypeAnnotation field value. */
+    typeAnnotation: {
+        /** Type field value. */
+        type: string;
+    };
+}
+/**
+ * Creates createContext.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createContext();
+ * ```
+ */
+declare const createContext: () => RuleContextState;
+/**
+ * Creates createTypeAnnotation.
+ * @param type Input type value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createTypeAnnotation();
+ * ```
+ */
+declare const createTypeAnnotation: (type: string) => TypeAnnotationWrapper;
+/**
+ * Creates createParameter.
+ * @param type Input type value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createParameter();
+ * ```
+ */
+declare const createParameter: (type: string) => MockNode;
+/**
+ * Creates createBareParameter.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createBareParameter();
+ * ```
+ */
+declare const createBareParameter: () => MockNode;
+/**
+ * Creates createParameterProperty.
+ * @param type Input type value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createParameterProperty();
+ * ```
+ */
+declare const createParameterProperty: (type: string) => MockNode;
+/**
+ * Creates createRestParameter.
+ * @param type Input type value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createRestParameter();
+ * ```
+ */
+declare const createRestParameter: (type: string) => MockNode;
+/**
+ * Creates createFunctionNode.
+ * @param overrides Input overrides value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createFunctionNode();
+ * ```
+ */
+declare const createFunctionNode: (overrides: Partial<MockNode>) => MockNode;
+/**
+ * Runs the listener for the supplied node.
+ * @param context Rule execution context.
+ * @param node Node to run through the listener.
+ * @example
+ * ```typescript
+ * runListener(context, node);
+ * ```
+ */
+declare const runListener: (context: Rule.RuleContext, node?: MockNode) => void;
+export { createBareParameter, createContext, createFunctionNode, createParameter, createParameterProperty, createRestParameter, createTypeAnnotation, runListener, };
+//# sourceMappingURL=test-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../../src/core/prefer-interface-types/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAInC,qCAAqC;AACrC,UAAU,QAAQ;IAChB,iCAAiC;IACjC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IAEvB,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AAWD,qCAAqC;AACrC,UAAU,WAAW;IACnB,8BAA8B;IAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAE9B,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAED,qCAAqC;AACrC,UAAU,gBAAgB;IACxB,2BAA2B;IAC3B,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC;IAE1B,2BAA2B;IAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB;AAED,qCAAqC;AACrC,UAAU,qBAAqB;IAC7B,kCAAkC;IAClC,cAAc,EAAE;QACd,wBAAwB;QACxB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAED;;;;;;;GAOG;AACH,QAAA,MAAM,aAAa,QAAO,gBAczB,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,qBAE3C,CAAC;AAEH;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,QAKxB,CAAC;AAEjB;;;;;;;GAOG;AACH,QAAA,MAAM,mBAAmB,QAAO,QAIhB,CAAC;AAEjB;;;;;;;;GAQG;AACH,QAAA,MAAM,uBAAuB,GAAI,MAAM,MAAM,KAAG,QAIhC,CAAC;AAEjB;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GAAI,MAAM,MAAM,KAAG,QAI5B,CAAC;AAEjB;;;;;;;;GAQG;AACH,QAAA,MAAM,kBAAkB,GAAI,WAAW,OAAO,CAAC,QAAQ,CAAC,KAAG,QAK3C,CAAC;AAEjB;;;;;;;;GAQG;AACH,QAAA,MAAM,WAAW,GAAI,SAAS,IAAI,CAAC,WAAW,EAAE,OAAO,QAAQ,KAAG,IAOjE,CAAC;AAEF,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,uBAAuB,EACvB,mBAAmB,EACnB,oBAAoB,EACpB,WAAW,GACZ,CAAC"}

package/dist/core/prefer-interface-types/test-helpers.js

@@ -0,0 +1,116 @@
+import { preferInterfaceTypesRule } from "./rule";
+/**
+ * Creates createContext.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createContext();
+ * ```
+ */
+const createContext = () => {
+    const reports = [];
+    const context = {
+        id: "prefer-interface-types",
+        options: [],
+        report: (descriptor) => {
+            const { messageId, node } = descriptor;
+            const reportEntry = { messageId, nodeType: node?.type };
+            reports.push(reportEntry);
+        },
+    };
+    return { context, reports };
+};
+/**
+ * Creates createTypeAnnotation.
+ * @param type Input type value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createTypeAnnotation();
+ * ```
+ */
+const createTypeAnnotation = (type) => ({
+    typeAnnotation: { type },
+});
+/**
+ * Creates createParameter.
+ * @param type Input type value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createParameter();
+ * ```
+ */
+const createParameter = (type) => ({
+    name: "value",
+    type: "Identifier",
+    typeAnnotation: createTypeAnnotation(type),
+});
+/**
+ * Creates createBareParameter.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createBareParameter();
+ * ```
+ */
+const createBareParameter = () => ({
+    name: "value",
+    type: "Identifier",
+});
+/**
+ * Creates createParameterProperty.
+ * @param type Input type value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createParameterProperty();
+ * ```
+ */
+const createParameterProperty = (type) => ({
+    parameter: createParameter(type),
+    type: "TSParameterProperty",
+});
+/**
+ * Creates createRestParameter.
+ * @param type Input type value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createRestParameter();
+ * ```
+ */
+const createRestParameter = (type) => ({
+    argument: createParameter(type),
+    type: "RestElement",
+});
+/**
+ * Creates createFunctionNode.
+ * @param overrides Input overrides value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createFunctionNode();
+ * ```
+ */
+const createFunctionNode = (overrides) => ({
+    params: [],
+    type: "FunctionDeclaration",
+    ...overrides,
+});
+/**
+ * Runs the listener for the supplied node.
+ * @param context Rule execution context.
+ * @param node Node to run through the listener.
+ * @example
+ * ```typescript
+ * runListener(context, node);
+ * ```
+ */
+const runListener = (context, node) => {
+    const listeners = preferInterfaceTypesRule.create(context);
+    const listener = listeners.FunctionDeclaration;
+    listener?.(node);
+};
+export { createBareParameter, createContext, createFunctionNode, createParameter, createParameterProperty, createRestParameter, createTypeAnnotation, runListener, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-helpers.js","sourceRoot":"","sources":["../../../src/core/prefer-interface-types/test-helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAE,MAAM,QAAQ,CAAC;AA+ClD;;;;;;;GAOG;AACH,MAAM,aAAa,GAAG,GAAqB,EAAE;IAC3C,MAAM,OAAO,GAAkB,EAAE,CAAC;IAClC,MAAM,OAAO,GAAqB;QAChC,EAAE,EAAE,wBAAwB;QAC5B,OAAO,EAAE,EAAE;QACX,MAAM,EAAE,CAAC,UAAiC,EAAQ,EAAE;YAClD,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,UAAqC,CAAC;YAClE,MAAM,WAAW,GAAgB,EAAE,SAAS,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;YAErE,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC;KAC6B,CAAC;IAEjC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AAC9B,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,oBAAoB,GAAG,CAAC,IAAY,EAAyB,EAAE,CAAC,CAAC;IACrE,cAAc,EAAE,EAAE,IAAI,EAAE;CACzB,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,eAAe,GAAG,CAAC,IAAY,EAAY,EAAE,CACjD,CAAC;IACC,IAAI,EAAE,OAAO;IACb,IAAI,EAAE,YAAY;IAClB,cAAc,EAAE,oBAAoB,CAAC,IAAI,CAAC;CAC3C,CAAa,CAAC;AAEjB;;;;;;;GAOG;AACH,MAAM,mBAAmB,GAAG,GAAa,EAAE,CACzC,CAAC;IACC,IAAI,EAAE,OAAO;IACb,IAAI,EAAE,YAAY;CACnB,CAAa,CAAC;AAEjB;;;;;;;;GAQG;AACH,MAAM,uBAAuB,GAAG,CAAC,IAAY,EAAY,EAAE,CACzD,CAAC;IACC,SAAS,EAAE,eAAe,CAAC,IAAI,CAAC;IAChC,IAAI,EAAE,qBAAqB;CAC5B,CAAa,CAAC;AAEjB;;;;;;;;GAQG;AACH,MAAM,mBAAmB,GAAG,CAAC,IAAY,EAAY,EAAE,CACrD,CAAC;IACC,QAAQ,EAAE,eAAe,CAAC,IAAI,CAAC;IAC/B,IAAI,EAAE,aAAa;CACpB,CAAa,CAAC;AAEjB;;;;;;;;GAQG;AACH,MAAM,kBAAkB,GAAG,CAAC,SAA4B,EAAY,EAAE,CACpE,CAAC;IACC,MAAM,EAAE,EAAE;IACV,IAAI,EAAE,qBAAqB;IAC3B,GAAG,SAAS;CACb,CAAa,CAAC;AAEjB;;;;;;;;GAQG;AACH,MAAM,WAAW,GAAG,CAAC,OAAyB,EAAE,IAAe,EAAQ,EAAE;IACvE,MAAM,SAAS,GAAG,wBAAwB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC3D,MAAM,QAAQ,GAAG,SAAS,CAAC,mBAEd,CAAC;IAEd,QAAQ,EAAE,CAAC,IAA4B,CAAC,CAAC;AAC3C,CAAC,CAAC;AAEF,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,uBAAuB,EACvB,mBAAmB,EACnB,oBAAoB,EACpB,WAAW,GACZ,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { preferInterfaceTypesRule } from \"./rule\";\n\n/** Type definition for rule data. */\ninterface MockNode {\n  /** Index signature value map. */\n  [key: string]: unknown;\n\n  /** Type field value. */\n  type: string;\n}\n\n/** Type definition for rule data. */\ninterface ReportDescriptorDetails {\n  /** MessageId field value. */\n  messageId?: string;\n\n  /** Node field value. */\n  node?: Rule.Node;\n}\n\n/** Type definition for rule data. */\ninterface ReportEntry {\n  /** MessageId helper value. */\n  messageId: string | undefined;\n\n  /** NodeType field value. */\n  nodeType: string | undefined;\n}\n\n/** Type definition for rule data. */\ninterface RuleContextState {\n  /** Context field value. */\n  context: Rule.RuleContext;\n\n  /** Reports field value. */\n  reports: ReportEntry[];\n}\n\n/** Type definition for rule data. */\ninterface TypeAnnotationWrapper {\n  /** TypeAnnotation field value. */\n  typeAnnotation: {\n    /** Type field value. */\n    type: string;\n  };\n}\n\n/**\n * Creates createContext.\n * @returns Return value output.\n * @example\n * ```typescript\n * createContext();\n * ```\n */\nconst createContext = (): RuleContextState => {\n  const reports: ReportEntry[] = [];\n  const context: Rule.RuleContext = {\n    id: \"prefer-interface-types\",\n    options: [],\n    report: (descriptor: Rule.ReportDescriptor): void => {\n      const { messageId, node } = descriptor as ReportDescriptorDetails;\n      const reportEntry: ReportEntry = { messageId, nodeType: node?.type };\n\n      reports.push(reportEntry);\n    },\n  } as unknown as Rule.RuleContext;\n\n  return { context, reports };\n};\n\n/**\n * Creates createTypeAnnotation.\n * @param type Input type value.\n * @returns Return value output.\n * @example\n * ```typescript\n * createTypeAnnotation();\n * ```\n */\nconst createTypeAnnotation = (type: string): TypeAnnotationWrapper => ({\n  typeAnnotation: { type },\n});\n\n/**\n * Creates createParameter.\n * @param type Input type value.\n * @returns Return value output.\n * @example\n * ```typescript\n * createParameter();\n * ```\n */\nconst createParameter = (type: string): MockNode =>\n  ({\n    name: \"value\",\n    type: \"Identifier\",\n    typeAnnotation: createTypeAnnotation(type),\n  }) as MockNode;\n\n/**\n * Creates createBareParameter.\n * @returns Return value output.\n * @example\n * ```typescript\n * createBareParameter();\n * ```\n */\nconst createBareParameter = (): MockNode =>\n  ({\n    name: \"value\",\n    type: \"Identifier\",\n  }) as MockNode;\n\n/**\n * Creates createParameterProperty.\n * @param type Input type value.\n * @returns Return value output.\n * @example\n * ```typescript\n * createParameterProperty();\n * ```\n */\nconst createParameterProperty = (type: string): MockNode =>\n  ({\n    parameter: createParameter(type),\n    type: \"TSParameterProperty\",\n  }) as MockNode;\n\n/**\n * Creates createRestParameter.\n * @param type Input type value.\n * @returns Return value output.\n * @example\n * ```typescript\n * createRestParameter();\n * ```\n */\nconst createRestParameter = (type: string): MockNode =>\n  ({\n    argument: createParameter(type),\n    type: \"RestElement\",\n  }) as MockNode;\n\n/**\n * Creates createFunctionNode.\n * @param overrides Input overrides value.\n * @returns Return value output.\n * @example\n * ```typescript\n * createFunctionNode();\n * ```\n */\nconst createFunctionNode = (overrides: Partial<MockNode>): MockNode =>\n  ({\n    params: [],\n    type: \"FunctionDeclaration\",\n    ...overrides,\n  }) as MockNode;\n\n/**\n * Runs the listener for the supplied node.\n * @param context Rule execution context.\n * @param node Node to run through the listener.\n * @example\n * ```typescript\n * runListener(context, node);\n * ```\n */\nconst runListener = (context: Rule.RuleContext, node?: MockNode): void => {\n  const listeners = preferInterfaceTypesRule.create(context);\n  const listener = listeners.FunctionDeclaration as\n    | ((node: Rule.Node) => void)\n    | undefined;\n\n  listener?.(node as unknown as Rule.Node);\n};\n\nexport {\n  createBareParameter,\n  createContext,\n  createFunctionNode,\n  createParameter,\n  createParameterProperty,\n  createRestParameter,\n  createTypeAnnotation,\n  runListener,\n};\n"]}