@codeperfect/eslint-plugin 1.0.0 → 2.0.0

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

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

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

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

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

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

package/dist/{custom-rule-documentation.d.ts → domain/custom-rule-documentation.d.ts}

@@ -6,7 +6,7 @@ interface CustomRuleDocumentation {
     url: string;
 }
 /** Base URL for published custom rule documentation pages. */
-declare const customRuleDocumentationBaseUrl = "https://github.com/codeperfect/eslint-plugin/blob/main/docs/rules";
+declare const customRuleDocumentationBaseUrl = "https://github.com/parloti/eslint-plugin/blob/main/docs/rules";
 /**
  * Creates shared docs metadata for a package-owned custom rule.
  * @param ruleName ESLint rule name without the plugin prefix.

package/dist/domain/custom-rule-documentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-rule-documentation.d.ts","sourceRoot":"","sources":["../../src/domain/custom-rule-documentation.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,UAAU,uBAAuB;IAC/B,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IAEpB,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;CACb;AAED,8DAA8D;AAC9D,QAAA,MAAM,8BAA8B,kEAC6B,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,iBAAS,uBAAuB,CAC9B,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,GAClB,uBAAuB,CAKzB;AAED;;;;;;;;GAQG;AACH,iBAAS,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,6BAA6B,GAC9B,CAAC;AACF,YAAY,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/domain/custom-rule-documentation.js

@@ -0,0 +1,35 @@
+/** Base URL for published custom rule documentation pages. */
+const customRuleDocumentationBaseUrl = "https://github.com/parloti/eslint-plugin/blob/main/docs/rules";
+/**
+ * Creates shared docs metadata for a package-owned custom rule.
+ * @param ruleName ESLint rule name without the plugin prefix.
+ * @param description Input description value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const docs = createRuleDocumentation(
+ *   "prefer-interface-types",
+ *   "Rule description",
+ * );
+ * ```
+ */
+function createRuleDocumentation(ruleName, description) {
+    return {
+        description,
+        url: getCustomRuleDocumentationUrl(ruleName),
+    };
+}
+/**
+ * Builds the canonical documentation URL for a package-owned custom rule.
+ * @param ruleName ESLint rule name without the plugin prefix.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const url = getCustomRuleDocumentationUrl("prefer-interface-types");
+ * ```
+ */
+function getCustomRuleDocumentationUrl(ruleName) {
+    return `${customRuleDocumentationBaseUrl}/${ruleName}.md`;
+}
+export { createRuleDocumentation, customRuleDocumentationBaseUrl, getCustomRuleDocumentationUrl, };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/docs/index.d.ts

@@ -0,0 +1,4 @@
+export { noInterfaceMemberDocumentationRule } from "./no-interface-member-docs/index.js";
+export { requireExampleLanguageRule } from "./require-example-language/index.js";
+export { singleLineJsdocRule } from "./single-line-jsdoc/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/docs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/domain/docs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/domain/docs/index.js

