@codeperfect/eslint-plugin 1.0.0

package/dist/docs/single-line-jsdoc/rule.js

@@ -0,0 +1,196 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation";
+import { normalizeMaxLineLength, reportIfSingleLine, } from "./single-line-jsdoc-utilities";
+/**
+ * Resolves the token after a comment when available.
+ * @param sourceCode Source code accessors.
+ * @param comment Comment node to inspect.
+ * @returns Token range metadata when available.
+ * @example
+ * ```typescript
+ * getTokenAfterRange({} as SourceCodeAccess, {} as SourceComment);
+ * ```
+ */
+const getTokenAfterRange = (sourceCode, comment) => {
+    if (typeof sourceCode.getTokenAfter !== "function") {
+        return void 0;
+    }
+    const tokenAfter = sourceCode.getTokenAfter(comment, {
+        includeComments: false,
+    });
+    if (tokenAfter?.range === void 0) {
+        return void 0;
+    }
+    return { range: tokenAfter.range };
+};
+/**
+ * Function-like node types handled directly.
+ * @example
+ * ```typescript
+ * functionLikeTypes.has("TSFunctionType");
+ * ```
+ */
+const functionLikeTypes = new Set([
+    "TSCallSignatureDeclaration",
+    "TSConstructSignatureDeclaration",
+    "TSFunctionType",
+]);
+/**
+ * Checks if a node is a function expression or arrow function.
+ * @param node Node to inspect.
+ * @returns True when the node is a function expression.
+ * @example
+ * ```typescript
+ * isFunctionExpression({ type: "FunctionExpression" } as EstreeNode);
+ * ```
+ */
+const isFunctionExpression = (node) => node?.type === "FunctionExpression" || node?.type === "ArrowFunctionExpression";
+/**
+ * Checks if a node is a function declaration or TS declaration signature.
+ * @param node Node to inspect.
+ * @returns True when the node is a function declaration.
+ * @example
+ * ```typescript
+ * isFunctionDeclaration({ type: "FunctionDeclaration" } as EstreeNode);
+ * ```
+ */
+const isFunctionDeclaration = (node) => node?.type === "FunctionDeclaration" || node?.type === "TSDeclareFunction";
+/**
+ * Checks if a node is a method-like declaration.
+ * @param node Node to inspect.
+ * @returns True when the node is a method-like declaration.
+ * @example
+ * ```typescript
+ * isMethodLike({ type: "MethodDefinition" } as EstreeNode);
+ * ```
+ */
+const isMethodLike = (node) => node?.type === "MethodDefinition" || node?.type === "TSMethodSignature";
+/**
+ * Checks if a node is a property with a function initializer.
+ * @param node Node to inspect.
+ * @returns True when the property value is a function.
+ * @example
+ * ```typescript
+ * isPropertyWithFunctionValue({ type: "Property" } as EstreeNode);
+ * ```
+ */
+const isPropertyWithFunctionValue = (node) => {
+    if (node.type !== "PropertyDefinition" && node.type !== "Property") {
+        return false;
+    }
+    const { value } = node;
+    return isFunctionExpression(value);
+};
+/**
+ * Checks if a variable declaration contains a function initializer.
+ * @param node Node to inspect.
+ * @returns True when any initializer is a function.
+ * @example
+ * ```typescript
+ * isVariableWithFunctionInit({ type: "VariableDeclaration" } as EstreeNode);
+ * ```
+ */
+const isVariableWithFunctionInit = (node) => {
+    if (node.type !== "VariableDeclaration") {
+        return false;
+    }
+    const { declarations } = node;
+    const initialized = declarations ?? [];
+    return initialized.some((declaration) => isFunctionExpression(declaration.init));
+};
+/**
+ * Checks if an export wraps a function-like declaration.
+ * @param node Node to inspect.
+ * @returns True when the exported declaration is function-like.
+ * @example
+ * ```typescript
+ * isExportedFunctionLike({ type: "ExportNamedDeclaration" } as EstreeNode);
+ * ```
+ */
+const isExportedFunctionLike = (node) => {
+    if (node.type !== "ExportNamedDeclaration" &&
+        node.type !== "ExportDefaultDeclaration") {
+        return false;
+    }
+    const { declaration } = node;
+    return isFunctionLikeNode(declaration);
+};
+/**
+ * Checks if a node represents any supported function-like declaration.
+ * @param node Node to inspect.
+ * @returns True when the node is function-like.
+ * @example
+ * ```typescript
+ * isFunctionLikeNode({ type: "FunctionDeclaration" } as EstreeNode);
+ * ```
+ */
+const isFunctionLikeNode = (node) => {
+    if (node === null || node === void 0) {
+        return false;
+    }
+    return (isFunctionDeclaration(node) ||
+        isFunctionExpression(node) ||
+        isMethodLike(node) ||
+        functionLikeTypes.has(node.type) ||
+        isPropertyWithFunctionValue(node) ||
+        isVariableWithFunctionInit(node) ||
+        isExportedFunctionLike(node));
+};
+/**
+ * Determines whether a JSDoc comment should be skipped for function targets.
+ * @param context Rule context.
+ * @param comment Comment node to inspect.
+ * @returns True when the comment targets a function-like node.
+ * @example
+ * ```typescript
+ * shouldSkipForFunction({} as Rule.RuleContext, {} as SourceComment);
+ * ```
+ */
+const shouldSkipForFunction = (context, comment) => {
+    const sourceCode = context.sourceCode;
+    if (typeof sourceCode.getNodeByRangeIndex !== "function") {
+        return false;
+    }
+    const tokenAfter = getTokenAfterRange(sourceCode, comment);
+    if (tokenAfter === void 0) {
+        return false;
+    }
+    const [rangeStart] = tokenAfter.range;
+    const node = sourceCode.getNodeByRangeIndex(rangeStart);
+    return isFunctionLikeNode(node);
+};
+/** Rule module enforcing single-line JSDoc when it fits. */
+const singleLineJsdocRule = {
+    create(context) {
+        const { options, sourceCode } = context;
+        const maxLineLength = normalizeMaxLineLength(options);
+        const comments = sourceCode.getAllComments();
+        for (const comment of comments) {
+            if (!shouldSkipForFunction(context, comment)) {
+                reportIfSingleLine(context, comment, maxLineLength);
+            }
+        }
+        return {};
+    },
+    meta: {
+        docs: createRuleDocumentation("single-line-jsdoc", "Require JSDoc comments to use a single line when they fit."),
+        fixable: "code",
+        messages: {
+            singleLine: "Use a single-line JSDoc comment when it fits on one line.",
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    maxLineLength: {
+                        minimum: 1,
+                        type: "number",
+                    },
+                },
+                type: "object",
+            },
+        ],
+        type: "layout",
+    },
+};
+export { singleLineJsdocRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../src/docs/single-line-jsdoc/rule.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC1E,OAAO,EACL,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,+BAA+B,CAAC;AA0DvC;;;;;;;;;GASG;AACH,MAAM,kBAAkB,GAAG,CACzB,UAA4B,EAC5B,OAAsB,EACM,EAAE;IAC9B,IAAI,OAAO,UAAU,CAAC,aAAa,KAAK,UAAU,EAAE,CAAC;QACnD,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,MAAM,UAAU,GAAG,UAAU,CAAC,aAAa,CAAC,OAAO,EAAE;QACnD,eAAe,EAAE,KAAK;KACvB,CAAC,CAAC;IAEH,IAAI,UAAU,EAAE,KAAK,KAAK,KAAK,CAAC,EAAE,CAAC;QACjC,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,CAAC;AACrC,CAAC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAS;IACxC,4BAA4B;IAC5B,iCAAiC;IACjC,gBAAgB;CACjB,CAAC,CAAC;AAEH;;;;;;;;GAQG;AACH,MAAM,oBAAoB,GAAG,CAAC,IAAe,EAAW,EAAE,CACxD,IAAI,EAAE,IAAI,KAAK,oBAAoB,IAAI,IAAI,EAAE,IAAI,KAAK,yBAAyB,CAAC;AAElF;;;;;;;;GAQG;AACH,MAAM,qBAAqB,GAAG,CAAC,IAAe,EAAW,EAAE,CACzD,IAAI,EAAE,IAAI,KAAK,qBAAqB,IAAI,IAAI,EAAE,IAAI,KAAK,mBAAmB,CAAC;AAE7E;;;;;;;;GAQG;AACH,MAAM,YAAY,GAAG,CAAC,IAAe,EAAW,EAAE,CAChD,IAAI,EAAE,IAAI,KAAK,kBAAkB,IAAI,IAAI,EAAE,IAAI,KAAK,mBAAmB,CAAC;AAE1E;;;;;;;;GAQG;AACH,MAAM,2BAA2B,GAAG,CAAC,IAAgB,EAAW,EAAE;IAChE,IAAI,IAAI,CAAC,IAAI,KAAK,oBAAoB,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QACnE,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,EAAE,KAAK,EAAE,GAAG,IAAqB,CAAC;IAExC,OAAO,oBAAoB,CAAC,KAAK,CAAC,CAAC;AACrC,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,0BAA0B,GAAG,CAAC,IAAgB,EAAW,EAAE;IAC/D,IAAI,IAAI,CAAC,IAAI,KAAK,qBAAqB,EAAE,CAAC;QACxC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,EAAE,YAAY,EAAE,GAAG,IAA4B,CAAC;IACtD,MAAM,WAAW,GAAG,YAAY,IAAI,EAAE,CAAC;IAEvC,OAAO,WAAW,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CACtC,oBAAoB,CAAC,WAAW,CAAC,IAAI,CAAC,CACvC,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,sBAAsB,GAAG,CAAC,IAAgB,EAAW,EAAE;IAC3D,IACE,IAAI,CAAC,IAAI,KAAK,wBAAwB;QACtC,IAAI,CAAC,IAAI,KAAK,0BAA0B,EACxC,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,EAAE,WAAW,EAAE,GAAG,IAA2B,CAAC;IAEpD,OAAO,kBAAkB,CAAC,WAAW,CAAC,CAAC;AACzC,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,kBAAkB,GAAG,CAAC,IAAe,EAAW,EAAE;IACtD,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACrC,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,CACL,qBAAqB,CAAC,IAAI,CAAC;QAC3B,oBAAoB,CAAC,IAAI,CAAC;QAC1B,YAAY,CAAC,IAAI,CAAC;QAClB,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;QAChC,2BAA2B,CAAC,IAAkB,CAAC;QAC/C,0BAA0B,CAAC,IAAkB,CAAC;QAC9C,sBAAsB,CAAC,IAAkB,CAAC,CAC3C,CAAC;AACJ,CAAC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,qBAAqB,GAAG,CAC5B,OAAyB,EACzB,OAAsB,EACb,EAAE;IACX,MAAM,UAAU,GAAG,OAAO,CAAC,UAA8B,CAAC;IAC1D,IAAI,OAAO,UAAU,CAAC,mBAAmB,KAAK,UAAU,EAAE,CAAC;QACzD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,UAAU,GAAG,kBAAkB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAC3D,IAAI,UAAU,KAAK,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC;IACtC,MAAM,IAAI,GAAG,UAAU,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;IACxD,OAAO,kBAAkB,CAAC,IAAI,CAAC,CAAC;AAClC,CAAC,CAAC;AAEF,4DAA4D;AAC5D,MAAM,mBAAmB,GAAoB;IAC3C,MAAM,CAAC,OAAyB;QAC9B,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;QACxC,MAAM,aAAa,GAAG,sBAAsB,CAAC,OAAO,CAAC,CAAC;QAEtD,MAAM,QAAQ,GAAG,UAAU,CAAC,cAAc,EAAE,CAAC;QAE7C,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC/B,IAAI,CAAC,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;gBAC7C,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC;YACtD,CAAC;QACH,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,IAAI,EAAE;QACJ,IAAI,EAAE,uBAAuB,CAAC,mBAAmB,EAAE,4DAA4D,CAAC;QAChH,OAAO,EAAE,MAAM;QACf,QAAQ,EAAE;YACR,UAAU,EAAE,2DAA2D;SACxE;QACD,MAAM,EAAE;YACN;gBACE,oBAAoB,EAAE,KAAK;gBAC3B,UAAU,EAAE;oBACV,aAAa,EAAE;wBACb,OAAO,EAAE,CAAC;wBACV,IAAI,EAAE,QAAQ;qBACf;iBACF;gBACD,IAAI,EAAE,QAAQ;aACf;SACF;QACD,IAAI,EAAE,QAAQ;KACf;CACF,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC","sourcesContent":["import type { Rule } from \"eslint\";\nimport type { Comment as EstreeComment, Node as EstreeNode } from \"estree\";\n\nimport { createRuleDocumentation } from \"../../custom-rule-documentation\";\nimport {\n  normalizeMaxLineLength,\n  reportIfSingleLine,\n} from \"./single-line-jsdoc-utilities\";\n/** Type union for nodes that may be missing. */\ntype MaybeNode = EstreeNode | NodeWithType | null | undefined;\n\n/** Shape for export nodes that wrap a declaration. */\ninterface NodeWithDeclaration {\n  /** Declaration wrapped by the export. */\n  declaration?: MaybeNode;\n}\n/** Shape for nodes that have declarations. */\ninterface NodeWithDeclarations {\n  /** Variable declarations for a declaration list. */\n  declarations?: VariableDeclarationEntry[];\n}\n/** Shape for minimal nodes that only expose a type. */\ninterface NodeWithType {\n  /** Node type discriminator. */\n  type: string;\n}\n/** Shape for nodes that have a value. */\ninterface NodeWithValue {\n  /** Value node used for property initializers. */\n  value?: MaybeNode;\n}\n/** SourceCode accessors used by this rule. */\ninterface SourceCodeAccess {\n  /** Returns the node at a range index. */\n  getNodeByRangeIndex: (index: number) => EstreeNode | null;\n\n  /** Returns the first token after a comment. */\n  getTokenAfter: (\n    node: EstreeComment,\n    options?: TokenAfterOptions,\n  ) => null | TokenWithOptionalRange;\n}\n/** Type alias for comment nodes provided by ESLint. */\ntype SourceComment = EstreeComment;\n/** Options used when fetching tokens after comments. */\ninterface TokenAfterOptions {\n  /** Whether to include comment tokens. */\n  includeComments?: boolean;\n}\n/** Shape for tokens that may include a range. */\ninterface TokenWithOptionalRange {\n  /** Token range used for lookups. */\n  range?: [number, number];\n}\n/** Shape for tokens with range metadata. */\ninterface TokenWithRange {\n  /** Token range used for lookups. */\n  range: [number, number];\n}\n/** Shape for variable declaration entries. */\ninterface VariableDeclarationEntry {\n  /** Optional initializer for the declaration. */\n  init?: MaybeNode;\n}\n\n/**\n * Resolves the token after a comment when available.\n * @param sourceCode Source code accessors.\n * @param comment Comment node to inspect.\n * @returns Token range metadata when available.\n * @example\n * ```typescript\n * getTokenAfterRange({} as SourceCodeAccess, {} as SourceComment);\n * ```\n */\nconst getTokenAfterRange = (\n  sourceCode: SourceCodeAccess,\n  comment: SourceComment,\n): TokenWithRange | undefined => {\n  if (typeof sourceCode.getTokenAfter !== \"function\") {\n    return void 0;\n  }\n\n  const tokenAfter = sourceCode.getTokenAfter(comment, {\n    includeComments: false,\n  });\n\n  if (tokenAfter?.range === void 0) {\n    return void 0;\n  }\n\n  return { range: tokenAfter.range };\n};\n\n/**\n * Function-like node types handled directly.\n * @example\n * ```typescript\n * functionLikeTypes.has(\"TSFunctionType\");\n * ```\n */\nconst functionLikeTypes = new Set<string>([\n  \"TSCallSignatureDeclaration\",\n  \"TSConstructSignatureDeclaration\",\n  \"TSFunctionType\",\n]);\n\n/**\n * Checks if a node is a function expression or arrow function.\n * @param node Node to inspect.\n * @returns True when the node is a function expression.\n * @example\n * ```typescript\n * isFunctionExpression({ type: \"FunctionExpression\" } as EstreeNode);\n * ```\n */\nconst isFunctionExpression = (node: MaybeNode): boolean =>\n  node?.type === \"FunctionExpression\" || node?.type === \"ArrowFunctionExpression\";\n\n/**\n * Checks if a node is a function declaration or TS declaration signature.\n * @param node Node to inspect.\n * @returns True when the node is a function declaration.\n * @example\n * ```typescript\n * isFunctionDeclaration({ type: \"FunctionDeclaration\" } as EstreeNode);\n * ```\n */\nconst isFunctionDeclaration = (node: MaybeNode): boolean =>\n  node?.type === \"FunctionDeclaration\" || node?.type === \"TSDeclareFunction\";\n\n/**\n * Checks if a node is a method-like declaration.\n * @param node Node to inspect.\n * @returns True when the node is a method-like declaration.\n * @example\n * ```typescript\n * isMethodLike({ type: \"MethodDefinition\" } as EstreeNode);\n * ```\n */\nconst isMethodLike = (node: MaybeNode): boolean =>\n  node?.type === \"MethodDefinition\" || node?.type === \"TSMethodSignature\";\n\n/**\n * Checks if a node is a property with a function initializer.\n * @param node Node to inspect.\n * @returns True when the property value is a function.\n * @example\n * ```typescript\n * isPropertyWithFunctionValue({ type: \"Property\" } as EstreeNode);\n * ```\n */\nconst isPropertyWithFunctionValue = (node: EstreeNode): boolean => {\n  if (node.type !== \"PropertyDefinition\" && node.type !== \"Property\") {\n    return false;\n  }\n\n  const { value } = node as NodeWithValue;\n\n  return isFunctionExpression(value);\n};\n\n/**\n * Checks if a variable declaration contains a function initializer.\n * @param node Node to inspect.\n * @returns True when any initializer is a function.\n * @example\n * ```typescript\n * isVariableWithFunctionInit({ type: \"VariableDeclaration\" } as EstreeNode);\n * ```\n */\nconst isVariableWithFunctionInit = (node: EstreeNode): boolean => {\n  if (node.type !== \"VariableDeclaration\") {\n    return false;\n  }\n\n  const { declarations } = node as NodeWithDeclarations;\n  const initialized = declarations ?? [];\n\n  return initialized.some((declaration) =>\n    isFunctionExpression(declaration.init),\n  );\n};\n\n/**\n * Checks if an export wraps a function-like declaration.\n * @param node Node to inspect.\n * @returns True when the exported declaration is function-like.\n * @example\n * ```typescript\n * isExportedFunctionLike({ type: \"ExportNamedDeclaration\" } as EstreeNode);\n * ```\n */\nconst isExportedFunctionLike = (node: EstreeNode): boolean => {\n  if (\n    node.type !== \"ExportNamedDeclaration\" &&\n    node.type !== \"ExportDefaultDeclaration\"\n  ) {\n    return false;\n  }\n\n  const { declaration } = node as NodeWithDeclaration;\n\n  return isFunctionLikeNode(declaration);\n};\n\n/**\n * Checks if a node represents any supported function-like declaration.\n * @param node Node to inspect.\n * @returns True when the node is function-like.\n * @example\n * ```typescript\n * isFunctionLikeNode({ type: \"FunctionDeclaration\" } as EstreeNode);\n * ```\n */\nconst isFunctionLikeNode = (node: MaybeNode): boolean => {\n  if (node === null || node === void 0) {\n    return false;\n  }\n\n  return (\n    isFunctionDeclaration(node) ||\n    isFunctionExpression(node) ||\n    isMethodLike(node) ||\n    functionLikeTypes.has(node.type) ||\n    isPropertyWithFunctionValue(node as EstreeNode) ||\n    isVariableWithFunctionInit(node as EstreeNode) ||\n    isExportedFunctionLike(node as EstreeNode)\n  );\n};\n\n/**\n * Determines whether a JSDoc comment should be skipped for function targets.\n * @param context Rule context.\n * @param comment Comment node to inspect.\n * @returns True when the comment targets a function-like node.\n * @example\n * ```typescript\n * shouldSkipForFunction({} as Rule.RuleContext, {} as SourceComment);\n * ```\n */\nconst shouldSkipForFunction = (\n  context: Rule.RuleContext,\n  comment: SourceComment,\n): boolean => {\n  const sourceCode = context.sourceCode as SourceCodeAccess;\n  if (typeof sourceCode.getNodeByRangeIndex !== \"function\") {\n    return false;\n  }\n\n  const tokenAfter = getTokenAfterRange(sourceCode, comment);\n  if (tokenAfter === void 0) {\n    return false;\n  }\n\n  const [rangeStart] = tokenAfter.range;\n  const node = sourceCode.getNodeByRangeIndex(rangeStart);\n  return isFunctionLikeNode(node);\n};\n\n/** Rule module enforcing single-line JSDoc when it fits. */\nconst singleLineJsdocRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    const { options, sourceCode } = context;\n    const maxLineLength = normalizeMaxLineLength(options);\n\n    const comments = sourceCode.getAllComments();\n\n    for (const comment of comments) {\n      if (!shouldSkipForFunction(context, comment)) {\n        reportIfSingleLine(context, comment, maxLineLength);\n      }\n    }\n\n    return {};\n  },\n  meta: {\n    docs: createRuleDocumentation(\"single-line-jsdoc\", \"Require JSDoc comments to use a single line when they fit.\"),\n    fixable: \"code\",\n    messages: {\n      singleLine: \"Use a single-line JSDoc comment when it fits on one line.\",\n    },\n    schema: [\n      {\n        additionalProperties: false,\n        properties: {\n          maxLineLength: {\n            minimum: 1,\n            type: \"number\",\n          },\n        },\n        type: \"object\",\n      },\n    ],\n    type: \"layout\",\n  },\n};\n\nexport { singleLineJsdocRule };"]}

