@codeperfect/eslint-plugin 2.4.0 → 2.5.0

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"}

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

@@ -0,0 +1,64 @@
+/**
+ * Gets getCommentLines.
+ * @param commentText Input commentText value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getCommentLines();
+ * ```
+ */
+const getCommentLines = (commentText) => {
+    const lines = commentText.split(/\r?\n/u);
+    const results = [];
+    let offset = 0;
+    for (const line of lines) {
+        const lineEnd = offset + line.length;
+        const nextSlice = commentText.slice(lineEnd, lineEnd + 2);
+        const lineBreakLength = nextSlice.startsWith("\r\n")
+            ? 2
+            : nextSlice.startsWith("\n")
+                ? 1
+                : 0;
+        results.push({
+            end: lineEnd,
+            lineBreakLength,
+            start: offset,
+            text: line,
+        });
+        offset = lineEnd + lineBreakLength;
+    }
+    return results;
+};
+/**
+ * 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);
+ * ```
+ */
+const buildRemovalRange = (commentStart, commentText, line) => {
+    if (line.lineBreakLength > 0) {
+        return [
+            commentStart + line.start,
+            commentStart + line.end + line.lineBreakLength,
+        ];
+    }
+    if (line.start > 0) {
+        const previousChar = commentText[line.start - 1];
+        const isPreviousLineBreak = previousChar === "\n";
+        if (isPreviousLineBreak) {
+            const lineBreakLength = line.start > 1 && commentText[line.start - 2] === "\r" ? 2 : 1;
+            return [
+                commentStart + line.start - lineBreakLength,
+                commentStart + line.end,
+            ];
+        }
+    }
+    return [commentStart + line.start, commentStart + line.end];
+};
+export { buildRemovalRange, getCommentLines };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import type { Comment, CommentLine } from "./types.js";
+import type { Comment } from "./types.js";
 /**
  * Gets the closest JSDoc comment for a node.
  * @param sourceCode Source code wrapper.
@@ -22,27 +22,5 @@ declare const getJsdocComment: (sourceCode: Rule.RuleContext["sourceCode"], node
  * ```
  */
 declare const getCommentText: (sourceCode: Rule.RuleContext["sourceCode"], comment: Comment) => string;
