@codeperfect/eslint-plugin 1.0.0

package/dist/docs/no-interface-member-docs/rule.js

@@ -0,0 +1,168 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { buildRemovalRange, getCommentLines, getCommentText, getJsdocComment, } from "./comment-utilities";
+import { parseParameterTagLine } from "./parameter-tags";
+import { getParameterTypeLookup, isNamedTypeReference, } from "./parameter-utilities";
+/**
+ * Checks whether a parameter member tag matches a named type reference.
+ * @param tag Parsed parameter member tag.
+ * @param parameterTypes Parameter type lookup.
+ * @returns True when the tag matches a named type reference.
+ * @example
+ * ```typescript
+ * const ok = isMatchingMemberTag(tag, parameterTypes);
+ * ```
+ */
+const isMatchingMemberTag = (tag, parameterTypes) => {
+    if (tag === void 0) {
+        return false;
+    }
+    const parameterType = parameterTypes.get(tag.baseName);
+    return isNamedTypeReference(parameterType);
+};
+/**
+ * Collects member tags from a JSDoc comment.
+ * @param commentText Full comment text.
+ * @param parameterTypes Parameter type lookup.
+ * @returns Member tags that match named type references.
+ * @example
+ * ```typescript
+ * const tags = collectMemberTags(commentText, parameterTypes);
+ * ```
+ */
+const collectMemberTags = (commentText, parameterTypes) => getCommentLines(commentText)
+    .map((line) => parseParameterTagLine(line))
+    .filter((tag) => isMatchingMemberTag(tag, parameterTypes));
+/**
+ * Reports interface member documentation entries for removal.
+ * @param context Rule execution context.
+ * @param details Collected rule details.
+ * @example
+ * ```typescript
+ * reportMemberDocumentation(context, details);
+ * ```
+ */
+const reportMemberDocumentation = (context, details) => {
+    const { commentStart, commentText, memberTags, node } = details;
+    for (const tag of memberTags) {
+        const removalRange = buildRemovalRange(commentStart, commentText, tag.line);
+        context.report({
+            data: { parameterName: tag.fullName },
+            fix: (fixer) => fixer.removeRange(removalRange),
+            messageId: "interfaceMemberDoc",
+            node,
+        });
+    }
+};
+/**
+ * Gets parameter type references for a node.
+ * @param node Function-like node to inspect.
+ * @returns Parameter type lookup when present.
+ * @example
+ * ```typescript
+ * const lookup = getParameterTypes(node);
+ * ```
+ */
+const getParameterTypes = (node) => {
+    const parameterTypes = getParameterTypeLookup(node);
+    return parameterTypes.size > 0 ? parameterTypes : void 0;
+};
+/**
+ * Resolves the JSDoc comment data for a node.
+ * @param sourceCode SourceCode wrapper.
+ * @param node Node to inspect.
+ * @returns JSDoc data when available.
+ * @example
+ * ```typescript
+ * const data = getJsdocData(sourceCode, node);
+ * ```
+ */
+const getJsdocData = (sourceCode, node) => {
+    const comment = getJsdocComment(sourceCode, node);
+    if (comment === void 0) {
+        return void 0;
+    }
+    const commentStart = comment.range?.[0];
+    if (typeof commentStart !== "number") {
+        return void 0;
+    }
+    const text = getCommentText(sourceCode, comment);
+    return { comment, commentStart, text };
+};
+/**
+ * Resolves the member tag context for a node.
+ * @param context Rule execution context.
+ * @param node Node to inspect.
+ * @returns Member tag context when available.
+ * @example
+ * ```typescript
+ * const context = resolveMemberTagContext(context, node);
+ * ```
+ */
+const resolveMemberTagContext = (context, node) => {
+    const parameterTypes = getParameterTypes(node);
+    const jsdocData = getJsdocData(context.sourceCode, node);
+    if (parameterTypes === void 0 || jsdocData === void 0) {
+        return void 0;
+    }
+    const memberTags = collectMemberTags(jsdocData.text, parameterTypes);
+    return memberTags.length > 0
+        ? {
+            comment: jsdocData.comment,
+            commentStart: jsdocData.commentStart,
+            commentText: jsdocData.text,
+            memberTags,
+        }
+        : void 0;
+};
+/**
+ * Handles function-like nodes for this rule.
+ * @param context Rule execution context.
+ * @param node Node to inspect.
+ * @example
+ * ```typescript
+ * handleFunctionLike(context, node);
+ * ```
+ */
+const handleFunctionLike = (context, node) => {
+    const resolved = resolveMemberTagContext(context, node);
+    if (resolved === void 0) {
+        return;
+    }
+    reportMemberDocumentation(context, {
+        comment: resolved.comment,
+        commentStart: resolved.commentStart,
+        commentText: resolved.commentText,
+        memberTags: resolved.memberTags,
+        node,
+        sourceCode: context.sourceCode,
+    });
+};
+/** ESLint rule disallowing interface member documentation in `@param` tags. */
+const noInterfaceMemberDocumentationRule = {
+    create(context) {
+        const listener = (node) => {
+            handleFunctionLike(context, node);
+        };
+        return {
+            ArrowFunctionExpression: listener,
+            FunctionDeclaration: listener,
+            FunctionExpression: listener,
+            TSCallSignatureDeclaration: listener,
+            TSConstructSignatureDeclaration: listener,
+            TSDeclareFunction: listener,
+            TSFunctionType: listener,
+            TSMethodSignature: listener,
+        };
+    },
+    meta: {
+        docs: createRuleDocumentation("no-interface-member-docs", "Disallow documenting interface members in @param tags; document them on the interface instead."),
+        fixable: "code",
+        messages: {
+            interfaceMemberDoc: "Document interface members on the interface instead of using @param for {{parameterName}}.",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { noInterfaceMemberDocumentationRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/docs/no-interface-member-docs/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Comment, ParameterMemberTag, TypeAnnotationNode } from \"./types\";\n\nimport { createRuleDocumentation } from \"../../custom-rule-documentation\";\nimport {\n  buildRemovalRange,\n  getCommentLines,\n  getCommentText,\n  getJsdocComment,\n} from \"./comment-utilities\";\nimport { parseParameterTagLine } from \"./parameter-tags\";\nimport {\n  getParameterTypeLookup,\n  isNamedTypeReference,\n} from \"./parameter-utilities\";\n\n/** Type definition for rule data. */\ninterface ReportMemberDocumentationContext {\n  /** Comment field value. */\n  comment: Comment;\n\n  /** CommentStart field value. */\n  commentStart: number;\n\n  /** CommentText field value. */\n  commentText: string;\n\n  /** MemberTags field value. */\n  memberTags: ParameterMemberTag[];\n\n  /** Node field value. */\n  node: Rule.Node;\n\n  /** SourceCode field value. */\n  sourceCode: Rule.RuleContext[\"sourceCode\"];\n}\n\n/**\n * Checks whether a parameter member tag matches a named type reference.\n * @param tag Parsed parameter member tag.\n * @param parameterTypes Parameter type lookup.\n * @returns True when the tag matches a named type reference.\n * @example\n * ```typescript\n * const ok = isMatchingMemberTag(tag, parameterTypes);\n * ```\n */\nconst isMatchingMemberTag = (\n  tag: ParameterMemberTag | undefined,\n  parameterTypes: Map<string, TypeAnnotationNode>,\n): tag is ParameterMemberTag => {\n  if (tag === void 0) {\n    return false;\n  }\n\n  const parameterType = parameterTypes.get(tag.baseName);\n\n  return isNamedTypeReference(parameterType);\n};\n\n/**\n * Collects member tags from a JSDoc comment.\n * @param commentText Full comment text.\n * @param parameterTypes Parameter type lookup.\n * @returns Member tags that match named type references.\n * @example\n * ```typescript\n * const tags = collectMemberTags(commentText, parameterTypes);\n * ```\n */\nconst collectMemberTags = (\n  commentText: string,\n  parameterTypes: Map<string, TypeAnnotationNode>,\n): ParameterMemberTag[] =>\n  getCommentLines(commentText)\n    .map((line) => parseParameterTagLine(line))\n    .filter((tag) => isMatchingMemberTag(tag, parameterTypes));\n\n/**\n * Reports interface member documentation entries for removal.\n * @param context Rule execution context.\n * @param details Collected rule details.\n * @example\n * ```typescript\n * reportMemberDocumentation(context, details);\n * ```\n */\nconst reportMemberDocumentation = (\n  context: Rule.RuleContext,\n  details: ReportMemberDocumentationContext,\n): void => {\n  const { commentStart, commentText, memberTags, node } = details;\n\n  for (const tag of memberTags) {\n    const removalRange = buildRemovalRange(commentStart, commentText, tag.line);\n\n    context.report({\n      data: { parameterName: tag.fullName },\n      fix: (fixer: Rule.RuleFixer): Rule.Fix => fixer.removeRange(removalRange),\n      messageId: \"interfaceMemberDoc\",\n      node,\n    });\n  }\n};\n\n/**\n * Gets parameter type references for a node.\n * @param node Function-like node to inspect.\n * @returns Parameter type lookup when present.\n * @example\n * ```typescript\n * const lookup = getParameterTypes(node);\n * ```\n */\nconst getParameterTypes = (\n  node: Rule.Node,\n): Map<string, TypeAnnotationNode> | undefined => {\n  const parameterTypes = getParameterTypeLookup(node);\n\n  return parameterTypes.size > 0 ? parameterTypes : void 0;\n};\n\n/**\n * Resolves the JSDoc comment data for a node.\n * @param sourceCode SourceCode wrapper.\n * @param node Node to inspect.\n * @returns JSDoc data when available.\n * @example\n * ```typescript\n * const data = getJsdocData(sourceCode, node);\n * ```\n */\nconst getJsdocData = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  node: Rule.Node,\n):\n  | undefined\n  | {\n      /** Comment field value. */\n      comment: Comment;\n\n      /** CommentStart field value. */\n      commentStart: number;\n\n      /** Text field value. */\n      text: string;\n    } => {\n  const comment = getJsdocComment(sourceCode, node);\n\n  if (comment === void 0) {\n    return void 0;\n  }\n\n  const commentStart = comment.range?.[0];\n\n  if (typeof commentStart !== \"number\") {\n    return void 0;\n  }\n\n  const text = getCommentText(sourceCode, comment);\n\n  return { comment, commentStart, text };\n};\n\n/**\n * Resolves the member tag context for a node.\n * @param context Rule execution context.\n * @param node Node to inspect.\n * @returns Member tag context when available.\n * @example\n * ```typescript\n * const context = resolveMemberTagContext(context, node);\n * ```\n */\nconst resolveMemberTagContext = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n):\n  | undefined\n  | {\n      /** Comment field value. */\n      comment: Comment;\n\n      /** CommentStart field value. */\n      commentStart: number;\n\n      /** CommentText field value. */\n      commentText: string;\n\n      /** MemberTags field value. */\n      memberTags: ParameterMemberTag[];\n    } => {\n  const parameterTypes = getParameterTypes(node);\n  const jsdocData = getJsdocData(context.sourceCode, node);\n\n  if (parameterTypes === void 0 || jsdocData === void 0) {\n    return void 0;\n  }\n\n  const memberTags = collectMemberTags(jsdocData.text, parameterTypes);\n\n  return memberTags.length > 0\n    ? {\n        comment: jsdocData.comment,\n        commentStart: jsdocData.commentStart,\n        commentText: jsdocData.text,\n        memberTags,\n      }\n    : void 0;\n};\n\n/**\n * Handles function-like nodes for this rule.\n * @param context Rule execution context.\n * @param node Node to inspect.\n * @example\n * ```typescript\n * handleFunctionLike(context, node);\n * ```\n */\nconst handleFunctionLike = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  const resolved = resolveMemberTagContext(context, node);\n\n  if (resolved === void 0) {\n    return;\n  }\n\n  reportMemberDocumentation(context, {\n    comment: resolved.comment,\n    commentStart: resolved.commentStart,\n    commentText: resolved.commentText,\n    memberTags: resolved.memberTags,\n    node,\n    sourceCode: context.sourceCode,\n  });\n};\n\n/** ESLint rule disallowing interface member documentation in `@param` tags. */\nconst noInterfaceMemberDocumentationRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    const listener = (node: Rule.Node): void => {\n      handleFunctionLike(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      \"no-interface-member-docs\",\n      \"Disallow documenting interface members in @param tags; document them on the interface instead.\",\n    ),\n    fixable: \"code\",\n    messages: {\n      interfaceMemberDoc:\n        \"Document interface members on the interface instead of using @param for {{parameterName}}.\",\n    },\n    schema: [],\n    type: \"problem\",\n  },\n};\n\nexport { noInterfaceMemberDocumentationRule };\n"]}

package/dist/docs/no-interface-member-docs/test-helpers.d.ts

@@ -0,0 +1,103 @@
+import type { Rule } from "eslint";
+/** Type definition for rule data. */
+type Comment = ReturnType<Rule.RuleContext["sourceCode"]["getAllComments"]>[number];
+/** Type definition for rule data. */
+interface InterfaceSample {
+    /** Context field value. */
+    context: Rule.RuleContext;
+    /** Node field value. */
+    node: Rule.Node;
+    /** Reports field value. */
+    reports: ReportEntry[];
+    /** SourceText field value. */
+    sourceText: string;
+}
+/** Type definition for rule data. */
+interface ReportEntry {
+    /** Fix helper value. */
+    fix?: null | Rule.ReportFixer | undefined;
+    /** MessageId helper value. */
+    messageId: string | undefined;
+}
+/** Type definition for rule data. */
+interface RuleContextState {
+    /** Context field value. */
+    context: Rule.RuleContext;
+    /** Reports field value. */
+    reports: ReportEntry[];
+}
+/**
+ * Creates a rule context state for the given source text.
+ * @param sourceText Source text to analyze.
+ * @param comments Comment nodes for the source.
+ * @returns Context state for tests.
+ * @example
+ * ```typescript
+ * const state = createContext("", []);
+ * ```
+ */
+declare const createContext: (sourceText: string, comments: Comment[]) => RuleContextState;
+/**
+ * Creates a JSDoc block comment for the given source text.
+ * @param commentValue Comment value without delimiters.
+ * @param sourceText Source text containing the comment.
+ * @returns Comment node for the source text.
+ * @example
+ * ```typescript
+ * const comment = createComment("*\n * ok\n ", "function demo() {}");
+ * ```
+ */
+declare const createComment: (commentValue: string, sourceText: string) => Comment;
+/**
+ * Creates a function node for the given source text.
+ * @param sourceText Source text containing the function.
+ * @param parameters Parameter nodes for the function.
+ * @returns Function declaration node.
+ * @example
+ * ```typescript
+ * const node = createFunctionNode("function demo() {}", []);
+ * ```
+ */
+declare const createFunctionNode: (sourceText: string, parameters: unknown[]) => Rule.Node;
+/**
+ * Creates a parameter node with a type annotation.
+ * @param type Type annotation kind to assign.
+ * @returns Parameter node for tests.
+ * @example
+ * ```typescript
+ * const param = createParameter("TSTypeReference");
+ * ```
+ */
+declare const createParameter: (type: string) => unknown;
+/**
+ * Runs the rule listener for a function declaration node.
+ * @param context Rule execution context.
+ * @param node Function node to inspect.
+ * @example
+ * ```typescript
+ * runFunctionListener(context, node);
+ * ```
+ */
+declare const runFunctionListener: (context: Rule.RuleContext, node: Rule.Node) => void;
+/**
+ * Builds source text with a leading JSDoc comment.
+ * @param commentValue Comment value used in the source.
+ * @returns Source text containing the comment and function.
+ * @example
+ * ```typescript
+ * const text = buildSourceText("*\n * ok\n ");
+ * ```
+ */
+declare const buildSourceText: (commentValue: string) => string;
+/**
+ * Creates a sample test fixture for interface member docs.
+ * @returns Sample context, node, and reports.
+ * @example
+ * ```typescript
+ * const sample = createInterfaceSample();
+ * ```
+ */
+declare const createInterfaceSample: () => InterfaceSample;
+export { buildSourceText, createComment, createContext, createFunctionNode, createInterfaceSample, createParameter, runFunctionListener, };
+export type { Comment };
+//# sourceMappingURL=test-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../../src/docs/no-interface-member-docs/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAInC,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,eAAe;IACvB,2BAA2B;IAC3B,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC;IAE1B,wBAAwB;IACxB,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;IAEhB,2BAA2B;IAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;IAEvB,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAC;CACpB;AAWD,qCAAqC;AACrC,UAAU,WAAW;IACnB,wBAAwB;IACxB,GAAG,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;IAE1C,8BAA8B;IAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,qCAAqC;AACrC,UAAU,gBAAgB;IACxB,2BAA2B;IAC3B,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC;IAE1B,2BAA2B;IAC3B,OAAO,EAAE,WAAW,EAAE,CAAC;CACxB;AA+CD;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,GACjB,YAAY,MAAM,EAClB,UAAU,OAAO,EAAE,KAClB,gBAKF,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,GAAI,cAAc,MAAM,EAAE,YAAY,MAAM,KAAG,OAQjE,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,kBAAkB,GACtB,YAAY,MAAM,EAClB,YAAY,OAAO,EAAE,KACpB,IAAI,CAAC,IAKS,CAAC;AAElB;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,OAMtC,CAAC;AAEH;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GACvB,SAAS,IAAI,CAAC,WAAW,EACzB,MAAM,IAAI,CAAC,IAAI,KACd,IAOF,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe,GAAI,cAAc,MAAM,KAAG,MAMlC,CAAC;AAEf;;;;;;;GAOG;AACH,QAAA,MAAM,qBAAqB,QAAO,eAmBjC,CAAC;AAEF,OAAO,EACL,eAAe,EACf,aAAa,EACb,aAAa,EACb,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,GACpB,CAAC;AACF,YAAY,EAAE,OAAO,EAAE,CAAC"}

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

@@ -0,0 +1,157 @@
+import { noInterfaceMemberDocumentationRule } from "./rule";
+/**
+ * Creates a SourceCode stub with the provided comments.
+ * @param text Source text to attach.
+ * @param comments Comment nodes to expose.
+ * @returns SourceCode stub for tests.
+ * @example
+ * ```typescript
+ * const sourceCode = createSourceCode("", []);
+ * ```
+ */
+const createSourceCode = (text, comments) => ({
+    getAllComments: () => comments,
+    text,
+});
+/**
+ * Builds a rule context for collecting reports.
+ * @param sourceCode SourceCode stub.
+ * @param reports Report sink.
+ * @returns Rule context that records reports.
+ * @example
+ * ```typescript
+ * const context = buildRuleContext(sourceCode, reports);
+ * ```
+ */
+const buildRuleContext = (sourceCode, reports) => ({
+    id: "no-interface-member-docs",
+    options: [],
+    report: (descriptor) => {
+        const { fix, messageId } = descriptor;
+        const entry = { fix, messageId };
+        reports.push(entry);
+    },
+    sourceCode,
+});
+/**
+ * Creates a rule context state for the given source text.
+ * @param sourceText Source text to analyze.
+ * @param comments Comment nodes for the source.
+ * @returns Context state for tests.
+ * @example
+ * ```typescript
+ * const state = createContext("", []);
+ * ```
+ */
+const createContext = (sourceText, comments) => {
+    const reports = [];
+    const sourceCode = createSourceCode(sourceText, comments);
+    return { context: buildRuleContext(sourceCode, reports), reports };
+};
+/**
+ * Creates a JSDoc block comment for the given source text.
+ * @param commentValue Comment value without delimiters.
+ * @param sourceText Source text containing the comment.
+ * @returns Comment node for the source text.
+ * @example
+ * ```typescript
+ * const comment = createComment("*\n * ok\n ", "function demo() {}");
+ * ```
+ */
+const createComment = (commentValue, sourceText) => {
+    const end = sourceText.indexOf("*/") + 2;
+    return {
+        range: [0, end],
+        type: "Block",
+        value: commentValue,
+    };
+};
+/**
+ * Creates a function node for the given source text.
+ * @param sourceText Source text containing the function.
+ * @param parameters Parameter nodes for the function.
+ * @returns Function declaration node.
+ * @example
+ * ```typescript
+ * const node = createFunctionNode("function demo() {}", []);
+ * ```
+ */
+const createFunctionNode = (sourceText, parameters) => ({
+    params: parameters,
+    range: [sourceText.indexOf("function"), sourceText.length],
+    type: "FunctionDeclaration",
+});
+/**
+ * Creates a parameter node with a type annotation.
+ * @param type Type annotation kind to assign.
+ * @returns Parameter node for tests.
+ * @example
+ * ```typescript
+ * const param = createParameter("TSTypeReference");
+ * ```
+ */
+const createParameter = (type) => ({
+    name: "context",
+    type: "Identifier",
+    typeAnnotation: {
+        typeAnnotation: { type },
+    },
+});
+/**
+ * Runs the rule listener for a function declaration node.
+ * @param context Rule execution context.
+ * @param node Function node to inspect.
+ * @example
+ * ```typescript
+ * runFunctionListener(context, node);
+ * ```
+ */
+const runFunctionListener = (context, node) => {
+    const listeners = noInterfaceMemberDocumentationRule.create(context);
+    const listener = listeners.FunctionDeclaration;
+    listener?.(node);
+};
+/**
+ * Builds source text with a leading JSDoc comment.
+ * @param commentValue Comment value used in the source.
+ * @returns Source text containing the comment and function.
+ * @example
+ * ```typescript
+ * const text = buildSourceText("*\n * ok\n ");
+ * ```
+ */
+const buildSourceText = (commentValue) => [
+    "/**",
+    commentValue.trimEnd(),
+    "*/",
+    "function getLineMeta(context: LineMetaContext): void {}",
+].join("\n");
+/**
+ * Creates a sample test fixture for interface member docs.
+ * @returns Sample context, node, and reports.
+ * @example
+ * ```typescript
+ * const sample = createInterfaceSample();
+ * ```
+ */
+const createInterfaceSample = () => {
+    const commentValue = [
+        "*",
+        " * Compute line metadata from the raw comment value.",
+        " * @param context The metadata context.",
+        " * @param context.commentValue The full comment value.",
+        " * @param context.full The full matched example text.",
+        " * @param context.startOffset The match start offset.",
+        " * @returns The line metadata for the example.",
+        " ",
+    ].join("\n");
+    const sourceText = buildSourceText(commentValue);
+    const comment = createComment(commentValue, sourceText);
+    const { context, reports } = createContext(sourceText, [comment]);
+    const node = createFunctionNode(sourceText, [
+        createParameter("TSTypeReference"),
+    ]);
+    return { context, node, reports, sourceText };
+};
+export { buildSourceText, createComment, createContext, createFunctionNode, createInterfaceSample, createParameter, runFunctionListener, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-helpers.js","sourceRoot":"","sources":["../../../src/docs/no-interface-member-docs/test-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport { noInterfaceMemberDocumentationRule } from \"./rule\";\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 InterfaceSample {\n  /** Context field value. */\n  context: Rule.RuleContext;\n\n  /** Node field value. */\n  node: Rule.Node;\n\n  /** Reports field value. */\n  reports: ReportEntry[];\n\n  /** SourceText field value. */\n  sourceText: string;\n}\n\n/** Type definition for rule data. */\ninterface ReportDescriptorDetails {\n  /** Fix field value. */\n  fix?: null | Rule.ReportFixer | undefined;\n\n  /** MessageId field value. */\n  messageId?: string;\n}\n\n/** Type definition for rule data. */\ninterface ReportEntry {\n  /** Fix helper value. */\n  fix?: null | Rule.ReportFixer | undefined;\n\n  /** MessageId helper value. */\n  messageId: 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/**\n * Creates a SourceCode stub with the provided comments.\n * @param text Source text to attach.\n * @param comments Comment nodes to expose.\n * @returns SourceCode stub for tests.\n * @example\n * ```typescript\n * const sourceCode = createSourceCode(\"\", []);\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 * Builds a rule context for collecting reports.\n * @param sourceCode SourceCode stub.\n * @param reports Report sink.\n * @returns Rule context that records reports.\n * @example\n * ```typescript\n * const context = buildRuleContext(sourceCode, reports);\n * ```\n */\nconst buildRuleContext = (\n  sourceCode: Rule.RuleContext[\"sourceCode\"],\n  reports: ReportEntry[],\n): Rule.RuleContext =>\n  ({\n    id: \"no-interface-member-docs\",\n    options: [],\n    report: (descriptor: Rule.ReportDescriptor): void => {\n      const { fix, messageId } = descriptor as ReportDescriptorDetails;\n      const entry: ReportEntry = { fix, messageId };\n\n      reports.push(entry);\n    },\n    sourceCode,\n  }) as unknown as Rule.RuleContext;\n\n/**\n * Creates a rule context state for the given source text.\n * @param sourceText Source text to analyze.\n * @param comments Comment nodes for the source.\n * @returns Context state for tests.\n * @example\n * ```typescript\n * const state = createContext(\"\", []);\n * ```\n */\nconst createContext = (\n  sourceText: string,\n  comments: Comment[],\n): RuleContextState => {\n  const reports: ReportEntry[] = [];\n  const sourceCode = createSourceCode(sourceText, comments);\n\n  return { context: buildRuleContext(sourceCode, reports), reports };\n};\n\n/**\n * Creates a JSDoc block comment for the given source text.\n * @param commentValue Comment value without delimiters.\n * @param sourceText Source text containing the comment.\n * @returns Comment node for the source text.\n * @example\n * ```typescript\n * const comment = createComment(\"*\\n * ok\\n \", \"function demo() {}\");\n * ```\n */\nconst createComment = (commentValue: string, sourceText: string): Comment => {\n  const end = sourceText.indexOf(\"*/\") + 2;\n\n  return {\n    range: [0, end],\n    type: \"Block\",\n    value: commentValue,\n  } as Comment;\n};\n\n/**\n * Creates a function node for the given source text.\n * @param sourceText Source text containing the function.\n * @param parameters Parameter nodes for the function.\n * @returns Function declaration node.\n * @example\n * ```typescript\n * const node = createFunctionNode(\"function demo() {}\", []);\n * ```\n */\nconst createFunctionNode = (\n  sourceText: string,\n  parameters: unknown[],\n): Rule.Node =>\n  ({\n    params: parameters,\n    range: [sourceText.indexOf(\"function\"), sourceText.length],\n    type: \"FunctionDeclaration\",\n  }) as Rule.Node;\n\n/**\n * Creates a parameter node with a type annotation.\n * @param type Type annotation kind to assign.\n * @returns Parameter node for tests.\n * @example\n * ```typescript\n * const param = createParameter(\"TSTypeReference\");\n * ```\n */\nconst createParameter = (type: string): unknown => ({\n  name: \"context\",\n  type: \"Identifier\",\n  typeAnnotation: {\n    typeAnnotation: { type },\n  },\n});\n\n/**\n * Runs the rule listener for a function declaration node.\n * @param context Rule execution context.\n * @param node Function node to inspect.\n * @example\n * ```typescript\n * runFunctionListener(context, node);\n * ```\n */\nconst runFunctionListener = (\n  context: Rule.RuleContext,\n  node: Rule.Node,\n): void => {\n  const listeners = noInterfaceMemberDocumentationRule.create(context);\n  const listener = listeners.FunctionDeclaration as\n    | ((node: Rule.Node) => void)\n    | undefined;\n\n  listener?.(node);\n};\n\n/**\n * Builds source text with a leading JSDoc comment.\n * @param commentValue Comment value used in the source.\n * @returns Source text containing the comment and function.\n * @example\n * ```typescript\n * const text = buildSourceText(\"*\\n * ok\\n \");\n * ```\n */\nconst buildSourceText = (commentValue: string): string =>\n  [\n    \"/**\",\n    commentValue.trimEnd(),\n    \"*/\",\n    \"function getLineMeta(context: LineMetaContext): void {}\",\n  ].join(\"\\n\");\n\n/**\n * Creates a sample test fixture for interface member docs.\n * @returns Sample context, node, and reports.\n * @example\n * ```typescript\n * const sample = createInterfaceSample();\n * ```\n */\nconst createInterfaceSample = (): InterfaceSample => {\n  const commentValue = [\n    \"*\",\n    \" * Compute line metadata from the raw comment value.\",\n    \" * @param context The metadata context.\",\n    \" * @param context.commentValue The full comment value.\",\n    \" * @param context.full The full matched example text.\",\n    \" * @param context.startOffset The match start offset.\",\n    \" * @returns The line metadata for the example.\",\n    \" \",\n  ].join(\"\\n\");\n  const sourceText = buildSourceText(commentValue);\n  const comment = createComment(commentValue, sourceText);\n  const { context, reports } = createContext(sourceText, [comment]);\n  const node = createFunctionNode(sourceText, [\n    createParameter(\"TSTypeReference\"),\n  ]);\n\n  return { context, node, reports, sourceText };\n};\n\nexport {\n  buildSourceText,\n  createComment,\n  createContext,\n  createFunctionNode,\n  createInterfaceSample,\n  createParameter,\n  runFunctionListener,\n};\nexport type { Comment };\n"]}