package/dist/docs/single-line-jsdoc/single-line-jsdoc-content.d.ts

@@ -0,0 +1,16 @@
+import type { Rule } from "eslint";
+/** Type definition for rule data. */
+type Comment = ReturnType<Rule.RuleContext["sourceCode"]["getAllComments"]>[number];
+/**
+ * Gets getCollapsedContent.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getCollapsedContent();
+ * ```
+ */
+declare const getCollapsedContent: (comment: Comment) => string | undefined;
+export { getCollapsedContent };
+export type { Comment };
+//# sourceMappingURL=single-line-jsdoc-content.d.ts.map

package/dist/docs/single-line-jsdoc/single-line-jsdoc-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-line-jsdoc-content.d.ts","sourceRoot":"","sources":["../../../src/docs/single-line-jsdoc/single-line-jsdoc-content.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;AAyFV;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB,GAAI,SAAS,OAAO,KAAG,MAAM,GAAG,SAYxD,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAC/B,YAAY,EAAE,OAAO,EAAE,CAAC"}

package/dist/docs/single-line-jsdoc/single-line-jsdoc-content.js

@@ -0,0 +1,95 @@
+/**
+ * Defines stripJsdocLine.
+ * @param line Input line value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * stripJsdocLine();
+ * ```
+ */
+const stripJsdocLine = (line) => line.replace(/^\s*\*? ?/u, "").trimEnd();
+/**
+ * Defines trimEmptyEdges.
+ * @param lines Input lines value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * trimEmptyEdges();
+ * ```
+ */
+const trimEmptyEdges = (lines) => {
+    let start = 0;
+    let end = lines.length - 1;
+    while (start <= end && lines[start]?.length === 0) {
+        start += 1;
+    }
+    while (end >= start && lines[end]?.length === 0) {
+        end -= 1;
+    }
+    return lines.slice(start, end + 1);
+};
+/**
+ * Gets getContentLines.
+ * @param commentValue Input commentValue value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getContentLines();
+ * ```
+ */
+const getContentLines = (commentValue) => {
+    const lines = commentValue
+        .split(/\r?\n/u)
+        .map((line) => stripJsdocLine(line))
+        .map((line) => line.trim());
+    return trimEmptyEdges(lines);
+};
+/**
+ * Checks shouldSkipContent.
+ * @param lines Input lines value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * shouldSkipContent();
+ * ```
+ */
+const shouldSkipContent = (lines) => {
+    if (lines.length === 0) {
+        return true;
+    }
+    if (lines.some((line) => line.length === 0)) {
+        return true;
+    }
+    return lines.some((line) => line.startsWith("@"));
+};
+/**
+ * Defines collapseContent.
+ * @param lines Input lines value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * collapseContent();
+ * ```
+ */
+const collapseContent = (lines) => lines.join(" ").replaceAll(/\s+/gu, " ").trim();
+/**
+ * Gets getCollapsedContent.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getCollapsedContent();
+ * ```
+ */
+const getCollapsedContent = (comment) => {
+    const contentLines = getContentLines(comment.value);
+    if (shouldSkipContent(contentLines)) {
+        return void 0;
+    }
+    if (contentLines.length !== 1) {
+        return void 0;
+    }
+    return collapseContent(contentLines);
+};
+export { getCollapsedContent };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/docs/single-line-jsdoc/single-line-jsdoc-utilities.d.ts