@@ -0,0 +1,4 @@
+export { noInterfaceMemberDocumentationRule } from "./no-interface-member-docs/index.js";
+export { requireExampleLanguageRule } from "./require-example-language/index.js";
+export { singleLineJsdocRule } from "./single-line-jsdoc/index.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9tYWluL2RvY3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGtDQUFrQyxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDaEYsT0FBTyxFQUFFLDBCQUEwQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDeEUsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0scUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBub0ludGVyZmFjZU1lbWJlckRvY3VtZW50YXRpb25SdWxlIH0gZnJvbSBcIi4vbm8taW50ZXJmYWNlLW1lbWJlci1kb2NzXCI7XG5leHBvcnQgeyByZXF1aXJlRXhhbXBsZUxhbmd1YWdlUnVsZSB9IGZyb20gXCIuL3JlcXVpcmUtZXhhbXBsZS1sYW5ndWFnZVwiO1xuZXhwb3J0IHsgc2luZ2xlTGluZUpzZG9jUnVsZSB9IGZyb20gXCIuL3NpbmdsZS1saW5lLWpzZG9jXCI7XG4iXX0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"comment-utilities-test-helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-utilities-test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,qCAAqC;AACrC,KAAK,OAAO,GAAG,UAAU,CACvB,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,gBAAgB,CAAC,CACjD,CAAC,MAAM,CAAC,CAAC;AAEV,qCAAqC;AACrC,UAAU,gBAAgB;IACxB,wBAAwB;IACxB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;IAEhB,0BAA0B;IAC1B,MAAM,EAAE,OAAO,CAAC;IAEhB,8BAA8B;IAC9B,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;CAC5C;AAED,qCAAqC;AACrC,UAAU,kBAAkB;IAC1B,wBAAwB;IACxB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;IAEhB,8BAA8B;IAC9B,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;CAC5C;AAED,qCAAqC;AACrC,UAAU,kBAAkB;IAC1B,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IAEjB,wBAAwB;IACxB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;IAEhB,8BAA8B;IAC9B,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;CAC5C;AAED;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,GAAI,OAAO,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,KAAG,OAKlD,CAAC;AAEhB;;;;;;;;;GASG;AACH,QAAA,MAAM,gBAAgB,GACpB,MAAM,MAAM,EACZ,UAAU,OAAO,EAAE,KAClB,IAAI,CAAC,WAAW,CAAC,YAAY,CAIM,CAAC;AAiBvC;;;;;;;GAOG;AACH,QAAA,MAAM,sBAAsB,QAAO,gBAkBlC,CAAC;AAEF;;;;;;;GAOG;AACH,QAAA,MAAM,wBAAwB,QAAO,kBAYpC,CAAC;AAEF;;;;;;;GAOG;AACH,QAAA,MAAM,qBAAqB,QAAO,kBAYjC,CAAC;AAEF;;;;;;;GAOG;AACH,QAAA,MAAM,yBAAyB,QAAO,kBAWrC,CAAC;AAEF,OAAO,EACL,aAAa,EACb,sBAAsB,EACtB,qBAAqB,EACrB,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,GACjB,CAAC;AACF,YAAY,EAAE,OAAO,EAAE,CAAC"}

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

