@codeperfect/eslint-plugin 2.3.0 → 2.5.0

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

@@ -34,8 +34,8 @@ function hasRange(node) {
 function isRange(value) {
     return (Array.isArray(value) &&
         value.length === 2 &&
-        value.every((part) => Number.isInteger(part) && part >= 0) &&
+        value.every((part) => Number.isSafeInteger(part) && part >= 0) &&
         value[0] <= value[1]);
 }
 export { hasFixData, hasRange };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL2NvcmUvbm8tbXVsdGlwbGUtZGVjbGFyYXRvcnMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBa0VBOzs7Ozs7OztHQVFHO0FBQ0gsU0FBUyxVQUFVLENBQ2pCLElBQTZCO0lBRTdCLE9BQU8sUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLE1BQU0sSUFBSSxJQUFJLElBQUksT0FBTyxJQUFJLENBQUMsSUFBSSxLQUFLLFFBQVEsQ0FBQztBQUMzRSxDQUFDO0FBRUQ7Ozs7Ozs7O0dBUUc7QUFDSCxTQUFTLFFBQVEsQ0FBQyxJQUEwQjtJQUMxQyxPQUFPLE9BQU8sQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLENBQUM7QUFDOUIsQ0FBQztBQUVEOzs7Ozs7OztHQVFHO0FBQ0gsU0FBUyxPQUFPLENBQUMsS0FBYztJQUM3QixPQUFPLENBQ0wsS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUM7UUFDcEIsS0FBSyxDQUFDLE1BQU0sS0FBSyxDQUFDO1FBQ2xCLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxJQUFJLENBQUMsQ0FBQztRQUMxRCxLQUFLLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUNyQixDQUFDO0FBQ0osQ0FBQztBQUVELE9BQU8sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogUHJvdmlkZXMgdGhlIG1pbmltYWwgbm9kZSBzaGFwZSB1c2VkIGJ5IHRoZSBydWxlLiAqL1xyXG5pbnRlcmZhY2UgQmFzZU5vZGUge1xyXG4gIC8qKiBQYXJlbnQgbm9kZSB1c2VkIHRvIGluc3BlY3Qgc3Vycm91bmRpbmcgc3ludGF4LiAqL1xyXG4gIHBhcmVudD86IEJhc2VOb2RlO1xyXG4gIC8qKiBTb3VyY2UgcmFuZ2UgdXNlZCBieSBhdXRvZml4IGxvZ2ljLiAqL1xyXG4gIHJhbmdlPzogUmFuZ2U7XHJcbiAgLyoqIEVTVHJlZSBub2RlIHR5cGUuICovXHJcbiAgdHlwZTogc3RyaW5nO1xyXG59XHJcblxyXG4vKiogUmVwcmVzZW50cyBhIGRlY2xhcmF0aW9uIHRoYXQgY2FuIGJlIHJld3JpdHRlbiBieSB0aGUgZml4ZXIuICovXHJcbmludGVyZmFjZSBGaXhhYmxlVmFyaWFibGVEZWNsYXJhdGlvbk5vZGUgZXh0ZW5kcyBWYXJpYWJsZURlY2xhcmF0aW9uTm9kZSB7XHJcbiAgLyoqIENvbmZpcm1lZCBkZWNsYXJhdGlvbiBrZXl3b3JkLiAqL1xyXG4gIGtpbmQ6IHN0cmluZztcclxuICAvKiogQ29uZmlybWVkIHNvdXJjZSByYW5nZSBmb3IgdGhlIGZ1bGwgZGVjbGFyYXRpb24uICovXHJcbiAgcmFuZ2U6IFJhbmdlO1xyXG59XHJcblxyXG4vKiogUmVwcmVzZW50cyBhIGBmb3IuLi5pbmAgb3IgYGZvci4uLm9mYCBzdGF0ZW1lbnQuICovXHJcbmludGVyZmFjZSBGb3JJbk9yT2ZTdGF0ZW1lbnROb2RlIGV4dGVuZHMgQmFzZU5vZGUge1xyXG4gIC8qKiBMZWZ0LWhhbmQgaW5pdGlhbGl6ZXIgb2YgdGhlIGxvb3AuICovXHJcbiAgbGVmdD86IEJhc2VOb2RlO1xyXG59XHJcblxyXG4vKiogUmVwcmVzZW50cyBhIGNsYXNzaWMgYGZvcmAgc3RhdGVtZW50LiAqL1xyXG5pbnRlcmZhY2UgRm9yU3RhdGVtZW50Tm9kZSBleHRlbmRzIEJhc2VOb2RlIHtcclxuICAvKiogSW5pdGlhbGl6ZXIgc2VjdGlvbiBvZiB0aGUgbG9vcC4gKi9cclxuICBpbml0PzogQmFzZU5vZGUgfCBudWxsO1xyXG59XHJcblxyXG4vKiogUmVwcmVzZW50cyBhIHNvdXJjZSByYW5nZSB3aXRoaW4gdGhlIG9yaWdpbmFsIGZpbGUuICovXHJcbnR5cGUgUmFuZ2UgPSBbbnVtYmVyLCBudW1iZXJdO1xyXG5cclxuLyoqIFJlcHJlc2VudHMgYSBub2RlIHdob3NlIHJhbmdlIGhhcyBiZWVuIGNvbmZpcm1lZC4gKi9cclxuaW50ZXJmYWNlIFJhbmdlZE5vZGUgZXh0ZW5kcyBCYXNlTm9kZSB7XHJcbiAgLyoqIENvbmZpcm1lZCBzb3VyY2UgcmFuZ2UgZm9yIHRoZSBub2RlLiAqL1xyXG4gIHJhbmdlOiBSYW5nZTtcclxufVxyXG5cclxuLyoqIFJlcHJlc2VudHMgYSBkZWNsYXJhdG9yIHdob3NlIHJhbmdlIGhhcyBiZWVuIGNvbmZpcm1lZC4gKi9cclxuaW50ZXJmYWNlIFJhbmdlZFZhcmlhYmxlRGVjbGFyYXRvck5vZGUgZXh0ZW5kcyBWYXJpYWJsZURlY2xhcmF0b3JOb2RlIHtcclxuICAvKiogQ29uZmlybWVkIHNvdXJjZSByYW5nZSBmb3IgdGhlIGRlY2xhcmF0b3IuICovXHJcbiAgcmFuZ2U6IFJhbmdlO1xyXG59XHJcblxyXG4vKiogRXhwb3NlcyB0aGUgc291cmNlIGFjY2VzcyBtZXRob2RzIHVzZWQgYnkgdGhlIHJ1bGUuICovXHJcbmludGVyZmFjZSBTb3VyY2VDb2RlQWNjZXNzIHtcclxuICAvKiogUmV0dXJucyB0aGUgc291cmNlIHRleHQgZm9yIGEgbm9kZSBvciB0aGUgZnVsbCBmaWxlIHdoZW4gb21pdHRlZC4gKi9cclxuICBnZXRUZXh0OiAobm9kZT86IEJhc2VOb2RlKSA9PiBzdHJpbmc7XHJcbiAgLyoqIFJhdyBzb3VyY2UgdGV4dCB3aGVuIGF2YWlsYWJsZSBmcm9tIEVTTGludC4gKi9cclxuICB0ZXh0Pzogc3RyaW5nO1xyXG59XHJcblxyXG4vKiogUmVwcmVzZW50cyBhIHZhcmlhYmxlIGRlY2xhcmF0aW9uIHN0YXRlbWVudC4gKi9cclxuaW50ZXJmYWNlIFZhcmlhYmxlRGVjbGFyYXRpb25Ob2RlIGV4dGVuZHMgQmFzZU5vZGUge1xyXG4gIC8qKiBJbmRpdmlkdWFsIGRlY2xhcmF0b3JzIGNvbnRhaW5lZCBpbiB0aGUgZGVjbGFyYXRpb24uICovXHJcbiAgZGVjbGFyYXRpb25zPzogVmFyaWFibGVEZWNsYXJhdG9yTm9kZVtdO1xyXG4gIC8qKiBUeXBlU2NyaXB0IGFtYmllbnQgZGVjbGFyYXRpb24gbW9kaWZpZXIuICovXHJcbiAgZGVjbGFyZT86IGJvb2xlYW47XHJcbiAgLyoqIERlY2xhcmF0aW9uIGtpbmQgc3VjaCBhcyBgY29uc3RgLCBgbGV0YCwgb3IgYHZhcmAuICovXHJcbiAga2luZD86IHN0cmluZztcclxufVxyXG5cclxuLyoqIFJlcHJlc2VudHMgYSBzaW5nbGUgdmFyaWFibGUgZGVjbGFyYXRvci4gKi9cclxudHlwZSBWYXJpYWJsZURlY2xhcmF0b3JOb2RlID0gQmFzZU5vZGU7XHJcblxyXG4vKipcclxuICogRGV0ZXJtaW5lcyB3aGV0aGVyIGEgZGVjbGFyYXRpb24gY29udGFpbnMgdGhlIGRhdGEgbmVlZGVkIGZvciBhdXRvZml4LlxyXG4gKiBAcGFyYW0gbm9kZSBEZWNsYXJhdGlvbiB0byB2YWxpZGF0ZS5cclxuICogQHJldHVybnMgV2hldGhlciB0aGUgZGVjbGFyYXRpb24gZXhwb3NlcyBib3RoIGBraW5kYCBhbmQgYHJhbmdlYC5cclxuICogQGV4YW1wbGVcclxuICogYGBgdHlwZXNjcmlwdFxyXG4gKiBjb25zdCBmaXhhYmxlID0gaGFzRml4RGF0YSh7IGtpbmQ6IFwiY29uc3RcIiwgcmFuZ2U6IFswLCA1XSwgdHlwZTogXCJWYXJpYWJsZURlY2xhcmF0aW9uXCIgfSk7XHJcbiAqIGBgYFxyXG4gKi9cclxuZnVuY3Rpb24gaGFzRml4RGF0YShcclxuICBub2RlOiBWYXJpYWJsZURlY2xhcmF0aW9uTm9kZSxcclxuKTogbm9kZSBpcyBGaXhhYmxlVmFyaWFibGVEZWNsYXJhdGlvbk5vZGUge1xyXG4gIHJldHVybiBoYXNSYW5nZShub2RlKSAmJiBcImtpbmRcIiBpbiBub2RlICYmIHR5cGVvZiBub2RlLmtpbmQgPT09IFwic3RyaW5nXCI7XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBEZXRlcm1pbmVzIHdoZXRoZXIgYSBub2RlIGhhcyBhIGNvbXBsZXRlIHJhbmdlLlxyXG4gKiBAcGFyYW0gbm9kZSBOb2RlIHRvIHZhbGlkYXRlLlxyXG4gKiBAcmV0dXJucyBXaGV0aGVyIHRoZSBub2RlIGV4cG9zZXMgYSB2YWxpZCB0d28taXRlbSByYW5nZS5cclxuICogQGV4YW1wbGVcclxuICogYGBgdHlwZXNjcmlwdFxyXG4gKiBjb25zdCByYW5nZWQgPSBoYXNSYW5nZSh7IHJhbmdlOiBbMCwgMV0sIHR5cGU6IFwiSWRlbnRpZmllclwiIH0pO1xyXG4gKiBgYGBcclxuICovXHJcbmZ1bmN0aW9uIGhhc1JhbmdlKG5vZGU6IEJhc2VOb2RlIHwgdW5kZWZpbmVkKTogbm9kZSBpcyBSYW5nZWROb2RlIHtcclxuICByZXR1cm4gaXNSYW5nZShub2RlPy5yYW5nZSk7XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBDaGVja3Mgd2hldGhlciBhIHZhbHVlIGlzIGEgY29tcGxldGUgc291cmNlIHJhbmdlLlxyXG4gKiBAcGFyYW0gdmFsdWUgQ2FuZGlkYXRlIHJhbmdlIHZhbHVlLlxyXG4gKiBAcmV0dXJucyBXaGV0aGVyIHRoZSB2YWx1ZSBpcyBhIHZhbGlkIHNvdXJjZSByYW5nZSB0dXBsZS5cclxuICogQGV4YW1wbGVcclxuICogYGBgdHlwZXNjcmlwdFxyXG4gKiBjb25zdCB2YWxpZFJhbmdlID0gaXNSYW5nZShbMCwgMV0pO1xyXG4gKiBgYGBcclxuICovXHJcbmZ1bmN0aW9uIGlzUmFuZ2UodmFsdWU6IHVua25vd24pOiB2YWx1ZSBpcyBSYW5nZSB7XHJcbiAgcmV0dXJuIChcclxuICAgIEFycmF5LmlzQXJyYXkodmFsdWUpICYmXHJcbiAgICB2YWx1ZS5sZW5ndGggPT09IDIgJiZcclxuICAgIHZhbHVlLmV2ZXJ5KChwYXJ0KSA9PiBOdW1iZXIuaXNJbnRlZ2VyKHBhcnQpICYmIHBhcnQgPj0gMCkgJiZcclxuICAgIHZhbHVlWzBdIDw9IHZhbHVlWzFdXHJcbiAgKTtcclxufVxyXG5cclxuZXhwb3J0IHsgaGFzRml4RGF0YSwgaGFzUmFuZ2UgfTtcclxuZXhwb3J0IHR5cGUge1xyXG4gIEZpeGFibGVWYXJpYWJsZURlY2xhcmF0aW9uTm9kZSxcclxuICBGb3JJbk9yT2ZTdGF0ZW1lbnROb2RlLFxyXG4gIEZvclN0YXRlbWVudE5vZGUsXHJcbiAgUmFuZ2VkVmFyaWFibGVEZWNsYXJhdG9yTm9kZSxcclxuICBTb3VyY2VDb2RlQWNjZXNzLFxyXG4gIFZhcmlhYmxlRGVjbGFyYXRpb25Ob2RlLFxyXG4gIFZhcmlhYmxlRGVjbGFyYXRvck5vZGUsXHJcbn07XHJcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

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