@codeperfect/eslint-plugin 1.0.0 → 2.1.0

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

@@ -0,0 +1,182 @@
+import { parseFenceLine, removeEmptyFences } from "./empty-fence-fixes.js";
+/**
+ * Applies a language to a fence line when needed.
+ * @param context Fence state and line data.
+ * @returns Updated line and fence state.
+ * @example
+ * ```typescript
+ * const result = applyFenceLanguage({ inFence: false, line: " * ```" });
+ * ```
+ */
+function applyFenceLanguage(context) {
+    const { inFence, line } = context;
+    const fenceInfo = parseFenceLine(line);
+    if (fenceInfo === void 0) {
+        return { inFence, line };
+    }
+    const shouldAddLanguage = !inFence && fenceInfo.language.length === 0;
+    const nextLine = shouldAddLanguage
+        ? `${fenceInfo.leading}\`\`\`typescript`
+        : line;
+    return { inFence: !inFence, line: nextLine };
+}
+/**
+ * Builds a full example with a fenced block when missing entirely.
+ * @param example Example metadata.
+ * @returns Example text with a fenced block.
+ * @example
+ * ```typescript
+ * const text = buildMissingFenceFix(example);
+ * ```
+ */
+function buildMissingFenceFix(example) {
+    const contentLines = normalizeContentLines({
+        content: example.content,
+        prefix: example.prefix,
+    });
+    return [
+        `${example.prefix}@example`,
+        `${example.prefix}\`\`\`typescript`,
+        ...contentLines.map((contentLine) => contentLine.length > 0
+            ? `${example.prefix} ${contentLine}`
+            : example.prefix),
+        `${example.prefix}\`\`\``,
+    ].join("\n");
+}
+/**
+ * Adds missing languages to existing fenced blocks.
+ * @param original Original comment text.
+ * @returns Updated comment text when changes are made.
+ * @example
+ * ```typescript
+ * const updated = buildMissingLanguageFix("* ```\n* ok\n* ```");
+ * ```
+ */
+function buildMissingLanguageFix(original) {
+    const lineBreak = original.includes("\r\n") ? "\r\n" : "\n";
+    const lines = original.split(/\r?\n/u);
+    let inFence = false;
+    const updatedLines = lines.map((line) => {
+        const { inFence: nextInFence, line: nextLine } = applyFenceLanguage({
+            inFence,
+            line,
+        });
+        inFence = nextInFence;
+        return nextLine;
+    });
+    const updated = updatedLines.join(lineBreak);
+    return updated === original ? void 0 : updated;
+}
+/**
+ * Builds a fixer function for the report.
+ * @param context Fixer context details.
+ * @returns Fixer function for ESLint.
+ * @example
+ * ```typescript
+ * const fixer = createFixer(context);
+ * ```
+ */
+function createFixer(context) {
+    const { absoluteEnd, absoluteStart } = context;
+    return (fixer) => {
+        const updated = getUpdatedExampleText(context);
+        if (updated === void 0) {
+            return void 0;
+        }
+        return fixer.replaceTextRange([absoluteStart, absoluteEnd], updated);
+    };
+}
+/**
+ * Extracts trailing whitespace from the original example range.
+ * @param original Original example text.
+ * @returns Trailing whitespace to preserve.
+ * @example
+ * ```typescript
+ * const suffix = getTrailingWhitespace("* @example ok\n ");
+ * ```
+ */
+function getTrailingWhitespace(original) {
+    const trailingMatch = /(?:\r?\n[ \t]*)$/u.exec(original);
+    return trailingMatch?.[0] ?? "";
+}
+/**
+ * Resolves the updated text for an example.
+ * @param context Fixer context details.
+ * @returns Fixed example text when a change is required.
+ * @example
+ * ```typescript
+ * const text = getUpdatedExampleText(context);
+ * ```
+ */
+function getUpdatedExampleText(context) {
+    const { absoluteEnd, absoluteStart, example, hasOtherExamples, problem, sourceText, } = context;
+    const original = sourceText.slice(absoluteStart, absoluteEnd);
+    if (problem === "missingLanguage") {
+        return buildMissingLanguageFix(original);
+    }
+    if (problem === "emptyExample") {
+        return resolveEmptyExampleFix({ example, hasOtherExamples, original });
+    }
+    const fixed = buildMissingFenceFix(example);
+    const trailingWhitespace = getTrailingWhitespace(original);
+    return trailingWhitespace.length > 0
+        ? `${fixed}${trailingWhitespace}`
+        : fixed;
+}
+/**
+ * Normalizes raw example content lines before fence wrapping.
+ * @param context Prefix and raw content.
+ * @returns Content lines safe to wrap in a fenced block.
+ * @example
+ * ```typescript
+ * const lines = normalizeContentLines({ content: "a\n * b", prefix: " * " });
+ * ```
+ */
+function normalizeContentLines(context) {
+    const { content, prefix } = context;
+    const lines = content.length > 0 ? content.split(/\r?\n/u) : [];
+    return lines
+        .map((line) => stripContentPrefix({ line, prefix }))
+        .map((line) => line.replace(/\s*\*\/[ \t]*$/u, ""));
+}
+/**
+ * Resolves the appropriate fix for empty examples.
+ * @param context Empty example fix details.
+ * @returns Fixed example text when a change is required.
+ * @example
+ * ```typescript
+ * const text = resolveEmptyExampleFix(context);
+ * ```
+ */
+function resolveEmptyExampleFix(context) {
+    const { example, hasOtherExamples, original } = context;
+    const cleaned = removeEmptyFences(original);
+    if (cleaned !== void 0) {
+        return cleaned;
+    }
+    if (hasOtherExamples) {
+        return "";
+    }
+    if (original.includes("```")) {
+        return void 0;
+    }
+    return buildMissingFenceFix(example);
+}
+/**
+ * Removes JSDoc line prefixes from example content.
+ * @param context Prefix and source line.
+ * @returns Cleaned content line.
+ * @example
+ * ```typescript
+ * const line = stripContentPrefix({ line: " * value", prefix: " * " });
+ * ```
+ */
+function stripContentPrefix(context) {
+    const { line, prefix } = context;
+    if (line.startsWith(prefix)) {
+        return line.slice(prefix.length);
+    }
+    return line.replace(/^\s*\*\s?/u, "");
+}
+export { buildMissingFenceFix, buildMissingLanguageFix, createFixer };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fixes.js","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/fixes.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Example, Problem } from \"./types\";\n\nimport { parseFenceLine, removeEmptyFences } from \"./empty-fence-fixes\";\n\n/** Type definition for rule data. */\ninterface EmptyExampleFixContext {\n  /** Example field value. */\n  example: Example;\n  /** HasOtherExamples field value. */\n  hasOtherExamples: boolean;\n  /** Original field value. */\n  original: string;\n}\n\n/** Type definition for rule data. */\ninterface FenceLanguageContext {\n  /** InFence field value. */\n  inFence: boolean;\n  /** Line field value. */\n  line: string;\n}\n\n/** Type definition for rule data. */\ninterface FenceResult {\n  /** InFence field value. */\n  inFence: boolean;\n  /** Line field value. */\n  line: string;\n}\n\n/** Type definition for rule data. */\ninterface FixerContext {\n  /** AbsoluteEnd field value. */\n  absoluteEnd: number;\n  /** AbsoluteStart field value. */\n  absoluteStart: number;\n  /** Example field value. */\n  example: Example;\n  /** HasOtherExamples field value. */\n  hasOtherExamples: boolean;\n  /** Problem field value. */\n  problem: Problem;\n  /** SourceText field value. */\n  sourceText: string;\n}\n\n/** Type definition for rule data. */\ninterface NormalizeContentLinesContext {\n  /** Content field value. */\n  content: string;\n  /** Prefix field value. */\n  prefix: string;\n}\n\n/** Type definition for rule data. */\ninterface StripContentPrefixContext {\n  /** Line field value. */\n  line: string;\n  /** Prefix field value. */\n  prefix: string;\n}\n\n/**\n * Applies a language to a fence line when needed.\n * @param context Fence state and line data.\n * @returns Updated line and fence state.\n * @example\n * ```typescript\n * const result = applyFenceLanguage({ inFence: false, line: \" * ```\" });\n * ```\n */\nfunction applyFenceLanguage(context: FenceLanguageContext): FenceResult {\n  const { inFence, line } = context;\n  const fenceInfo = parseFenceLine(line);\n\n  if (fenceInfo === void 0) {\n    return { inFence, line };\n  }\n\n  const shouldAddLanguage = !inFence && fenceInfo.language.length === 0;\n  const nextLine = shouldAddLanguage\n    ? `${fenceInfo.leading}\\`\\`\\`typescript`\n    : line;\n\n  return { inFence: !inFence, line: nextLine };\n}\n\n/**\n * Builds a full example with a fenced block when missing entirely.\n * @param example Example metadata.\n * @returns Example text with a fenced block.\n * @example\n * ```typescript\n * const text = buildMissingFenceFix(example);\n * ```\n */\nfunction buildMissingFenceFix(example: Example): string {\n  const contentLines = normalizeContentLines({\n    content: example.content,\n    prefix: example.prefix,\n  });\n\n  return [\n    `${example.prefix}@example`,\n    `${example.prefix}\\`\\`\\`typescript`,\n    ...contentLines.map((contentLine) =>\n      contentLine.length > 0\n        ? `${example.prefix} ${contentLine}`\n        : example.prefix,\n    ),\n    `${example.prefix}\\`\\`\\``,\n  ].join(\"\\n\");\n}\n\n/**\n * Adds missing languages to existing fenced blocks.\n * @param original Original comment text.\n * @returns Updated comment text when changes are made.\n * @example\n * ```typescript\n * const updated = buildMissingLanguageFix(\"* ```\\n* ok\\n* ```\");\n * ```\n */\nfunction buildMissingLanguageFix(original: string): string | undefined {\n  const lineBreak = original.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\n  const lines = original.split(/\\r?\\n/u);\n  let inFence = false;\n\n  const updatedLines = lines.map((line) => {\n    const { inFence: nextInFence, line: nextLine } = applyFenceLanguage({\n      inFence,\n      line,\n    });\n    inFence = nextInFence;\n    return nextLine;\n  });\n\n  const updated = updatedLines.join(lineBreak);\n\n  return updated === original ? void 0 : updated;\n}\n\n/**\n * Builds a fixer function for the report.\n * @param context Fixer context details.\n * @returns Fixer function for ESLint.\n * @example\n * ```typescript\n * const fixer = createFixer(context);\n * ```\n */\nfunction createFixer(\n  context: FixerContext,\n): (fixer: Rule.RuleFixer) => Rule.Fix | undefined {\n  const { absoluteEnd, absoluteStart } = context;\n\n  return (fixer: Rule.RuleFixer): Rule.Fix | undefined => {\n    const updated = getUpdatedExampleText(context);\n\n    if (updated === void 0) {\n      return void 0;\n    }\n\n    return fixer.replaceTextRange([absoluteStart, absoluteEnd], updated);\n  };\n}\n\n/**\n * Extracts trailing whitespace from the original example range.\n * @param original Original example text.\n * @returns Trailing whitespace to preserve.\n * @example\n * ```typescript\n * const suffix = getTrailingWhitespace(\"* @example ok\\n \");\n * ```\n */\nfunction getTrailingWhitespace(original: string): string {\n  const trailingMatch = /(?:\\r?\\n[ \\t]*)$/u.exec(original);\n\n  return trailingMatch?.[0] ?? \"\";\n}\n\n/**\n * Resolves the updated text for an example.\n * @param context Fixer context details.\n * @returns Fixed example text when a change is required.\n * @example\n * ```typescript\n * const text = getUpdatedExampleText(context);\n * ```\n */\nfunction getUpdatedExampleText(context: FixerContext): string | undefined {\n  const {\n    absoluteEnd,\n    absoluteStart,\n    example,\n    hasOtherExamples,\n    problem,\n    sourceText,\n  } = context;\n  const original = sourceText.slice(absoluteStart, absoluteEnd);\n\n  if (problem === \"missingLanguage\") {\n    return buildMissingLanguageFix(original);\n  }\n\n  if (problem === \"emptyExample\") {\n    return resolveEmptyExampleFix({ example, hasOtherExamples, original });\n  }\n\n  const fixed = buildMissingFenceFix(example);\n  const trailingWhitespace = getTrailingWhitespace(original);\n\n  return trailingWhitespace.length > 0\n    ? `${fixed}${trailingWhitespace}`\n    : fixed;\n}\n\n/**\n * Normalizes raw example content lines before fence wrapping.\n * @param context Prefix and raw content.\n * @returns Content lines safe to wrap in a fenced block.\n * @example\n * ```typescript\n * const lines = normalizeContentLines({ content: \"a\\n * b\", prefix: \" * \" });\n * ```\n */\nfunction normalizeContentLines(\n  context: NormalizeContentLinesContext,\n): string[] {\n  const { content, prefix } = context;\n  const lines = content.length > 0 ? content.split(/\\r?\\n/u) : [];\n\n  return lines\n    .map((line) => stripContentPrefix({ line, prefix }))\n    .map((line) => line.replace(/\\s*\\*\\/[ \\t]*$/u, \"\"));\n}\n\n/**\n * Resolves the appropriate fix for empty examples.\n * @param context Empty example fix details.\n * @returns Fixed example text when a change is required.\n * @example\n * ```typescript\n * const text = resolveEmptyExampleFix(context);\n * ```\n */\nfunction resolveEmptyExampleFix(\n  context: EmptyExampleFixContext,\n): string | undefined {\n  const { example, hasOtherExamples, original } = context;\n  const cleaned = removeEmptyFences(original);\n\n  if (cleaned !== void 0) {\n    return cleaned;\n  }\n\n  if (hasOtherExamples) {\n    return \"\";\n  }\n\n  if (original.includes(\"```\")) {\n    return void 0;\n  }\n\n  return buildMissingFenceFix(example);\n}\n\n/**\n * Removes JSDoc line prefixes from example content.\n * @param context Prefix and source line.\n * @returns Cleaned content line.\n * @example\n * ```typescript\n * const line = stripContentPrefix({ line: \" * value\", prefix: \" * \" });\n * ```\n */\nfunction stripContentPrefix(context: StripContentPrefixContext): string {\n  const { line, prefix } = context;\n\n  if (line.startsWith(prefix)) {\n    return line.slice(prefix.length);\n  }\n\n  return line.replace(/^\\s*\\*\\s?/u, \"\");\n}\n\nexport { buildMissingFenceFix, buildMissingLanguageFix, createFixer };\n"]}

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