@@ -0,0 +1,25 @@
+import type { Rule } from "eslint";
+import type { Comment } from "./single-line-jsdoc-content";
+/**
+ * Normalizes normalizeMaxLineLength.
+ * @param options Input options value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * normalizeMaxLineLength();
+ * ```
+ */
+declare const normalizeMaxLineLength: (options: readonly unknown[]) => number;
+/**
+ * Reports a comment when it can be collapsed to a single line.
+ * @param context Input context value.
+ * @param comment Input comment value.
+ * @param maxLineLength Input maxLineLength value.
+ * @example
+ * ```typescript
+ * reportIfSingleLine(context, comment, 80);
+ * ```
+ */
+declare const reportIfSingleLine: (context: Rule.RuleContext, comment: Comment, maxLineLength: number) => void;
+export { normalizeMaxLineLength, reportIfSingleLine };
+//# sourceMappingURL=single-line-jsdoc-utilities.d.ts.map

package/dist/docs/single-line-jsdoc/single-line-jsdoc-utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-line-jsdoc-utilities.d.ts","sourceRoot":"","sources":["../../../src/docs/single-line-jsdoc/single-line-jsdoc-utilities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAa3D;;;;;;;;GAQG;AACH,QAAA,MAAM,sBAAsB,GAAI,SAAS,SAAS,OAAO,EAAE,KAAG,MAU7D,CAAC;AAiHF;;;;;;;;;GASG;AACH,QAAA,MAAM,kBAAkB,GACtB,SAAS,IAAI,CAAC,WAAW,EACzB,SAAS,OAAO,EAChB,eAAe,MAAM,KACpB,IAsBF,CAAC;AAEF,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/docs/single-line-jsdoc/single-line-jsdoc-utilities.js

