@codeperfect/eslint-plugin 1.0.0

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

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

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

@@ -0,0 +1,2 @@
+export { noInterfaceMemberDocumentationRule } from "./rule";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/docs/no-interface-member-docs/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kCAAkC,EAAE,MAAM,QAAQ,CAAC"}

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

@@ -0,0 +1,2 @@
+export { noInterfaceMemberDocumentationRule } from "./rule";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZG9jcy9uby1pbnRlcmZhY2UtbWVtYmVyLWRvY3MvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGtDQUFrQyxFQUFFLE1BQU0sUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgbm9JbnRlcmZhY2VNZW1iZXJEb2N1bWVudGF0aW9uUnVsZSB9IGZyb20gXCIuL3J1bGVcIjtcbiJdfQ==

package/dist/docs/no-interface-member-docs/parameter-tags.d.ts

@@ -0,0 +1,13 @@
+import type { CommentLine, ParameterMemberTag } from "./types";
+/**
+ * Parses a `@param` tag line into a member tag when applicable.
+ * @param line Comment line metadata.
+ * @returns Parsed parameter member tag when present.
+ * @example
+ * ```typescript
+ * const tag = parseParameterTagLine(line);
+ * ```
+ */
+declare const parseParameterTagLine: (line: CommentLine) => ParameterMemberTag | undefined;
+export { parseParameterTagLine };
+//# sourceMappingURL=parameter-tags.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-tags.d.ts","sourceRoot":"","sources":["../../../src/docs/no-interface-member-docs/parameter-tags.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAoG/D;;;;;;;;GAQG;AACH,QAAA,MAAM,qBAAqB,GACzB,MAAM,WAAW,KAChB,kBAAkB,GAAG,SAmBvB,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/docs/no-interface-member-docs/parameter-tags.js

@@ -0,0 +1,101 @@
+/** Extracts the parameter name from an `@param` tag line. */
+const parameterTagPattern = /@param\s+(?:\{[^}]*\}\s+)?(?<name>[^\s-]+)/u;
+/**
+ * Defines stripJsdocLine.
+ * @param line Input line value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * stripJsdocLine();
+ * ```
+ */
+const stripJsdocLine = (line) => line.replace(/^\s*\/?\**\s?/u, "").trim();
+/**
+ * Defines stripDefaultValue.
+ * @param rawName Input rawName value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * stripDefaultValue();
+ * ```
+ */
+const stripDefaultValue = (rawName) => {
+    const [head = ""] = rawName.split("=");
+    return head;
+};
+/**
+ * Normalizes normalizeParameterName.
+ * @param rawName Input rawName value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * normalizeParameterName();
+ * ```
+ */
+const normalizeParameterName = (rawName) => stripDefaultValue(rawName)
+    .replace(/^\[/u, "")
+    .replace(/\]$/u, "")
+    .replace(/\?$/u, "");
+/**
+ * Gets getParameterName.
+ * @param content Input content value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getParameterName();
+ * ```
+ */
+const getParameterName = (content) => {
+    if (!content.startsWith("@param")) {
+        return void 0;
+    }
+    const match = parameterTagPattern.exec(content);
+    const rawName = match?.groups?.["name"] ?? "";
+    const normalized = normalizeParameterName(rawName);
+    return normalized.length > 0 ? normalized : void 0;
+};
+/**
+ * Extracts member path details from a normalized parameter name.
+ * @param normalized Normalized parameter name.
+ * @returns Member path details when available.
+ * @example
+ * ```typescript
+ * const member = getMemberName("props.title");
+ * ```
+ */
+const getMemberName = (normalized) => {
+    const dotIndex = normalized.indexOf(".");
+    if (dotIndex <= 0) {
+        return void 0;
+    }
+    const baseName = normalized.slice(0, dotIndex);
+    const memberPath = normalized.slice(dotIndex + 1).trim();
+    return memberPath.length > 0 ? { baseName, memberPath } : void 0;
+};
+/**
+ * Parses a `@param` tag line into a member tag when applicable.
+ * @param line Comment line metadata.
+ * @returns Parsed parameter member tag when present.
+ * @example
+ * ```typescript
+ * const tag = parseParameterTagLine(line);
+ * ```
+ */
+const parseParameterTagLine = (line) => {
+    const content = stripJsdocLine(line.text);
+    const normalized = getParameterName(content);
+    if (normalized === void 0) {
+        return void 0;
+    }
+    const member = getMemberName(normalized);
+    if (member === void 0) {
+        return void 0;
+    }
+    return {
+        baseName: member.baseName,
+        fullName: normalized,
+        line,
+    };
+};
+export { parseParameterTagLine };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,24 @@
+import type { Rule } from "eslint";
+import type { TypeAnnotationNode } from "./types";
+/**
+ * Builds a lookup of parameter names to type annotations.
+ * @param node Function-like node.
+ * @returns Lookup of parameter names to annotations.
+ * @example
+ * ```typescript
+ * const lookup = getParameterTypeLookup(node);
+ * ```
+ */
+declare const getParameterTypeLookup: (node: Rule.Node) => Map<string, TypeAnnotationNode>;
+/**
+ * Checks whether a type annotation is a named type reference.
+ * @param typeAnnotation Type annotation to inspect.
+ * @returns True when the annotation is a named reference.
+ * @example
+ * ```typescript
+ * const ok = isNamedTypeReference(annotation);
+ * ```
+ */
+declare const isNamedTypeReference: (typeAnnotation: TypeAnnotationNode | undefined) => boolean;
+export { getParameterTypeLookup, isNamedTypeReference };
+//# sourceMappingURL=parameter-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-utilities.d.ts","sourceRoot":"","sources":["../../../src/docs/no-interface-member-docs/parameter-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AA0KlD;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB,GAC1B,MAAM,IAAI,CAAC,IAAI,KACd,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAYhC,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,oBAAoB,GACxB,gBAAgB,kBAAkB,GAAG,SAAS,KAC7C,OAAqD,CAAC;AAEzD,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/docs/no-interface-member-docs/parameter-utilities.js