package/dist/docs/no-interface-member-docs/types.d.ts

@@ -0,0 +1,30 @@
+import type { Rule } from "eslint";
+/** Type definition for rule data. */
+type Comment = ReturnType<Rule.RuleContext["sourceCode"]["getAllComments"]>[number];
+/** Type definition for rule data. */
+interface CommentLine {
+    /** End field value. */
+    end: number;
+    /** LineBreakLength field value. */
+    lineBreakLength: number;
+    /** Start field value. */
+    start: number;
+    /** Text field value. */
+    text: string;
+}
+/** Type definition for rule data. */
+interface ParameterMemberTag {
+    /** BaseName field value. */
+    baseName: string;
+    /** FullName field value. */
+    fullName: string;
+    /** Line field value. */
+    line: CommentLine;
+}
+/** Type definition for rule data. */
+interface TypeAnnotationNode {
+    /** Type field value. */
+    type: string;
+}
+export type { Comment, CommentLine, ParameterMemberTag, TypeAnnotationNode };
+//# sourceMappingURL=types.d.ts.map

package/dist/docs/no-interface-member-docs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/docs/no-interface-member-docs/types.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,WAAW;IACnB,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;IAEZ,mCAAmC;IACnC,eAAe,EAAE,MAAM,CAAC;IAExB,yBAAyB;IACzB,KAAK,EAAE,MAAM,CAAC;IAEd,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,qCAAqC;AACrC,UAAU,kBAAkB;IAC1B,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,wBAAwB;IACxB,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,qCAAqC;AACrC,UAAU,kBAAkB;IAC1B,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,YAAY,EAAE,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/docs/no-interface-member-docs/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9jcy9uby1pbnRlcmZhY2UtbWVtYmVyLWRvY3MvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgUnVsZSB9IGZyb20gXCJlc2xpbnRcIjtcblxuLyoqIFR5cGUgZGVmaW5pdGlvbiBmb3IgcnVsZSBkYXRhLiAqL1xudHlwZSBDb21tZW50ID0gUmV0dXJuVHlwZTxcbiAgUnVsZS5SdWxlQ29udGV4dFtcInNvdXJjZUNvZGVcIl1bXCJnZXRBbGxDb21tZW50c1wiXVxuPltudW1iZXJdO1xuXG4vKiogVHlwZSBkZWZpbml0aW9uIGZvciBydWxlIGRhdGEuICovXG5pbnRlcmZhY2UgQ29tbWVudExpbmUge1xuICAvKiogRW5kIGZpZWxkIHZhbHVlLiAqL1xuICBlbmQ6IG51bWJlcjtcblxuICAvKiogTGluZUJyZWFrTGVuZ3RoIGZpZWxkIHZhbHVlLiAqL1xuICBsaW5lQnJlYWtMZW5ndGg6IG51bWJlcjtcblxuICAvKiogU3RhcnQgZmllbGQgdmFsdWUuICovXG4gIHN0YXJ0OiBudW1iZXI7XG5cbiAgLyoqIFRleHQgZmllbGQgdmFsdWUuICovXG4gIHRleHQ6IHN0cmluZztcbn1cblxuLyoqIFR5cGUgZGVmaW5pdGlvbiBmb3IgcnVsZSBkYXRhLiAqL1xuaW50ZXJmYWNlIFBhcmFtZXRlck1lbWJlclRhZyB7XG4gIC8qKiBCYXNlTmFtZSBmaWVsZCB2YWx1ZS4gKi9cbiAgYmFzZU5hbWU6IHN0cmluZztcblxuICAvKiogRnVsbE5hbWUgZmllbGQgdmFsdWUuICovXG4gIGZ1bGxOYW1lOiBzdHJpbmc7XG5cbiAgLyoqIExpbmUgZmllbGQgdmFsdWUuICovXG4gIGxpbmU6IENvbW1lbnRMaW5lO1xufVxuXG4vKiogVHlwZSBkZWZpbml0aW9uIGZvciBydWxlIGRhdGEuICovXG5pbnRlcmZhY2UgVHlwZUFubm90YXRpb25Ob2RlIHtcbiAgLyoqIFR5cGUgZmllbGQgdmFsdWUuICovXG4gIHR5cGU6IHN0cmluZztcbn1cblxuZXhwb3J0IHR5cGUgeyBDb21tZW50LCBDb21tZW50TGluZSwgUGFyYW1ldGVyTWVtYmVyVGFnLCBUeXBlQW5ub3RhdGlvbk5vZGUgfTtcbiJdfQ==