@@ -0,0 +1,140 @@
+import { getCollapsedContent } from "./single-line-jsdoc-content";
+/** Default value used by this module. */
+const DEFAULT_MAX_LINE_LENGTH = 80;
+/**
+ * Normalizes normalizeMaxLineLength.
+ * @param options Input options value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * normalizeMaxLineLength();
+ * ```
+ */
+const normalizeMaxLineLength = (options) => {
+    const rawOptions = options[0];
+    const maxLineLength = rawOptions?.maxLineLength;
+    if (typeof maxLineLength === "number" && Number.isFinite(maxLineLength)) {
+        const normalized = Math.floor(maxLineLength);
+        return normalized > 0 ? normalized : DEFAULT_MAX_LINE_LENGTH;
+    }
+    return DEFAULT_MAX_LINE_LENGTH;
+};
+/**
+ * Checks isMultilineComment.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isMultilineComment();
+ * ```
+ */
+const isMultilineComment = (comment) => {
+    const { loc, value } = comment;
+    if (loc === null || loc === void 0) {
+        return /\r|\n/u.test(value);
+    }
+    return loc.start.line !== loc.end.line;
+};
+/**
+ * Build a single-line JSDoc string from content.
+ * @param content Input content value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const text = buildSingleLineText("ok");
+ * ```
+ */
+const buildSingleLineText = (content) => `/** ${content} */`;
+/**
+ * Creates a fixer for replacing a JSDoc range.
+ * @param range Input range value.
+ * @param replacementText Input replacementText value.
+ * @returns Fixer function for ESLint.
+ * @example
+ * ```typescript
+ * const fixer = createFix([0, 1], "/** ok *\\/");
+ * ```
+ */
+const createFix = (range, replacementText) => {
+    return (fixer) => fixer.replaceTextRange(range, replacementText);
+};
+/**
+ * Checks isJsdocComment.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isJsdocComment();
+ * ```
+ */
+const isJsdocComment = (comment) => comment.type === "Block" && comment.value.startsWith("*");
+/**
+ * Gets getStartColumn.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getStartColumn();
+ * ```
+ */
+const getStartColumn = (comment) => {
+    const { loc } = comment;
+    if (loc === null || loc === void 0) {
+        return void 0;
+    }
+    return loc.start.column;
+};
+/**
+ * Builds a single-line replacement when it fits.
+ * @param comment Input comment value.
+ * @param maxLineLength Input maxLineLength value.
+ * @returns Replacement text when available.
+ * @example
+ * ```typescript
+ * const text = getSingleLineReplacement(comment, 80);
+ * ```
+ */
+const getSingleLineReplacement = (comment, maxLineLength) => {
+    if (!isMultilineComment(comment)) {
+        return void 0;
+    }
+    const content = getCollapsedContent(comment);
+    const startColumn = getStartColumn(comment);
+    if (content === void 0 || startColumn === void 0) {
+        return void 0;
+    }
+    const singleLineText = buildSingleLineText(content);
+    return startColumn + singleLineText.length > maxLineLength
+        ? void 0
+        : singleLineText;
+};
+/**
+ * Reports a comment when it can be collapsed to a single line.
+ * @param context Input context value.
+ * @param comment Input comment value.
+ * @param maxLineLength Input maxLineLength value.
+ * @example
+ * ```typescript
+ * reportIfSingleLine(context, comment, 80);
+ * ```
+ */
+const reportIfSingleLine = (context, comment, maxLineLength) => {
+    if (!isJsdocComment(comment)) {
+        return;
+    }
+    const singleLineText = getSingleLineReplacement(comment, maxLineLength);
+    if (singleLineText === void 0) {
+        return;
+    }
+    const { loc, range } = comment;
+    if (loc === null || loc === void 0 || range === void 0) {
+        return;
+    }
+    context.report({
+        fix: createFix(range, singleLineText),
+        loc,
+        messageId: "singleLine",
+    });
+};
+export { normalizeMaxLineLength, reportIfSingleLine };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"single-line-jsdoc-utilities.js","sourceRoot":"","sources":["../../../src/docs/single-line-jsdoc/single-line-jsdoc-utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Comment } from \"./single-line-jsdoc-content\";\n\nimport { getCollapsedContent } from \"./single-line-jsdoc-content\";\n\n/** Default value used by this module. */\nconst DEFAULT_MAX_LINE_LENGTH = 80;\n\n/** Type definition for rule data. */\ninterface SingleLineJsdocOptions {\n  /** MaxLineLength helper value. */\n  maxLineLength?: number;\n}\n\n/**\n * Normalizes normalizeMaxLineLength.\n * @param options Input options value.\n * @returns Return value output.\n * @example\n * ```typescript\n * normalizeMaxLineLength();\n * ```\n */\nconst normalizeMaxLineLength = (options: readonly unknown[]): number => {\n  const rawOptions = options[0] as SingleLineJsdocOptions | undefined;\n  const maxLineLength = rawOptions?.maxLineLength;\n\n  if (typeof maxLineLength === \"number\" && Number.isFinite(maxLineLength)) {\n    const normalized = Math.floor(maxLineLength);\n    return normalized > 0 ? normalized : DEFAULT_MAX_LINE_LENGTH;\n  }\n\n  return DEFAULT_MAX_LINE_LENGTH;\n};\n\n/**\n * Checks isMultilineComment.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * isMultilineComment();\n * ```\n */\nconst isMultilineComment = (comment: Comment): boolean => {\n  const { loc, value } = comment;\n\n  if (loc === null || loc === void 0) {\n    return /\\r|\\n/u.test(value);\n  }\n\n  return loc.start.line !== loc.end.line;\n};\n\n/**\n * Build a single-line JSDoc string from content.\n * @param content Input content value.\n * @returns Return value output.\n * @example\n * ```typescript\n * const text = buildSingleLineText(\"ok\");\n * ```\n */\nconst buildSingleLineText = (content: string): string => `/** ${content} */`;\n\n/**\n * Creates a fixer for replacing a JSDoc range.\n * @param range Input range value.\n * @param replacementText Input replacementText value.\n * @returns Fixer function for ESLint.\n * @example\n * ```typescript\n * const fixer = createFix([0, 1], \"/** ok *\\\\/\");\n * ```\n */\nconst createFix = (\n  range: [number, number],\n  replacementText: string,\n): Rule.ReportFixer => {\n  return (fixer: Rule.RuleFixer): Rule.Fix =>\n    fixer.replaceTextRange(range, replacementText);\n};\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 getStartColumn.\n * @param comment Input comment value.\n * @returns Return value output.\n * @example\n * ```typescript\n * getStartColumn();\n * ```\n */\nconst getStartColumn = (comment: Comment): number | undefined => {\n  const { loc } = comment;\n\n  if (loc === null || loc === void 0) {\n    return void 0;\n  }\n\n  return loc.start.column;\n};\n\n/**\n * Builds a single-line replacement when it fits.\n * @param comment Input comment value.\n * @param maxLineLength Input maxLineLength value.\n * @returns Replacement text when available.\n * @example\n * ```typescript\n * const text = getSingleLineReplacement(comment, 80);\n * ```\n */\nconst getSingleLineReplacement = (\n  comment: Comment,\n  maxLineLength: number,\n): string | undefined => {\n  if (!isMultilineComment(comment)) {\n    return void 0;\n  }\n\n  const content = getCollapsedContent(comment);\n  const startColumn = getStartColumn(comment);\n\n  if (content === void 0 || startColumn === void 0) {\n    return void 0;\n  }\n\n  const singleLineText = buildSingleLineText(content);\n\n  return startColumn + singleLineText.length > maxLineLength\n    ? void 0\n    : singleLineText;\n};\n\n/**\n * Reports a comment when it can be collapsed to a single line.\n * @param context Input context value.\n * @param comment Input comment value.\n * @param maxLineLength Input maxLineLength value.\n * @example\n * ```typescript\n * reportIfSingleLine(context, comment, 80);\n * ```\n */\nconst reportIfSingleLine = (\n  context: Rule.RuleContext,\n  comment: Comment,\n  maxLineLength: number,\n): void => {\n  if (!isJsdocComment(comment)) {\n    return;\n  }\n\n  const singleLineText = getSingleLineReplacement(comment, maxLineLength);\n\n  if (singleLineText === void 0) {\n    return;\n  }\n\n  const { loc, range } = comment;\n\n  if (loc === null || loc === void 0 || range === void 0) {\n    return;\n  }\n\n  context.report({\n    fix: createFix(range, singleLineText),\n    loc,\n    messageId: \"singleLine\",\n  });\n};\n\nexport { normalizeMaxLineLength, reportIfSingleLine };\n"]}