@@ -0,0 +1,125 @@
+/**
+ * Gets a type annotation node from an identifier.
+ * @param node Identifier node to inspect.
+ * @returns The type annotation node when present.
+ * @example
+ * ```typescript
+ * const annotation = getTypeAnnotationNode(identifier);
+ * ```
+ */
+const getTypeAnnotationNode = (node) => node.typeAnnotation?.typeAnnotation;
+/**
+ * Defines resolveParameterNode.
+ * @param node Input node value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * resolveParameterNode();
+ * ```
+ */
+const resolveParameterNode = (node) => {
+    if (node === null || typeof node !== "object") {
+        return node;
+    }
+    const container = node;
+    if (container.argument !== void 0) {
+        return container.argument;
+    }
+    if (container.parameter !== void 0) {
+        return container.parameter;
+    }
+    if (container.type === "AssignmentPattern" && container.left !== void 0) {
+        return container.left;
+    }
+    return node;
+};
+/**
+ * Gets the parameter identifier for a parameter node.
+ * @param node Parameter node to inspect.
+ * @returns The identifier node when present.
+ * @example
+ * ```typescript
+ * const identifier = getParameterIdentifier(node);
+ * ```
+ */
+const getParameterIdentifier = (node) => {
+    const resolved = resolveParameterNode(node);
+    if (resolved === null || typeof resolved !== "object") {
+        return void 0;
+    }
+    const identifier = resolved;
+    const { name } = identifier;
+    if (identifier.type !== "Identifier" || typeof name !== "string") {
+        return void 0;
+    }
+    return { ...identifier, name };
+};
+/**
+ * Gets parameter info for the given node.
+ * @param node Parameter node to inspect.
+ * @returns Parameter info when available.
+ * @example
+ * ```typescript
+ * const info = getParameterInfo(node);
+ * ```
+ */
+const getParameterInfo = (node) => {
+    const identifier = getParameterIdentifier(node);
+    if (identifier === void 0) {
+        return void 0;
+    }
+    const typeAnnotation = getTypeAnnotationNode(identifier);
+    return typeAnnotation === void 0
+        ? { name: identifier.name }
+        : {
+            name: identifier.name,
+            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 : [];
+};
+/**
+ * Builds a lookup of parameter names to type annotations.
+ * @param node Function-like node.
+ * @returns Lookup of parameter names to annotations.
+ * @example
+ * ```typescript
+ * const lookup = getParameterTypeLookup(node);
+ * ```
+ */
+const getParameterTypeLookup = (node) => {
+    const lookup = new Map();
+    for (const parameter of getParameters(node)) {
+        const info = getParameterInfo(parameter);
+        if (info !== void 0 && info.typeAnnotation !== void 0) {
+            lookup.set(info.name, info.typeAnnotation);
+        }
+    }
+    return lookup;
+};
+/**
+ * Checks whether a type annotation is a named type reference.
+ * @param typeAnnotation Type annotation to inspect.
+ * @returns True when the annotation is a named reference.
+ * @example
+ * ```typescript
+ * const ok = isNamedTypeReference(annotation);
+ * ```
+ */
+const isNamedTypeReference = (typeAnnotation) => typeAnnotation?.type === "TSTypeReference";
+export { getParameterTypeLookup, isNamedTypeReference };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parameter-utilities.js","sourceRoot":"","sources":["../../../src/docs/no-interface-member-docs/parameter-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { TypeAnnotationNode } from \"./types\";\n\n/** Type definition for rule data. */\ninterface FunctionLikeNode {\n  /** Params helper value. */\n  params?: unknown[];\n}\n\n/** Type definition for rule data. */\ninterface IdentifierNode {\n  /** Name helper value. */\n  name?: string;\n\n  /** Type helper value. */\n  type?: string;\n\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: {\n    /** TypeAnnotation helper value. */\n    typeAnnotation?: TypeAnnotationNode;\n  };\n}\n\n/** Type definition for rule data. */\ninterface NamedIdentifierNode extends IdentifierNode {\n  /** Name field value. */\n  name: string;\n}\n\n/** Type definition for rule data. */\ninterface ParameterContainer {\n  /** Argument helper value. */\n  argument?: unknown;\n\n  /** Left helper value. */\n  left?: unknown;\n\n  /** Parameter helper value. */\n  parameter?: unknown;\n\n  /** Type helper value. */\n  type?: string;\n}\n\n/** Type definition for rule data. */\ninterface ParameterInfo {\n  /** Name field value. */\n  name: string;\n\n  /** TypeAnnotation helper value. */\n  typeAnnotation?: TypeAnnotationNode;\n}\n\n/**\n * Gets a type annotation node from an identifier.\n * @param node Identifier node to inspect.\n * @returns The type annotation node when present.\n * @example\n * ```typescript\n * const annotation = getTypeAnnotationNode(identifier);\n * ```\n */\nconst getTypeAnnotationNode = (\n  node: IdentifierNode,\n): TypeAnnotationNode | undefined => node.typeAnnotation?.typeAnnotation;\n\n/**\n * Defines resolveParameterNode.\n * @param node Input node value.\n * @returns Return value output.\n * @example\n * ```typescript\n * resolveParameterNode();\n * ```\n */\nconst resolveParameterNode = (node: unknown): unknown => {\n  if (node === null || typeof node !== \"object\") {\n    return node;\n  }\n\n  const container = node as ParameterContainer;\n\n  if (container.argument !== void 0) {\n    return container.argument;\n  }\n\n  if (container.parameter !== void 0) {\n    return container.parameter;\n  }\n\n  if (container.type === \"AssignmentPattern\" && container.left !== void 0) {\n    return container.left;\n  }\n\n  return node;\n};\n\n/**\n * Gets the parameter identifier for a parameter node.\n * @param node Parameter node to inspect.\n * @returns The identifier node when present.\n * @example\n * ```typescript\n * const identifier = getParameterIdentifier(node);\n * ```\n */\nconst getParameterIdentifier = (\n  node: unknown,\n): NamedIdentifierNode | undefined => {\n  const resolved = resolveParameterNode(node);\n\n  if (resolved === null || typeof resolved !== \"object\") {\n    return void 0;\n  }\n\n  const identifier = resolved as IdentifierNode;\n  const { name } = identifier;\n\n  if (identifier.type !== \"Identifier\" || typeof name !== \"string\") {\n    return void 0;\n  }\n\n  return { ...identifier, name } as NamedIdentifierNode;\n};\n\n/**\n * Gets parameter info for the given node.\n * @param node Parameter node to inspect.\n * @returns Parameter info when available.\n * @example\n * ```typescript\n * const info = getParameterInfo(node);\n * ```\n */\nconst getParameterInfo = (node: unknown): ParameterInfo | undefined => {\n  const identifier = getParameterIdentifier(node);\n\n  if (identifier === void 0) {\n    return void 0;\n  }\n\n  const typeAnnotation = getTypeAnnotationNode(identifier);\n\n  return typeAnnotation === void 0\n    ? { name: identifier.name }\n    : {\n        name: identifier.name,\n        typeAnnotation,\n      };\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 * Builds a lookup of parameter names to type annotations.\n * @param node Function-like node.\n * @returns Lookup of parameter names to annotations.\n * @example\n * ```typescript\n * const lookup = getParameterTypeLookup(node);\n * ```\n */\nconst getParameterTypeLookup = (\n  node: Rule.Node,\n): Map<string, TypeAnnotationNode> => {\n  const lookup = new Map<string, TypeAnnotationNode>();\n\n  for (const parameter of getParameters(node)) {\n    const info = getParameterInfo(parameter);\n\n    if (info !== void 0 && info.typeAnnotation !== void 0) {\n      lookup.set(info.name, info.typeAnnotation);\n    }\n  }\n\n  return lookup;\n};\n\n/**\n * Checks whether a type annotation is a named type reference.\n * @param typeAnnotation Type annotation to inspect.\n * @returns True when the annotation is a named reference.\n * @example\n * ```typescript\n * const ok = isNamedTypeReference(annotation);\n * ```\n */\nconst isNamedTypeReference = (\n  typeAnnotation: TypeAnnotationNode | undefined,\n): boolean => typeAnnotation?.type === \"TSTypeReference\";\n\nexport { getParameterTypeLookup, isNamedTypeReference };\n"]}

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

@@ -0,0 +1,5 @@
+import type { Rule } from "eslint";
+/** ESLint rule disallowing interface member documentation in `@param` tags. */
+declare const noInterfaceMemberDocumentationRule: Rule.RuleModule;
+export { noInterfaceMemberDocumentationRule };
+//# sourceMappingURL=rule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../src/docs/no-interface-member-docs/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAiPnC,+EAA+E;AAC/E,QAAA,MAAM,kCAAkC,EAAE,IAAI,CAAC,UA8B9C,CAAC;AAEF,OAAO,EAAE,kCAAkC,EAAE,CAAC"}