-/**
- * 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, getCommentText, getJsdocComment };
+export { getCommentText, getJsdocComment };
 //# sourceMappingURL=comment-utilities.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"comment-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA2DpD;;;;;;;;;GASG;AACH,QAAA,MAAM,eAAe,GACnB,YAAY,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAC1C,MAAM,IAAI,CAAC,IAAI,KACd,OAAO,GAAG,SAuBZ,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAClB,YAAY,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAC1C,SAAS,OAAO,KACf,MASF,CAAC;AAEF;;;;;;;;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,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"comment-utilities.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AA2DvC;;;;;;;;;GASG;AACH,QAAA,MAAM,eAAe,GACnB,YAAY,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAC1C,MAAM,IAAI,CAAC,IAAI,KACd,OAAO,GAAG,SAuBZ,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,cAAc,GAClB,YAAY,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,EAC1C,SAAS,OAAO,KACf,MASF,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,CAAC"}

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

@@ -57,7 +57,7 @@ const findClosestComment = (comments, nodeStart) => {
 const getJsdocComment = (sourceCode, node) => {
     const comments = sourceCode.getAllComments();
     const nodeStart = node.range?.[0];
-    if (comments.length === 0 || typeof nodeStart !== "number") {
+    if (typeof nodeStart !== "number" || comments.length === 0) {
         return void 0;
     }
     const comment = findClosestComment(comments, nodeStart);
@@ -89,67 +89,5 @@ const getCommentText = (sourceCode, comment) => {
     }
     return sourceCode.text.slice(start, end);
 };
-/**
- * Gets getCommentLines.
- * @param commentText Input commentText value.
- * @returns Return value output.
- * @example
- * ```typescript
- * getCommentLines();
- * ```
- */
-const getCommentLines = (commentText) => {
-    const lines = commentText.split(/\r?\n/u);
-    const results = [];
-    let offset = 0;
-    for (const line of lines) {
-        const lineEnd = offset + line.length;
-        const nextSlice = commentText.slice(lineEnd, lineEnd + 2);
-        const lineBreakLength = nextSlice.startsWith("\r\n")
-            ? 2
-            : nextSlice.startsWith("\n")
-                ? 1
-                : 0;
-        results.push({
-            end: lineEnd,
-            lineBreakLength,
-            start: offset,
-            text: line,
-        });
-        offset = lineEnd + lineBreakLength;
-    }
-    return results;
-};
-/**
- * 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);
- * ```
- */
-const buildRemovalRange = (commentStart, commentText, line) => {
-    if (line.lineBreakLength > 0) {
-        return [
-            commentStart + line.start,
-            commentStart + line.end + line.lineBreakLength,
-        ];
-    }
-    if (line.start > 0) {
-        const previousChar = commentText[line.start - 1];
-        const previousIsLineBreak = previousChar === "\n";
-        if (previousIsLineBreak) {
-            const lineBreakLength = line.start > 1 && commentText[line.start - 2] === "\r" ? 2 : 1;
-            return [
-                commentStart + line.start - lineBreakLength,
-                commentStart + line.end,
-            ];
-        }
-    }
-    return [commentStart + line.start, commentStart + line.end];
-};
-export { buildRemovalRange, getCommentLines, getCommentText, getJsdocComment };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"comment-utilities.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Comment, CommentLine } from \"./types\";\n\n/**\n * Checks isJsdocComment.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isJsdocComment();\n * ```\n */\nconst isJsdocComment = (comment: Comment): boolean =>\n  comment.type === \"Block\" && comment.value.startsWith(\"*\");\n\n/**\n * Gets getCommentEnd.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getCommentEnd();\n * ```\n */\nconst getCommentEnd = (comment: Comment): number | undefined => {\n  const commentEnd = comment.range?.[1];\n\n  return typeof commentEnd === \"number\" ? commentEnd : void 0;\n};\n\n/**\n * Finds the closest JSDoc comment before a node.\n * @param comments Comment list to search.\n * @param nodeStart Start offset of the node.\n * @returns The closest JSDoc comment when present.\n * @example\n * ```typescript\n * const comment = findClosestComment(comments, nodeStart);\n * ```\n */\nconst findClosestComment = (\n  comments: Comment[],\n  nodeStart: number,\n): Comment | undefined => {\n  let closest: Comment | undefined = void 0;\n  let closestEnd = -1;\n\n  for (const comment of comments) {\n    const commentEnd = getCommentEnd(comment);\n    const shouldConsider = isJsdocComment(comment) && commentEnd !== void 0;\n\n    if (shouldConsider && commentEnd <= nodeStart && commentEnd > closestEnd) {\n      closest = comment;\n      closestEnd = commentEnd;\n    }\n  }\n\n  return closest;\n};\n\n/**\n * Gets the closest JSDoc comment for a node.\n * @param sourceCode Source code wrapper.\n * @param node Node to inspect.\n * @returns The closest JSDoc comment when present.\n * @example\n * ```typescript\n * const comment = getJsdocComment(sourceCode, node);\n * ```\n */\nconst getJsdocComment = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  node: Rule.Node,\n): Comment | undefined => {\n  const comments = sourceCode.getAllComments();\n  const nodeStart = node.range?.[0];\n\n  if (comments.length === 0 || typeof nodeStart !== \"number\") {\n    return void 0;\n  }\n\n  const comment = findClosestComment(comments, nodeStart);\n\n  if (comment === void 0) {\n    return void 0;\n  }\n\n  const commentEnd = comment.range?.[1];\n\n  if (typeof commentEnd !== \"number\") {\n    return void 0;\n  }\n\n  const betweenCommentAndNode = sourceCode.text.slice(commentEnd, nodeStart);\n\n  return betweenCommentAndNode.trim().length === 0 ? comment : void 0;\n};\n\n/**\n * Extracts the full text for a comment range.\n * @param sourceCode Source code wrapper.\n * @param comment Comment to read.\n * @returns Comment contents from the source.\n * @example\n * ```typescript\n * const text = getCommentText(sourceCode, comment);\n * ```\n */\nconst getCommentText = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  comment: Comment,\n): string => {\n  const start = comment.range?.[0];\n  const end = comment.range?.[1];\n\n  if (typeof start !== \"number\" || typeof end !== \"number\") {\n    return \"\";\n  }\n\n  return sourceCode.text.slice(start, end);\n};\n\n/**\n * Gets getCommentLines.\n * @param commentText Input commentText value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getCommentLines();\n * ```\n */\nconst getCommentLines = (commentText: string): CommentLine[] => {\n  const lines = commentText.split(/\\r?\\n/u);\n  const results: CommentLine[] = [];\n  let offset = 0;\n\n  for (const line of lines) {\n    const lineEnd = offset + line.length;\n    const nextSlice = commentText.slice(lineEnd, lineEnd + 2);\n    const lineBreakLength = nextSlice.startsWith(\"\\r\\n\")\n      ? 2\n      : nextSlice.startsWith(\"\\n\")\n        ? 1\n        : 0;\n\n    results.push({\n      end: lineEnd,\n      lineBreakLength,\n      start: offset,\n      text: line,\n    });\n\n    offset = lineEnd + lineBreakLength;\n  }\n\n  return results;\n};\n\n/**\n * Builds a removal range for the specified comment line.\n * @param commentStart Comment start offset in the source.\n * @param commentText Full comment text.\n * @param line Line metadata for the comment.\n * @returns The range to remove.\n * @example\n * ```typescript\n * const range = buildRemovalRange(0, commentText, line);\n * ```\n */\nconst buildRemovalRange = (\n  commentStart: number,\n  commentText: string,\n  line: CommentLine,\n): [number, number] => {\n  if (line.lineBreakLength > 0) {\n    return [\n      commentStart + line.start,\n      commentStart + line.end + line.lineBreakLength,\n    ];\n  }\n\n  if (line.start > 0) {\n    const previousChar = commentText[line.start - 1];\n    const previousIsLineBreak = previousChar === \"\\n\";\n\n    if (previousIsLineBreak) {\n      const lineBreakLength =\n        line.start > 1 && commentText[line.start - 2] === \"\\r\" ? 2 : 1;\n      return [\n        commentStart + line.start - lineBreakLength,\n        commentStart + line.end,\n      ];\n    }\n  }\n\n  return [commentStart + line.start, commentStart + line.end];\n};\n\nexport { buildRemovalRange, getCommentLines, getCommentText, getJsdocComment };\n"]}
+export { getCommentText, getJsdocComment };
+//# sourceMappingURL=data:application/json;base64,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