@@ -0,0 +1,129 @@
+/**
+ * Creates a block comment value for tests.
+ * @param value Comment value without delimiters.
+ * @param range Comment range in the source text.
+ * @returns The comment object.
+ * @example
+ * ```typescript
+ * const comment = createComment("*\n * ok\n ", [0, 10]);
+ * ```
+ */
+const createComment = (value, range) => ({
+    range,
+    type: "Block",
+    value,
+});
+/**
+ * Creates a source code wrapper with comments.
+ * @param text Full source text.
+ * @param comments Comment nodes to return.
+ * @returns SourceCode stub used in tests.
+ * @example
+ * ```typescript
+ * const sourceCode = createSourceCode("function demo() {}", []);
+ * ```
+ */
+const createSourceCode = (text, comments) => ({
+    getAllComments: () => comments,
+    text,
+});
+/**
+ * Creates a function node for the test source text.
+ * @param sourceText Source content that includes a function.
+ * @returns Function declaration node used in tests.
+ * @example
+ * ```typescript
+ * const node = createFunctionNode("function demo() {}");
+ * ```
+ */
+const createFunctionNode = (sourceText) => ({
+    range: [sourceText.indexOf("function"), sourceText.length],
+    type: "FunctionDeclaration",
+});
+/**
+ * Creates a context with two JSDoc comments.
+ * @returns The dual-comment context.
+ * @example
+ * ```typescript
+ * const context = createDualJsdocContext();
+ * ```
+ */
+const createDualJsdocContext = () => {
+    const sourceText = [
+        "/**\n * first\n */",
+        "/**\n * second\n */",
+        "function demo() {}",
+    ].join("\n");
+    const firstStart = sourceText.indexOf("/**");
+    const firstEnd = sourceText.indexOf("*/") + 2;
+    const secondStart = sourceText.indexOf("/**", firstEnd);
+    const secondEnd = sourceText.indexOf("*/", secondStart) + 2;
+    const first = createComment("*\n * first\n ", [firstStart, firstEnd]);
+    const second = createComment("*\n * second\n ", [secondStart, secondEnd]);
+    return {
+        node: createFunctionNode(sourceText),
+        second,
+        sourceCode: createSourceCode(sourceText, [first, second]),
+    };
+};
+/**
+ * Creates a context with a single JSDoc comment.
+ * @returns The single-comment context.
+ * @example
+ * ```typescript
+ * const context = createSingleJsdocContext();
+ * ```
+ */
+const createSingleJsdocContext = () => {
+    const sourceText = ["/**\n * ok\n */", "function demo() {}"].join("\n");
+    const comment = createComment("*\n * ok\n ", [
+        0,
+        sourceText.indexOf("*/") + 2,
+    ]);
+    return {
+        comment,
+        node: createFunctionNode(sourceText),
+        sourceCode: createSourceCode(sourceText, [comment]),
+    };
+};
+/**
+ * Creates a context with a non-JSDoc comment.
+ * @returns The lookup context.
+ * @example
+ * ```typescript
+ * const context = createNonJsdocContext();
+ * ```
+ */
+const createNonJsdocContext = () => {
+    const sourceText = "// line\nfunction demo() {}";
+    const comment = {
+        range: [0, 7],
+        type: "Line",
+        value: " line",
+    };
+    return {
+        node: createFunctionNode(sourceText),
+        sourceCode: createSourceCode(sourceText, [comment]),
+    };
+};
+/**
+ * Creates a context with a JSDoc comment missing range data.
+ * @returns The lookup context.
+ * @example
+ * ```typescript
+ * const context = createRangeMissingContext();
+ * ```
+ */
+const createRangeMissingContext = () => {
+    const sourceText = "function demo() {}";
+    const comment = {
+        type: "Block",
+        value: "*\n * ok\n ",
+    };
+    return {
+        node: createFunctionNode(sourceText),
+        sourceCode: createSourceCode(sourceText, [comment]),
+    };
+};
+export { createComment, createDualJsdocContext, createNonJsdocContext, createRangeMissingContext, createSingleJsdocContext, createSourceCode, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"comment-utilities-test-helpers.js","sourceRoot":"","sources":["../../../../src/domain/docs/no-interface-member-docs/comment-utilities-test-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\n/** Type definition for rule data. */\ntype Comment = ReturnType<\n  Rule.RuleContext[\"sourceCode\"][\"getAllComments\"]\n>[number];\n\n/** Type definition for rule data. */\ninterface DualJsdocContext {\n  /** Node field value. */\n  node: Rule.Node;\n\n  /** Second field value. */\n  second: Comment;\n\n  /** SourceCode field value. */\n  sourceCode: Rule.RuleContext[\"sourceCode\"];\n}\n\n/** Type definition for rule data. */\ninterface JsdocLookupContext {\n  /** Node field value. */\n  node: Rule.Node;\n\n  /** SourceCode field value. */\n  sourceCode: Rule.RuleContext[\"sourceCode\"];\n}\n\n/** Type definition for rule data. */\ninterface SingleJsdocContext {\n  /** Comment field value. */\n  comment: Comment;\n\n  /** Node field value. */\n  node: Rule.Node;\n\n  /** SourceCode field value. */\n  sourceCode: Rule.RuleContext[\"sourceCode\"];\n}\n\n/**\n * Creates a block comment value for tests.\n * @param value Comment value without delimiters.\n * @param range Comment range in the source text.\n * @returns The comment object.\n * @example\n * ```typescript\n * const comment = createComment(\"*\\n * ok\\n \", [0, 10]);\n * ```\n */\nconst createComment = (value: string, range?: [number, number]): Comment =>\n  ({\n    range,\n    type: \"Block\",\n    value,\n  }) as Comment;\n\n/**\n * Creates a source code wrapper with comments.\n * @param text Full source text.\n * @param comments Comment nodes to return.\n * @returns SourceCode stub used in tests.\n * @example\n * ```typescript\n * const sourceCode = createSourceCode(\"function demo() {}\", []);\n * ```\n */\nconst createSourceCode = (\n  text: string,\n  comments: Comment[],\n): Rule.RuleContext[\"sourceCode\"] =>\n  ({\n    getAllComments: (): Comment[] => comments,\n    text,\n  }) as Rule.RuleContext[\"sourceCode\"];\n\n/**\n * Creates a function node for the test source text.\n * @param sourceText Source content that includes a function.\n * @returns Function declaration node used in tests.\n * @example\n * ```typescript\n * const node = createFunctionNode(\"function demo() {}\");\n * ```\n */\nconst createFunctionNode = (sourceText: string): Rule.Node =>\n  ({\n    range: [sourceText.indexOf(\"function\"), sourceText.length],\n    type: \"FunctionDeclaration\",\n  }) as Rule.Node;\n\n/**\n * Creates a context with two JSDoc comments.\n * @returns The dual-comment context.\n * @example\n * ```typescript\n * const context = createDualJsdocContext();\n * ```\n */\nconst createDualJsdocContext = (): DualJsdocContext => {\n  const sourceText = [\n    \"/**\\n * first\\n */\",\n    \"/**\\n * second\\n */\",\n    \"function demo() {}\",\n  ].join(\"\\n\");\n  const firstStart = sourceText.indexOf(\"/**\");\n  const firstEnd = sourceText.indexOf(\"*/\") + 2;\n  const secondStart = sourceText.indexOf(\"/**\", firstEnd);\n  const secondEnd = sourceText.indexOf(\"*/\", secondStart) + 2;\n  const first = createComment(\"*\\n * first\\n \", [firstStart, firstEnd]);\n  const second = createComment(\"*\\n * second\\n \", [secondStart, secondEnd]);\n\n  return {\n    node: createFunctionNode(sourceText),\n    second,\n    sourceCode: createSourceCode(sourceText, [first, second]),\n  };\n};\n\n/**\n * Creates a context with a single JSDoc comment.\n * @returns The single-comment context.\n * @example\n * ```typescript\n * const context = createSingleJsdocContext();\n * ```\n */\nconst createSingleJsdocContext = (): SingleJsdocContext => {\n  const sourceText = [\"/**\\n * ok\\n */\", \"function demo() {}\"].join(\"\\n\");\n  const comment = createComment(\"*\\n * ok\\n \", [\n    0,\n    sourceText.indexOf(\"*/\") + 2,\n  ]);\n\n  return {\n    comment,\n    node: createFunctionNode(sourceText),\n    sourceCode: createSourceCode(sourceText, [comment]),\n  };\n};\n\n/**\n * Creates a context with a non-JSDoc comment.\n * @returns The lookup context.\n * @example\n * ```typescript\n * const context = createNonJsdocContext();\n * ```\n */\nconst createNonJsdocContext = (): JsdocLookupContext => {\n  const sourceText = \"// line\\nfunction demo() {}\";\n  const comment = {\n    range: [0, 7],\n    type: \"Line\",\n    value: \" line\",\n  } as Comment;\n\n  return {\n    node: createFunctionNode(sourceText),\n    sourceCode: createSourceCode(sourceText, [comment]),\n  };\n};\n\n/**\n * Creates a context with a JSDoc comment missing range data.\n * @returns The lookup context.\n * @example\n * ```typescript\n * const context = createRangeMissingContext();\n * ```\n */\nconst createRangeMissingContext = (): JsdocLookupContext => {\n  const sourceText = \"function demo() {}\";\n  const comment = {\n    type: \"Block\",\n    value: \"*\\n * ok\\n \",\n  } as Comment;\n\n  return {\n    node: createFunctionNode(sourceText),\n    sourceCode: createSourceCode(sourceText, [comment]),\n  };\n};\n\nexport {\n  createComment,\n  createDualJsdocContext,\n  createNonJsdocContext,\n  createRangeMissingContext,\n  createSingleJsdocContext,\n  createSourceCode,\n};\nexport type { Comment };\n"]}

package/dist/{docs → 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";
+import type { Comment, CommentLine } from "./types.js";
 /**
  * Gets the closest JSDoc comment for a node.
  * @param sourceCode Source code wrapper.

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

@@ -0,0 +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,SASZ,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"}