package/dist/docs/test-helpers.d.ts

@@ -0,0 +1,50 @@
+import type { Rule } from "eslint";
+/** Type definition for rule data. */
+interface FixReportEntry {
+    /** Fix helper value. */
+    fix?: null | Rule.ReportFixer | undefined;
+}
+/** Type definition for rule data. */
+type FixResult = Exclude<ReturnType<Rule.ReportFixer>, null>;
+/**
+ * Creates createFixer.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * createFixer();
+ * ```
+ */
+declare const createFixer: () => Parameters<Rule.ReportFixer>[0];
+/**
+ * Gets getFixText.
+ * @param fixResult Input fixResult value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getFixText();
+ * ```
+ */
+declare const getFixText: (fixResult?: FixResult) => string | undefined;
+/**
+ * Gets getFixes.
+ * @param reports Input reports value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getFixes();
+ * ```
+ */
+declare const getFixes: (reports: FixReportEntry[]) => Rule.Fix[];
+/**
+ * Applies applyFixes.
+ * @param sourceText Input sourceText value.
+ * @param fixes Input fixes value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * applyFixes();
+ * ```
+ */
+declare const applyFixes: (sourceText: string, fixes: Rule.Fix[]) => string;
+export { applyFixes, createFixer, getFixes, getFixText };
+//# sourceMappingURL=test-helpers.d.ts.map

package/dist/docs/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../src/docs/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,qCAAqC;AACrC,UAAU,cAAc;IACtB,wBAAwB;IACxB,GAAG,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC,WAAW,GAAG,SAAS,CAAC;CAC3C;AAED,qCAAqC;AACrC,KAAK,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,IAAI,CAAC,CAAC;AAE7D;;;;;;;GAOG;AACH,QAAA,MAAM,WAAW,QAAO,UAAU,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAqBpD,CAAC;AAcH;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,GAAI,YAAY,SAAS,KAAG,MAAM,GAAG,SASpD,CAAC;AAEF;;;;;;;;GAQG;AACH,QAAA,MAAM,QAAQ,GAAI,SAAS,cAAc,EAAE,KAAG,IAAI,CAAC,GAAG,EAiBrD,CAAC;AAEF;;;;;;;;;GASG;AACH,QAAA,MAAM,UAAU,GAAI,YAAY,MAAM,EAAE,OAAO,IAAI,CAAC,GAAG,EAAE,KAAG,MAgB3D,CAAC;AAEF,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC"}