@codeperfect/eslint-plugin 1.0.0 → 2.0.0

package/dist/domain/docs/require-example-language/rule.js

@@ -0,0 +1,34 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation.js";
+import { getExamples } from "./examples.js";
+import { reportExample } from "./reporting.js";
+/**
+ * ESLint rule requiring \@example tags to use fenced code blocks with a language.
+ */
+const requireExampleLanguageRule = {
+    create(context) {
+        const { sourceCode } = context;
+        for (const comment of sourceCode.getAllComments()) {
+            if (comment.type === "Block" && comment.value.startsWith("*")) {
+                const examples = getExamples(comment.value);
+                const hasOtherExamples = examples.length > 1;
+                for (const example of examples) {
+                    reportExample({ comment, context, example, hasOtherExamples });
+                }
+            }
+        }
+        return {};
+    },
+    meta: {
+        docs: createRuleDocumentation("require-example-language", "Require @example tags to use fenced code blocks with a language."),
+        fixable: "code",
+        messages: {
+            emptyExample: "@example must include example content.",
+            missingFence: "@example must include a fenced code block with a language (e.g. ```typescript).",
+            missingLanguage: "@example fenced code blocks must specify a language (e.g. ```typescript).",
+        },
+        schema: [],
+        type: "problem",
+    },
+};
+export { requireExampleLanguageRule };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/docs/require-example-language/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/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,OAAO;IACf,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAC;IAEhB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,6BAA6B;IAC7B,SAAS,EAAE,MAAM,CAAC;IAElB,6BAA6B;IAC7B,SAAS,EAAE,MAAM,CAAC;IAElB,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAC;IAEf,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,qCAAqC;AACrC,KAAK,OAAO,GAAG,cAAc,GAAG,cAAc,GAAG,iBAAiB,CAAC;AAEnE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/domain/docs/require-example-language/types.js

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

package/dist/domain/docs/single-line-jsdoc/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/single-line-jsdoc/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/docs/single-line-jsdoc/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/single-line-jsdoc/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAoQnC,4DAA4D;AAC5D,QAAA,MAAM,mBAAmB,EAAE,IAAI,CAAC,UAmC/B,CAAC;AAEF,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/domain/docs/single-line-jsdoc/rule.edge-cases.d.ts

@@ -0,0 +1,4 @@
+/** Companion module for single-line-jsdoc edge-case tests. */
+declare const singleLineJsdocRuleEdgeCases: import("eslint").Rule.RuleModule;
+export { singleLineJsdocRuleEdgeCases };
+//# sourceMappingURL=rule.edge-cases.d.ts.map

package/dist/domain/docs/single-line-jsdoc/rule.edge-cases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.edge-cases.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/single-line-jsdoc/rule.edge-cases.ts"],"names":[],"mappings":"AAEA,8DAA8D;AAC9D,QAAA,MAAM,4BAA4B,kCAAsB,CAAC;AAEzD,OAAO,EAAE,4BAA4B,EAAE,CAAC"}

package/dist/domain/docs/single-line-jsdoc/rule.edge-cases.js

@@ -0,0 +1,5 @@
+import { singleLineJsdocRule } from "./rule.js";
+/** Companion module for single-line-jsdoc edge-case tests. */
+const singleLineJsdocRuleEdgeCases = singleLineJsdocRule;
+export { singleLineJsdocRuleEdgeCases };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5lZGdlLWNhc2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RvbWFpbi9kb2NzL3NpbmdsZS1saW5lLWpzZG9jL3J1bGUuZWRnZS1jYXNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFFN0MsOERBQThEO0FBQzlELE1BQU0sNEJBQTRCLEdBQUcsbUJBQW1CLENBQUM7QUFFekQsT0FBTyxFQUFFLDRCQUE0QixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzaW5nbGVMaW5lSnNkb2NSdWxlIH0gZnJvbSBcIi4vcnVsZVwiO1xyXG5cclxuLyoqIENvbXBhbmlvbiBtb2R1bGUgZm9yIHNpbmdsZS1saW5lLWpzZG9jIGVkZ2UtY2FzZSB0ZXN0cy4gKi9cclxuY29uc3Qgc2luZ2xlTGluZUpzZG9jUnVsZUVkZ2VDYXNlcyA9IHNpbmdsZUxpbmVKc2RvY1J1bGU7XHJcblxyXG5leHBvcnQgeyBzaW5nbGVMaW5lSnNkb2NSdWxlRWRnZUNhc2VzIH07Il19

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

