@codeperfect/eslint-plugin 2.4.0 → 2.6.0

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

@@ -0,0 +1,200 @@
+/**
+ * Resolves a node value when it is an ESTree node.
+ * @param value Candidate AST value.
+ * @returns The value as an ESTree node when it has a type discriminator.
+ * @example
+ * ```typescript
+ * const node = asNode({ type: "Identifier" });
+ * ```
+ */
+const asNode = (value) => typeof value === "object" && value !== null && "type" in value
+    ? value
+    : void 0;
+/**
+ * Resolves a node array while rejecting malformed AST data.
+ * @param value Candidate AST value.
+ * @returns AST nodes when every array item is a node.
+ * @example
+ * ```typescript
+ * const nodes = asNodeArray([{ type: "Identifier" }]);
+ * ```
+ */
+const asNodeArray = (value) => Array.isArray(value) && value.every((item) => asNode(item) !== void 0)
+    ? value
+    : void 0;
+/**
+ * Reads an identifier name from a node.
+ * @param node Candidate identifier node.
+ * @returns Identifier name when the node is an identifier.
+ * @example
+ * ```typescript
+ * const name = getIdentifierName({ name: "run", type: "Identifier" });
+ * ```
+ */
+const getIdentifierName = (node) => node?.type === "Identifier" && typeof node["name"] === "string"
+    ? node["name"]
+    : void 0;
+/**
+ * Gets the called expression from a function with one return statement.
+ * @param functionNode Function node to inspect.
+ * @returns The directly returned call expression when present.
+ * @example
+ * ```typescript
+ * const call = getDelegatedCall(functionNode);
+ * ```
+ */
+const getDelegatedCall = (functionNode) => {
+    if (functionNode.async === true || functionNode.generator === true) {
+        return void 0;
+    }
+    const body = asNode(functionNode["body"]);
+    if (body === void 0) {
+        return void 0;
+    }
+    if (body.type === "CallExpression") {
+        return body;
+    }
+    const statements = asNodeArray(body["body"]);
+    if (body.type !== "BlockStatement" || statements?.length !== 1) {
+        return void 0;
+    }
+    const returnStatement = statements[0];
+    return returnStatement?.type === "ReturnStatement"
+        ? asNode(returnStatement["argument"])
+        : void 0;
+};
+/**
+ * Gets parameter names and whether each parameter is a rest parameter.
+ * @param functionNode Function node to inspect.
+ * @returns Named parameter metadata when every parameter is supported.
+ * @example
+ * ```typescript
+ * const parameters = getParameters(functionNode);
+ * ```
+ */
+const getParameters = (functionNode) => {
+    const parameters = asNodeArray(functionNode["params"]);
+    if (parameters === void 0) {
+        return void 0;
+    }
+    const result = [];
+    for (const parameter of parameters) {
+        const isRest = parameter.type === "RestElement";
+        const name = getIdentifierName(isRest ? asNode(parameter["argument"]) : parameter);
+        if (name === void 0) {
+            return void 0;
+        }
+        result.push({ isRest, name });
+    }
+    return result;
+};
+/**
+ * Determines whether one call argument forwards its corresponding parameter.
+ * @param argument Call argument to inspect.
+ * @param parameter Corresponding function parameter.
+ * @returns Whether the argument forwards the parameter without change.
+ * @example
+ * ```typescript
+ * const forwards = forwardsParameter(argument, parameter);
+ * ```
+ */
+const forwardsParameter = (argument, parameter) => {
+    if (parameter.isRest) {
+        return (argument.type === "SpreadElement" &&
+            getIdentifierName(asNode(argument["argument"])) === parameter.name);
+    }
+    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.
+ * @example
+ * ```typescript
+ * const isLiteralCall = isLiteralMemberCall(callee);
+ * ```
+ */
+const isLiteralMemberCall = (callee) => callee.type === "MemberExpression" &&
+    asNode(callee["object"])?.type === "Literal";
+/**
+ * Determines whether a function does nothing except directly call another function.
+ * @param functionNode Function node to inspect.
+ * @param functionName Declared wrapper function name.
+ * @returns Whether the function is an exact synchronous delegation.
+ * @example
+ * ```typescript
+ * const isDelegation = isUselessDelegation(functionNode, "run");
+ * ```
+ */
+const isUselessDelegation = (functionNode, functionName) => {
+    const call = getDelegatedCall(functionNode);
+    const parameters = getParameters(functionNode);
+    const arguments_ = asNodeArray(call?.["arguments"]);
+    const callee = asNode(call?.["callee"]);
+    if (call?.type !== "CallExpression" ||
+        parameters === void 0 ||
+        arguments_ === void 0 ||
+        callee === void 0 ||
+        isLiteralMemberCall(callee) ||
+        getIdentifierName(callee) === functionName ||
+        arguments_.length !== parameters.length) {
+        return false;
+    }
+    return arguments_.every((argument, index) => {
+        const parameter = parameters[index];
+        return parameter !== void 0 && forwardsParameter(argument, parameter);
+    });
+};
+/**
+ * Reports a function when it is a no-op delegation.
+ * @param context Rule execution context.
+ * @param functionNode Function node to inspect.
+ * @param nameNode Declared wrapper name node.
+ * @example
+ * ```typescript
+ * reportIfUselessDelegation(context, functionNode, nameNode);
+ * ```
+ */
+const reportIfUselessDelegation = (context, functionNode, nameNode) => {
+    const functionName = getIdentifierName(nameNode);
+    if (functionName === void 0 ||
+        !isUselessDelegation(functionNode, functionName)) {
+        return;
+    }
+    context.report({
+        messageId: "uselessDelegation",
+        node: nameNode,
+    });
+};
+/** ESLint rule implementation for functions that only forward their arguments. */
+const noUselessDelegationRule = {
+    create: (context) => ({
+        FunctionDeclaration: (node) => {
+            const functionNode = node;
+            reportIfUselessDelegation(context, functionNode, asNode(functionNode["id"]));
+        },
+        VariableDeclarator: (node) => {
+            const declarator = node;
+            const initializer = asNode(declarator["init"]);
+            if (initializer?.type !== "ArrowFunctionExpression" &&
+                initializer?.type !== "FunctionExpression") {
+                return;
+            }
+            reportIfUselessDelegation(context, initializer, asNode(declarator["id"]));
+        },
+    }),
+    meta: {
+        docs: {
+            description: "Disallow named functions that only delegate directly to another call.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/no-useless-delegation.md",
+        },
+        messages: {
+            uselessDelegation: "This function only delegates to another call; remove the wrapper or call the target directly.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+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"]}

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

@@ -0,0 +1,57 @@
+/** Type definition for type annotation nodes inspected by this rule. */
+interface TypeAnnotationNode {
+    /** Type field value. */
+    type: string;
+    /** Nested annotation for parenthesized types. */
+    typeAnnotation?: unknown;
+    /** Nested member annotations for union/intersection types. */
+    types?: unknown[];
+}
+/** Type definition for variable declarator nodes with optional identifiers. */
+interface VariableDeclaratorNode {
+    /** Identifier or binding pattern for the variable declarator. */
+    id?: unknown;
+}
+/**
+ * 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);
+ * ```
+ */
+declare const getTypeAnnotationNode: (node: unknown) => TypeAnnotationNode | undefined;
+/**
+ * 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);
+ * ```
+ */
+declare const getReturnTypeAnnotation: (node: unknown) => TypeAnnotationNode | undefined;
+/**
+ * Gets getParameters.
+ * @param node Input node value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getParameters();
+ * ```
+ */
+declare const getParameters: (node: unknown) => unknown[];
+/**
+ * Finds an inline object type literal within a type annotation node.
+ * @param node Type annotation node to inspect.
+ * @returns The first inline object type literal when present.
+ * @example
+ * ```typescript
+ * const inlineObjectType = getInlineObjectTypeLiteral(annotation);
+ * ```
+ */
+declare const getInlineObjectTypeLiteral: (node: TypeAnnotationNode | undefined) => TypeAnnotationNode | undefined;
+export { getInlineObjectTypeLiteral, getParameters, getReturnTypeAnnotation, getTypeAnnotationNode, };
+export type { TypeAnnotationNode, VariableDeclaratorNode };
+//# sourceMappingURL=rule-utilities.d.ts.map

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

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

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

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

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

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

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

@@ -1,106 +1,4 @@
-/**
- * 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.left !== void 0) {
-        return getTypeAnnotationNode(node.left);
-    }
-    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 : [];
-};
-/**
- * Finds an inline object type literal within a type annotation node.
- * @param node Type annotation node to inspect.
- * @returns The first inline object type literal when present.
- * @example
- * ```typescript
- * const inlineObjectType = getInlineObjectTypeLiteral(annotation);
- * ```
- */
-const getInlineObjectTypeLiteral = (node) => {
-    if (node === void 0) {
-        return void 0;
-    }
-    if (node.type === "TSTypeLiteral") {
-        return node;
-    }
-    if (node.type === "TSParenthesizedType") {
-        return getInlineObjectTypeLiteral(node.typeAnnotation);
-    }
-    if (node.type === "TSUnionType" || node.type === "TSIntersectionType") {
-        const nestedTypes = Array.isArray(node.types) ? node.types : [];
-        for (const nestedType of nestedTypes) {
-            const nestedInlineObjectType = getInlineObjectTypeLiteral(nestedType);
-            if (nestedInlineObjectType !== void 0) {
-                return nestedInlineObjectType;
-            }
-        }
-    }
-    return void 0;
-};
+import { getInlineObjectTypeLiteral, getParameters, getReturnTypeAnnotation, getTypeAnnotationNode, } from "./rule-utilities.js";
 /**
  * Reports an inline object type annotation.
  * @param context Rule execution context.
@@ -213,4 +111,4 @@ const preferInterfaceTypesRule = {
     },
 };
 export { preferInterfaceTypesRule };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\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  /** Left-side helper value used by assignment patterns. */\n  left?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n}\n\n/** Type definition for 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  /** Nested annotation for parenthesized types. */\n  typeAnnotation?: unknown;\n\n  /** Nested member annotations for union/intersection types. */\n  types?: unknown[];\n}\n\n/** Type definition for variable declarator nodes with optional identifiers. */\ninterface VariableDeclaratorNode {\n  /** Identifier or binding pattern for the variable declarator. */\n  id?: unknown;\n}\n\n/**\n * Gets a nested type annotation from parameter wrappers.\n * @param node Parameter wrapper node.\n * @returns The nested type annotation when present.\n * @example\n * ```typescript\n * const annotation = getNestedTypeAnnotation({ argument: node });\n * ```\n */\nconst getNestedTypeAnnotation = (\n  node: ParameterContainer,\n): TypeAnnotationNode | undefined => {\n  if (node.argument !== void 0) {\n    return getTypeAnnotationNode(node.argument);\n  }\n\n  if (node.left !== void 0) {\n    return getTypeAnnotationNode(node.left);\n  }\n\n  if (node.parameter !== void 0) {\n    return getTypeAnnotationNode(node.parameter);\n  }\n\n  return void 0;\n};\n\n/**\n * Extracts the type annotation from a node.\n * @param node Node that may contain a type annotation.\n * @returns The type annotation when present.\n * @example\n * ```typescript\n * const annotation = getTypeAnnotationNode(node);\n * ```\n */\nconst getTypeAnnotationNode = (\n  node: unknown,\n): TypeAnnotationNode | undefined => {\n  if (node === null || typeof node !== \"object\") {\n    return void 0;\n  }\n\n  const directTypeAnnotation = (node as TypeAnnotationContainer).typeAnnotation\n    ?.typeAnnotation;\n\n  if (directTypeAnnotation !== void 0) {\n    return directTypeAnnotation;\n  }\n\n  return getNestedTypeAnnotation(node);\n};\n\n/**\n * Gets the return type annotation for a function-like node.\n * @param node Node that may contain a return type.\n * @returns The return type annotation when present.\n * @example\n * ```typescript\n * const annotation = getReturnTypeAnnotation(node);\n * ```\n */\nconst getReturnTypeAnnotation = (\n  node: unknown,\n): TypeAnnotationNode | undefined => {\n  if (node === null || typeof node !== \"object\") {\n    return void 0;\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return typedNode.returnType?.typeAnnotation;\n};\n\n/**\n * Gets getParameters.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getParameters();\n * ```\n */\nconst getParameters = (node: unknown): unknown[] => {\n  if (node === null || typeof node !== \"object\") {\n    return [];\n  }\n\n  const typedNode = node as FunctionLikeNode;\n\n  return Array.isArray(typedNode.params) ? typedNode.params : [];\n};\n\n/**\n * Finds an inline object type literal within a type annotation node.\n * @param node Type annotation node to inspect.\n * @returns The first inline object type literal when present.\n * @example\n * ```typescript\n * const inlineObjectType = getInlineObjectTypeLiteral(annotation);\n * ```\n */\nconst getInlineObjectTypeLiteral = (\n  node: TypeAnnotationNode | undefined,\n): TypeAnnotationNode | undefined => {\n  if (node === void 0) {\n    return void 0;\n  }\n\n  if (node.type === \"TSTypeLiteral\") {\n    return node;\n  }\n\n  if (node.type === \"TSParenthesizedType\") {\n    return getInlineObjectTypeLiteral(\n      node.typeAnnotation as TypeAnnotationNode | undefined,\n    );\n  }\n\n  if (node.type === \"TSUnionType\" || node.type === \"TSIntersectionType\") {\n    const nestedTypes = Array.isArray(node.types) ? node.types : [];\n\n    for (const nestedType of nestedTypes) {\n      const nestedInlineObjectType = getInlineObjectTypeLiteral(\n        nestedType as TypeAnnotationNode | undefined,\n      );\n\n      if (nestedInlineObjectType !== void 0) {\n        return nestedInlineObjectType;\n      }\n    }\n  }\n\n  return void 0;\n};\n\n/**\n * Reports an inline object type annotation.\n * @param context Rule execution context.\n * @param typeAnnotation Type annotation node to report.\n * @example\n * ```typescript\n * reportTypeLiteral(context, typeAnnotation);\n * ```\n */\nconst reportTypeLiteral = (\n  context: Rule.RuleContext,\n  typeAnnotation: TypeAnnotationNode,\n): void => {\n  context.report({\n    messageId: \"preferNamedObject\",\n    node: typeAnnotation as unknown as Rule.Node,\n  });\n};\n\n/**\n * Checks function-like nodes for inline object types.\n * @param context Rule execution context.\n * @param node Function-like node to check.\n * @example\n * ```typescript\n * checkFunctionLike(context, node);\n * ```\n */\nconst checkFunctionLike = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  for (const parameter of getParameters(node)) {\n    const inlineObjectType = getInlineObjectTypeLiteral(\n      getTypeAnnotationNode(parameter),\n    );\n\n    if (inlineObjectType !== void 0) {\n      reportTypeLiteral(context, inlineObjectType);\n    }\n  }\n\n  const inlineReturnObjectType = getInlineObjectTypeLiteral(\n    getReturnTypeAnnotation(node),\n  );\n\n  if (inlineReturnObjectType !== void 0) {\n    reportTypeLiteral(context, inlineReturnObjectType);\n  }\n};\n\n/**\n * Checks variable declarators for inline object types.\n * @param context Rule execution context.\n * @param node Variable declarator to check.\n * @example\n * ```typescript\n * checkVariableDeclarator(context, node);\n * ```\n */\nconst checkVariableDeclarator = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  const typedNode = node as VariableDeclaratorNode;\n\n  const inlineObjectType = getInlineObjectTypeLiteral(\n    getTypeAnnotationNode(typedNode.id),\n  );\n\n  if (inlineObjectType !== void 0) {\n    reportTypeLiteral(context, inlineObjectType);\n  }\n};\n\n/** ESLint rule requiring named interface/type aliases for object types. */\nconst preferInterfaceTypesRule: Rule.RuleModule = {\n  /**\n   * Creates listeners that validate function-like and variable annotations.\n   * @param context Rule execution context.\n   * @returns Rule listener map.\n   * @example\n   * ```typescript\n   * const listeners = preferInterfaceTypesRule.create(context);\n   * ```\n   */\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    /**\n     * Checks function-like nodes for inline object types.\n     * @param node Function-like node to inspect.\n     * @example\n     * ```typescript\n     * functionLikeListener(node);\n     * ```\n     */\n    const functionLikeListener = (node: Rule.Node): void => {\n      checkFunctionLike(context, node);\n    };\n\n    /**\n     * Checks variable declarators for inline object types.\n     * @param node Variable declarator to inspect.\n     * @example\n     * ```typescript\n     * variableDeclaratorListener(node);\n     * ```\n     */\n    const variableDeclaratorListener = (node: Rule.Node): void => {\n      checkVariableDeclarator(context, node);\n    };\n\n    return {\n      ArrowFunctionExpression: functionLikeListener,\n      FunctionDeclaration: functionLikeListener,\n      FunctionExpression: functionLikeListener,\n      TSCallSignatureDeclaration: functionLikeListener,\n      TSConstructSignatureDeclaration: functionLikeListener,\n      TSDeclareFunction: functionLikeListener,\n      TSFunctionType: functionLikeListener,\n      TSMethodSignature: functionLikeListener,\n      VariableDeclarator: variableDeclaratorListener,\n    };\n  },\n  meta: {\n    docs: {\n      description:\n        \"Require named interfaces or type aliases for object types in parameters, return types, and variable annotations.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/prefer-interface-types.md\",\n    },\n    messages: {\n      preferNamedObject:\n        \"Use a named interface or type alias instead of an inline object type.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { preferInterfaceTypesRule };\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/core/prefer-interface-types/rule.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,0BAA0B,EAC1B,aAAa,EACb,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAE1B;;;;;;;;GAQG;AACH,MAAM,iBAAiB,GAAG,CACxB,OAAyB,EACzB,cAAkC,EAC5B,EAAE;IACR,OAAO,CAAC,MAAM,CAAC;QACb,SAAS,EAAE,mBAAmB;QAC9B,IAAI,EAAE,cAAsC;KAC7C,CAAC,CAAC;AACL,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,iBAAiB,GAAG,CACxB,OAAyB,EACzB,IAAe,EACT,EAAE;IACR,KAAK,MAAM,SAAS,IAAI,aAAa,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5C,MAAM,gBAAgB,GAAG,0BAA0B,CACjD,qBAAqB,CAAC,SAAS,CAAC,CACjC,CAAC;QAEF,IAAI,gBAAgB,KAAK,KAAK,CAAC,EAAE,CAAC;YAChC,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC;IAED,MAAM,sBAAsB,GAAG,0BAA0B,CACvD,uBAAuB,CAAC,IAAI,CAAC,CAC9B,CAAC;IAEF,IAAI,sBAAsB,KAAK,KAAK,CAAC,EAAE,CAAC;QACtC,iBAAiB,CAAC,OAAO,EAAE,sBAAsB,CAAC,CAAC;IACrD,CAAC;AACH,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,uBAAuB,GAAG,CAC9B,OAAyB,EACzB,IAAe,EACT,EAAE;IACR,MAAM,SAAS,GAAG,IAA8B,CAAC;IAEjD,MAAM,gBAAgB,GAAG,0BAA0B,CACjD,qBAAqB,CAAC,SAAS,CAAC,EAAE,CAAC,CACpC,CAAC;IAEF,IAAI,gBAAgB,KAAK,KAAK,CAAC,EAAE,CAAC;QAChC,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC,CAAC;AAEF,2EAA2E;AAC3E,MAAM,wBAAwB,GAAoB;IAChD;;;;;;;;OAQG;IACH,MAAM,CAAC,OAAyB;QAC9B;;;;;;;WAOG;QACH,MAAM,oBAAoB,GAAG,CAAC,IAAe,EAAQ,EAAE;YACrD,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACnC,CAAC,CAAC;QAEF;;;;;;;WAOG;QACH,MAAM,0BAA0B,GAAG,CAAC,IAAe,EAAQ,EAAE;YAC3D,uBAAuB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACzC,CAAC,CAAC;QAEF,OAAO;YACL,uBAAuB,EAAE,oBAAoB;YAC7C,mBAAmB,EAAE,oBAAoB;YACzC,kBAAkB,EAAE,oBAAoB;YACxC,0BAA0B,EAAE,oBAAoB;YAChD,+BAA+B,EAAE,oBAAoB;YACrD,iBAAiB,EAAE,oBAAoB;YACvC,cAAc,EAAE,oBAAoB;YACpC,iBAAiB,EAAE,oBAAoB;YACvC,kBAAkB,EAAE,0BAA0B;SAC/C,CAAC;IACJ,CAAC;IACD,IAAI,EAAE;QACJ,IAAI,EAAE;YACJ,WAAW,EACT,kHAAkH;YACpH,WAAW,EAAE,KAAK;YAClB,GAAG,EAAE,yFAAyF;SAC/F;QACD,QAAQ,EAAE;YACR,iBAAiB,EACf,uEAAuE;SAC1E;QACD,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,YAAY;KACnB;CACF,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type {\n  TypeAnnotationNode,\n  VariableDeclaratorNode,\n} from \"./rule-utilities\";\n\nimport {\n  getInlineObjectTypeLiteral,\n  getParameters,\n  getReturnTypeAnnotation,\n  getTypeAnnotationNode,\n} from \"./rule-utilities\";\n\n/**\n * Reports an inline object type annotation.\n * @param context Rule execution context.\n * @param typeAnnotation Type annotation node to report.\n * @example\n * ```typescript\n * reportTypeLiteral(context, typeAnnotation);\n * ```\n */\nconst reportTypeLiteral = (\n  context: Rule.RuleContext,\n  typeAnnotation: TypeAnnotationNode,\n): void => {\n  context.report({\n    messageId: \"preferNamedObject\",\n    node: typeAnnotation as unknown as Rule.Node,\n  });\n};\n\n/**\n * Checks function-like nodes for inline object types.\n * @param context Rule execution context.\n * @param node Function-like node to check.\n * @example\n * ```typescript\n * checkFunctionLike(context, node);\n * ```\n */\nconst checkFunctionLike = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  for (const parameter of getParameters(node)) {\n    const inlineObjectType = getInlineObjectTypeLiteral(\n      getTypeAnnotationNode(parameter),\n    );\n\n    if (inlineObjectType !== void 0) {\n      reportTypeLiteral(context, inlineObjectType);\n    }\n  }\n\n  const inlineReturnObjectType = getInlineObjectTypeLiteral(\n    getReturnTypeAnnotation(node),\n  );\n\n  if (inlineReturnObjectType !== void 0) {\n    reportTypeLiteral(context, inlineReturnObjectType);\n  }\n};\n\n/**\n * Checks variable declarators for inline object types.\n * @param context Rule execution context.\n * @param node Variable declarator to check.\n * @example\n * ```typescript\n * checkVariableDeclarator(context, node);\n * ```\n */\nconst checkVariableDeclarator = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  const typedNode = node as VariableDeclaratorNode;\n\n  const inlineObjectType = getInlineObjectTypeLiteral(\n    getTypeAnnotationNode(typedNode.id),\n  );\n\n  if (inlineObjectType !== void 0) {\n    reportTypeLiteral(context, inlineObjectType);\n  }\n};\n\n/** ESLint rule requiring named interface/type aliases for object types. */\nconst preferInterfaceTypesRule: Rule.RuleModule = {\n  /**\n   * Creates listeners that validate function-like and variable annotations.\n   * @param context Rule execution context.\n   * @returns Rule listener map.\n   * @example\n   * ```typescript\n   * const listeners = preferInterfaceTypesRule.create(context);\n   * ```\n   */\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    /**\n     * Checks function-like nodes for inline object types.\n     * @param node Function-like node to inspect.\n     * @example\n     * ```typescript\n     * functionLikeListener(node);\n     * ```\n     */\n    const functionLikeListener = (node: Rule.Node): void => {\n      checkFunctionLike(context, node);\n    };\n\n    /**\n     * Checks variable declarators for inline object types.\n     * @param node Variable declarator to inspect.\n     * @example\n     * ```typescript\n     * variableDeclaratorListener(node);\n     * ```\n     */\n    const variableDeclaratorListener = (node: Rule.Node): void => {\n      checkVariableDeclarator(context, node);\n    };\n\n    return {\n      ArrowFunctionExpression: functionLikeListener,\n      FunctionDeclaration: functionLikeListener,\n      FunctionExpression: functionLikeListener,\n      TSCallSignatureDeclaration: functionLikeListener,\n      TSConstructSignatureDeclaration: functionLikeListener,\n      TSDeclareFunction: functionLikeListener,\n      TSFunctionType: functionLikeListener,\n      TSMethodSignature: functionLikeListener,\n      VariableDeclarator: variableDeclaratorListener,\n    };\n  },\n  meta: {\n    docs: {\n      description:\n        \"Require named interfaces or type aliases for object types in parameters, return types, and variable annotations.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/prefer-interface-types.md\",\n    },\n    messages: {\n      preferNamedObject:\n        \"Use a named interface or type alias instead of an inline object type.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { preferInterfaceTypesRule };\n"]}

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

@@ -0,0 +1,25 @@
+import type { CommentLine } from "./types.js";
+/**
+ * Gets getCommentLines.
+ * @param commentText Input commentText value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getCommentLines();
+ * ```
+ */
+declare const getCommentLines: (commentText: string) => CommentLine[];
+/**
+ * Builds a removal range for the specified comment line.
+ * @param commentStart Comment start offset in the source.
+ * @param commentText Full comment text.
+ * @param line Line metadata for the comment.
+ * @returns The range to remove.
+ * @example
+ * ```typescript
+ * const range = buildRemovalRange(0, commentText, line);
+ * ```
+ */
+declare const buildRemovalRange: (commentStart: number, commentText: string, line: CommentLine) => [number, number];
+export { buildRemovalRange, getCommentLines };
+//# sourceMappingURL=comment-removal-ranges.d.ts.map

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

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