package/dist/docs/require-example-language/empty-fence-fixes.d.ts

@@ -0,0 +1,29 @@
+/** Type definition for rule data. */
+interface FenceLineInfo {
+    /** Language field value. */
+    language: string;
+    /** Leading field value. */
+    leading: string;
+}
+/**
+ * Parses a fence line for its leading prefix and language.
+ * @param line Fence line to parse.
+ * @returns Parsed fence info when matched.
+ * @example
+ * ```typescript
+ * const info = parseFenceLine(" * ```typescript");
+ * ```
+ */
+declare function parseFenceLine(line: string): FenceLineInfo | undefined;
+/**
+ * Removes fenced blocks that contain no content.
+ * @param original Original comment text.
+ * @returns Updated comment text when a fence is removed.
+ * @example
+ * ```typescript
+ * const updated = removeEmptyFences("* ```typescript\n* ```\n* ok");
+ * ```
+ */
+declare function removeEmptyFences(original: string): string | undefined;
+export { parseFenceLine, removeEmptyFences };
+//# sourceMappingURL=empty-fence-fixes.d.ts.map

package/dist/docs/require-example-language/empty-fence-fixes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empty-fence-fixes.d.ts","sourceRoot":"","sources":["../../../src/docs/require-example-language/empty-fence-fixes.ts"],"names":[],"mappings":"AAqBA,qCAAqC;AACrC,UAAU,aAAa;IACrB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAC;CACjB;AAuFD;;;;;;;;GAQG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAe/D;AAED;;;;;;;;GAQG;AACH,iBAAS,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA0B/D;AAgDD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,CAAC"}