@@ -0,0 +1,196 @@
+import { createRuleDocumentation } from "../../custom-rule-documentation.js";
+import { normalizeMaxLineLength, reportIfSingleLine, } from "./single-line-jsdoc-utilities.js";
+/**
+ * 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/domain/docs/single-line-jsdoc/rule.ts"],"names":[],"mappings":"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","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/domain/docs/single-line-jsdoc/rule.node-lookups.d.ts

@@ -0,0 +1,4 @@
+/** Companion module for single-line-jsdoc lookup edge-case tests. */
+declare const singleLineJsdocRuleNodeLookups: import("eslint").Rule.RuleModule;
+export { singleLineJsdocRuleNodeLookups };
+//# sourceMappingURL=rule.node-lookups.d.ts.map

package/dist/domain/docs/single-line-jsdoc/rule.node-lookups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.node-lookups.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/single-line-jsdoc/rule.node-lookups.ts"],"names":[],"mappings":"AAEA,qEAAqE;AACrE,QAAA,MAAM,8BAA8B,kCAAsB,CAAC;AAE3D,OAAO,EAAE,8BAA8B,EAAE,CAAC"}

package/dist/domain/docs/single-line-jsdoc/rule.node-lookups.js

@@ -0,0 +1,5 @@
+import { singleLineJsdocRule } from "./rule.js";
+/** Companion module for single-line-jsdoc lookup edge-case tests. */
+const singleLineJsdocRuleNodeLookups = singleLineJsdocRule;
+export { singleLineJsdocRuleNodeLookups };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5ub2RlLWxvb2t1cHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL2RvY3Mvc2luZ2xlLWxpbmUtanNkb2MvcnVsZS5ub2RlLWxvb2t1cHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sUUFBUSxDQUFDO0FBRTdDLHFFQUFxRTtBQUNyRSxNQUFNLDhCQUE4QixHQUFHLG1CQUFtQixDQUFDO0FBRTNELE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgc2luZ2xlTGluZUpzZG9jUnVsZSB9IGZyb20gXCIuL3J1bGVcIjtcclxuXHJcbi8qKiBDb21wYW5pb24gbW9kdWxlIGZvciBzaW5nbGUtbGluZS1qc2RvYyBsb29rdXAgZWRnZS1jYXNlIHRlc3RzLiAqL1xyXG5jb25zdCBzaW5nbGVMaW5lSnNkb2NSdWxlTm9kZUxvb2t1cHMgPSBzaW5nbGVMaW5lSnNkb2NSdWxlO1xyXG5cclxuZXhwb3J0IHsgc2luZ2xlTGluZUpzZG9jUnVsZU5vZGVMb29rdXBzIH07Il19

package/dist/domain/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/domain/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/domain/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 → domain/docs}/single-line-jsdoc/single-line-jsdoc-utilities.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import type { Comment } from "./single-line-jsdoc-content";
+import type { Comment } from "./single-line-jsdoc-content.js";
 /**
  * Normalizes normalizeMaxLineLength.
  * @param options Input options value.

package/dist/domain/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/domain/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/domain/docs/single-line-jsdoc/single-line-jsdoc-utilities.js

@@ -0,0 +1,140 @@
+import { getCollapsedContent } from "./single-line-jsdoc-content.js";
+/** 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/domain/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/domain/docs/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../../src/domain/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"}