@@ -0,0 +1,3 @@
+export { requireExampleLanguageRule } from "./rule.js";
+export type { Comment, Example, Problem } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,QAAQ,CAAC;AACpD,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC"}

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

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

package/dist/{docs → domain/docs}/require-example-language/reporting.d.ts

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import type { Comment, Example, Problem } from "./types";
+import type { Comment, Example, Problem } from "./types.js";
 /** Type definition for rule data. */
 interface ReportDescriptorContext {
     /** Comment field value. */

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

@@ -0,0 +1 @@
+{"version":3,"file":"reporting.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/reporting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAuBzD,qCAAqC;AACrC,UAAU,uBAAuB;IAC/B,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IAEjB,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IAEjB,oCAAoC;IACpC,gBAAgB,EAAE,OAAO,CAAC;IAE1B,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IAEjB,8BAA8B;IAC9B,UAAU,EAAE,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;CAC5C;AAED,qCAAqC;AACrC,UAAU,oBAAoB;IAC5B,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IAEjB,2BAA2B;IAC3B,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC;IAE1B,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IAEjB,oCAAoC;IACpC,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAuBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,iBAAS,qBAAqB,CAC5B,OAAO,EAAE,uBAAuB,GAC/B,IAAI,CAAC,gBAAgB,CA6BvB;AA0FD;;;;;;;GAOG;AACH,iBAAS,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAiB1D;AAED,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,CAAC"}

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

@@ -0,0 +1,148 @@
+import { checkExampleContent } from "./examples.js";
+import { createFixer } from "./fixes.js";
+/**
+ * Build a report descriptor for a single example problem.
+ * @param context Input context value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const descriptor = buildReportDescriptor({
+ *   comment: { type: "Block", value: "*" } as Comment,
+ *   example: {
+ *     content: "",
+ *     endIndex: 0,
+ *     endOffset: 0,
+ *     lineIndex: 0,
+ *     prefix: " * ",
+ *     startOffset: 0,
+ *   },
+ *   hasOtherExamples: false,
+ *   problem: "missingFence",
+ *   sourceCode: {} as Rule.SourceCode,
+ * });
+ * ```
+ */
+function buildReportDescriptor(context) {
+    const { comment, example, hasOtherExamples, problem, sourceCode } = context;
+    const fix = getFixerForExample({
+        comment,
+        example,
+        hasOtherExamples,
+        problem,
+        sourceCode,
+    });
+    const reportFix = fix === void 0
+        ? void 0
+        : (fixer) => fix(fixer) ?? [];
+    const loc = getReportLocation(comment, example);
+    if (loc !== void 0) {
+        return {
+            fix: reportFix,
+            loc,
+            messageId: problem,
+        };
+    }
+    return {
+        fix: reportFix,
+        messageId: problem,
+        node: sourceCode.ast,
+    };
+}
+/**
+ * Resolve a fixer for the report when ranges are available.
+ * @param context Input context value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * const fixer = getFixerForExample({
+ *   comment: { type: "Block", value: "*" } as Comment,
+ *   example: {
+ *     content: "",
+ *     endIndex: 0,
+ *     endOffset: 0,
+ *     lineIndex: 0,
+ *     prefix: " * ",
+ *     startOffset: 0,
+ *   },
+ *   hasOtherExamples: false,
+ *   problem: "missingLanguage",
+ *   sourceCode: {} as Rule.SourceCode,
+ * });
+ * ```
+ */
+function getFixerForExample(context) {
+    const { comment, example, hasOtherExamples, problem, sourceCode } = context;
+    const commentOffset = comment.range?.[0];
+    const commentValueOffset = typeof commentOffset === "number" ? commentOffset + 2 : void 0;
+    const absoluteStart = typeof commentValueOffset === "number"
+        ? commentValueOffset + example.startOffset
+        : void 0;
+    const absoluteEnd = typeof commentValueOffset === "number"
+        ? commentValueOffset + example.endOffset
+        : void 0;
+    if (typeof absoluteStart !== "number" || typeof absoluteEnd !== "number") {
+        return void 0;
+    }
+    return createFixer({
+        absoluteEnd,
+        absoluteStart,
+        example,
+        hasOtherExamples,
+        problem,
+        sourceText: sourceCode.text,
+    });
+}
+/**
+ * Resolve the report location for a matched example.
+ * @param comment Comment node containing the example.
+ * @param example Example metadata.
+ * @returns Report location when available.
+ * @example
+ * ```typescript
+ * const loc = getReportLocation({} as Comment, {
+ *    content: "",
+ *    endIndex: 0,
+ *    endOffset: 0,
+ *    lineIndex: 0,
+ *    prefix: "",
+ *    startOffset: 0,
+ * });
+ * ```
+ */
+function getReportLocation(comment, example) {
+    const line = typeof comment.loc?.start.line === "number"
+        ? comment.loc.start.line + example.lineIndex
+        : void 0;
+    if (line === void 0) {
+        return void 0;
+    }
+    return {
+        end: { column: 1, line },
+        start: { column: 0, line },
+    };
+}
+/**
+ * Reports a single example when it violates the rule.
+ * @param context Report details for this example.
+ * @example
+ * ```typescript
+ * reportExample(context);
+ * ```
+ */
+function reportExample(context) {
+    const { comment, context: ruleContext, example, hasOtherExamples } = context;
+    const problem = checkExampleContent(example.content);
+    if (problem === void 0) {
+        return;
+    }
+    const descriptor = buildReportDescriptor({
+        comment,
+        example,
+        hasOtherExamples,
+        problem,
+        sourceCode: ruleContext.sourceCode,
+    });
+    ruleContext.report(descriptor);
+}
+export { buildReportDescriptor, reportExample };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reporting.js","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/reporting.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\n\nimport type { Comment, Example, Problem } from \"./types\";\n\nimport { checkExampleContent } from \"./examples\";\nimport { createFixer } from \"./fixes\";\n\n/** Type definition for rule data. */\ninterface FixerLookupContext {\n  /** Comment field value. */\n  comment: Comment;\n\n  /** Example field value. */\n  example: Example;\n\n  /** HasOtherExamples field value. */\n  hasOtherExamples: boolean;\n\n  /** Problem field value. */\n  problem: Problem;\n\n  /** SourceCode field value. */\n  sourceCode: Rule.RuleContext[\"sourceCode\"];\n}\n\n/** Type definition for rule data. */\ninterface ReportDescriptorContext {\n  /** Comment field value. */\n  comment: Comment;\n\n  /** Example field value. */\n  example: Example;\n\n  /** HasOtherExamples field value. */\n  hasOtherExamples: boolean;\n\n  /** Problem field value. */\n  problem: Problem;\n\n  /** SourceCode field value. */\n  sourceCode: Rule.RuleContext[\"sourceCode\"];\n}\n\n/** Type definition for rule data. */\ninterface ReportExampleContext {\n  /** Comment field value. */\n  comment: Comment;\n\n  /** Context field value. */\n  context: Rule.RuleContext;\n\n  /** Example field value. */\n  example: Example;\n\n  /** HasOtherExamples field value. */\n  hasOtherExamples: boolean;\n}\n\n/** Type definition for rule data. */\ninterface ReportLocation {\n  /** End field value. */\n  end: {\n    /** Column field value. */\n    column: number;\n\n    /** Line field value. */\n    line: number;\n  };\n\n  /** Start field value. */\n  start: {\n    /** Column field value. */\n    column: number;\n\n    /** Line field value. */\n    line: number;\n  };\n}\n\n/**\n * Build a report descriptor for a single example problem.\n * @param context Input context value.\n * @returns Return value output.\n * @example\n * ```typescript\n * const descriptor = buildReportDescriptor({\n *   comment: { type: \"Block\", value: \"*\" } as Comment,\n *   example: {\n *     content: \"\",\n *     endIndex: 0,\n *     endOffset: 0,\n *     lineIndex: 0,\n *     prefix: \" * \",\n *     startOffset: 0,\n *   },\n *   hasOtherExamples: false,\n *   problem: \"missingFence\",\n *   sourceCode: {} as Rule.SourceCode,\n * });\n * ```\n */\nfunction buildReportDescriptor(\n  context: ReportDescriptorContext,\n): Rule.ReportDescriptor {\n  const { comment, example, hasOtherExamples, problem, sourceCode } = context;\n  const fix = getFixerForExample({\n    comment,\n    example,\n    hasOtherExamples,\n    problem,\n    sourceCode,\n  });\n  const reportFix =\n    fix === void 0\n      ? void 0\n      : (fixer: Rule.RuleFixer): Iterable<Rule.Fix> | Rule.Fix =>\n          fix(fixer) ?? [];\n  const loc = getReportLocation(comment, example);\n\n  if (loc !== void 0) {\n    return {\n      fix: reportFix,\n      loc,\n      messageId: problem,\n    };\n  }\n\n  return {\n    fix: reportFix,\n    messageId: problem,\n    node: sourceCode.ast,\n  };\n}\n\n/**\n * Resolve a fixer for the report when ranges are available.\n * @param context Input context value.\n * @returns Return value output.\n * @example\n * ```typescript\n * const fixer = getFixerForExample({\n *   comment: { type: \"Block\", value: \"*\" } as Comment,\n *   example: {\n *     content: \"\",\n *     endIndex: 0,\n *     endOffset: 0,\n *     lineIndex: 0,\n *     prefix: \" * \",\n *     startOffset: 0,\n *   },\n *   hasOtherExamples: false,\n *   problem: \"missingLanguage\",\n *   sourceCode: {} as Rule.SourceCode,\n * });\n * ```\n */\nfunction getFixerForExample(\n  context: FixerLookupContext,\n): ((fixer: Rule.RuleFixer) => Rule.Fix | undefined) | undefined {\n  const { comment, example, hasOtherExamples, problem, sourceCode } = context;\n  const commentOffset = comment.range?.[0];\n  const commentValueOffset =\n    typeof commentOffset === \"number\" ? commentOffset + 2 : void 0;\n  const absoluteStart =\n    typeof commentValueOffset === \"number\"\n      ? commentValueOffset + example.startOffset\n      : void 0;\n  const absoluteEnd =\n    typeof commentValueOffset === \"number\"\n      ? commentValueOffset + example.endOffset\n      : void 0;\n\n  if (typeof absoluteStart !== \"number\" || typeof absoluteEnd !== \"number\") {\n    return void 0;\n  }\n\n  return createFixer({\n    absoluteEnd,\n    absoluteStart,\n    example,\n    hasOtherExamples,\n    problem,\n    sourceText: sourceCode.text,\n  });\n}\n\n/**\n * Resolve the report location for a matched example.\n * @param comment Comment node containing the example.\n * @param example Example metadata.\n * @returns Report location when available.\n * @example\n * ```typescript\n * const loc = getReportLocation({} as Comment, {\n *    content: \"\",\n *    endIndex: 0,\n *    endOffset: 0,\n *    lineIndex: 0,\n *    prefix: \"\",\n *    startOffset: 0,\n * });\n * ```\n */\nfunction getReportLocation(\n  comment: Comment,\n  example: Example,\n): ReportLocation | undefined {\n  const line =\n    typeof comment.loc?.start.line === \"number\"\n      ? comment.loc.start.line + example.lineIndex\n      : void 0;\n\n  if (line === void 0) {\n    return void 0;\n  }\n\n  return {\n    end: { column: 1, line },\n    start: { column: 0, line },\n  };\n}\n\n/**\n * Reports a single example when it violates the rule.\n * @param context Report details for this example.\n * @example\n * ```typescript\n * reportExample(context);\n * ```\n */\nfunction reportExample(context: ReportExampleContext): void {\n  const { comment, context: ruleContext, example, hasOtherExamples } = context;\n  const problem = checkExampleContent(example.content);\n\n  if (problem === void 0) {\n    return;\n  }\n\n  const descriptor = buildReportDescriptor({\n    comment,\n    example,\n    hasOtherExamples,\n    problem,\n    sourceCode: ruleContext.sourceCode,\n  });\n\n  ruleContext.report(descriptor);\n}\n\nexport { buildReportDescriptor, reportExample };\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAKnC;;GAEG;AACH,QAAA,MAAM,0BAA0B,EAAE,IAAI,CAAC,UAoCtC,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

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

@@ -0,0 +1,37 @@
+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: {
+            description: "Require @example tags to use fenced code blocks with a language.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/require-example-language.md",
+        },
+        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

@@ -0,0 +1,4 @@
+import type { Rule } from "eslint";
+/** Rule module enforcing single-line JSDoc when it fits. */
+export declare const singleLineJsdocRule: Rule.RuleModule;
+//# sourceMappingURL=rule.d.ts.map

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;AAiQnC,4DAA4D;AAC5D,eAAO,MAAM,mBAAmB,EAAE,IAAI,CAAC,UAyCtC,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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVsZS5lZGdlLWNhc2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2RvbWFpbi9kb2NzL3NpbmdsZS1saW5lLWpzZG9jL3J1bGUuZWRnZS1jYXNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFFN0MsOERBQThEO0FBQzlELE1BQU0sNEJBQTRCLEdBQUcsbUJBQW1CLENBQUM7QUFFekQsT0FBTyxFQUFFLDRCQUE0QixFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBzaW5nbGVMaW5lSnNkb2NSdWxlIH0gZnJvbSBcIi4vcnVsZVwiO1xyXG5cclxuLyoqIENvbXBhbmlvbiBtb2R1bGUgZm9yIHNpbmdsZS1saW5lLWpzZG9jIGVkZ2UtY2FzZSB0ZXN0cy4gKi9cclxuY29uc3Qgc2luZ2xlTGluZUpzZG9jUnVsZUVkZ2VDYXNlcyA9IHNpbmdsZUxpbmVKc2RvY1J1bGU7XHJcblxyXG5leHBvcnQgeyBzaW5nbGVMaW5lSnNkb2NSdWxlRWRnZUNhc2VzIH07XHJcbiJdfQ==