@codeperfect/eslint-plugin 1.0.0 → 2.0.0

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

@@ -0,0 +1,181 @@
+import { getFenceLanguage, getInlineContent, getLineMeta, getPrefix, hasLineContent, } from "./example-utilities.js";
+/** Captures `@example` headers and bodies for analysis. */
+const examplePattern = /^(?<header>\s*\*?\s*@example\b[^\n]*)(?<body>[\s\S]*?)(?=^\s*\*?\s*@\w+|(?![\s\S]))/gmu;
+/**
+ * Updates fence state based on the detected language.
+ * @param state Current fence tracking state.
+ * @param language Fence language string.
+ * @returns Updated fence tracking state.
+ * @example
+ * ```typescript
+ * const next = updateFenceState(state, "typescript");
+ * ```
+ */
+const updateFenceState = (state, language) => {
+    if (!state.inFence) {
+        if (language.length === 0) {
+            return { ...state, missingLanguage: true, sawFence: true };
+        }
+        return {
+            ...state,
+            currentFenceHasContent: false,
+            inFence: true,
+            missingLanguage: false,
+            sawFence: true,
+        };
+    }
+    return {
+        ...state,
+        currentFenceHasContent: false,
+        hasEmptyFence: state.hasEmptyFence || !state.currentFenceHasContent,
+        inFence: false,
+        missingLanguage: false,
+        sawFence: true,
+    };
+};
+/**
+ * Updates fence tracking for a single example line.
+ * @param state Current fence tracking state.
+ * @param line Example line to inspect.
+ * @returns Updated fence tracking state.
+ * @example
+ * ```typescript
+ * const next = updateFenceStateForLine(state, " * ok");
+ * ```
+ */
+const updateFenceStateForLine = (state, line) => {
+    const language = getFenceLanguage(line);
+    if (language !== void 0) {
+        return updateFenceState(state, language);
+    }
+    if (state.inFence && hasLineContent(line)) {
+        return { ...state, currentFenceHasContent: true };
+    }
+    return state;
+};
+/**
+ * Analyzes fenced code blocks for missing language identifiers.
+ * @param content Example content to analyze.
+ * @returns Fence analysis results.
+ * @example
+ * ```typescript
+ * const analysis = analyzeFenceContent("```typescript\nconst value = 1;\n```");
+ * ```
+ */
+function analyzeFenceContent(content) {
+    const lines = content.split(/\r?\n/u);
+    let state = {
+        currentFenceHasContent: false,
+        hasEmptyFence: false,
+        inFence: false,
+        missingLanguage: false,
+        sawFence: false,
+    };
+    for (const line of lines) {
+        state = updateFenceStateForLine(state, line);
+        if (state.missingLanguage) {
+            break;
+        }
+    }
+    if (state.inFence && !state.currentFenceHasContent) {
+        state = { ...state, hasEmptyFence: true };
+    }
+    return {
+        hasEmptyFence: state.hasEmptyFence,
+        missingLanguage: state.missingLanguage,
+        sawFence: state.sawFence,
+    };
+}
+/**
+ * Builds example content from an inline header and body lines.
+ * @param context Example header and body lines.
+ * @returns Combined example content.
+ * @example
+ * ```typescript
+ * const content = buildExampleContent({ body: "* ok", header: "* @example" });
+ * ```
+ */
+function buildExampleContent(context) {
+    const { body, header } = context;
+    const inlineContent = getInlineContent(header);
+    if (inlineContent.length > 0) {
+        return `${inlineContent}\n${body}`;
+    }
+    return body;
+}
+/**
+ * Builds an Example from a regex match and raw comment value.
+ * @param match Regex match from the example pattern.
+ * @param commentValue Raw comment value.
+ * @returns Example metadata extracted from the match.
+ * @example
+ * ```typescript
+ * const example = buildExampleFromMatch(match, commentValue);
+ * ```
+ */
+function buildExampleFromMatch(match, commentValue) {
+    const [full] = match;
+    const header = match.groups?.["header"] ?? "";
+    const body = match.groups?.["body"] ?? "";
+    const startOffset = match.index ?? 0;
+    const content = buildExampleContent({ body, header });
+    const prefix = getPrefix(header);
+    const { endIndex, endOffset, lineIndex } = getLineMeta({
+        commentValue,
+        full,
+        startOffset,
+    });
+    return {
+        content: content.trim(),
+        endIndex,
+        endOffset,
+        lineIndex,
+        prefix,
+        startOffset,
+    };
+}
+/**
+ * Checks example content for required fences and language.
+ * @param content Example content to inspect.
+ * @returns Problem identifier when the content is invalid.
+ * @example
+ * ```typescript
+ * const problem = checkExampleContent("```typescript\nconst ok = true;\n```");
+ * ```
+ */
+function checkExampleContent(content) {
+    if (content.trim().length === 0) {
+        return "emptyExample";
+    }
+    const { hasEmptyFence, missingLanguage, sawFence } = analyzeFenceContent(content);
+    if (missingLanguage) {
+        return "missingLanguage";
+    }
+    if (sawFence && hasEmptyFence) {
+        return "emptyExample";
+    }
+    if (!sawFence) {
+        return "missingFence";
+    }
+    return void 0;
+}
+/**
+ * Extracts all `@example` entries from a JSDoc comment value.
+ * Uses a multiline regex to capture the header and following lines
+ * until the next JSDoc tag or the end of the comment.
+ * @param commentValue Raw comment value.
+ * @returns Extracted examples.
+ * @example
+ * ```typescript
+ * const examples = getExamples("* @example\n* ```typescript\n* ok\n* ```");
+ * ```
+ */
+function getExamples(commentValue) {
+    const examples = [];
+    for (const match of commentValue.matchAll(examplePattern)) {
+        examples.push(buildExampleFromMatch(match, commentValue));
+    }
+    return examples;
+}
+export { buildExampleFromMatch, checkExampleContent, getExamples };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"examples.js","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/examples.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Example, Problem } from \"./types\";\n\nimport {\n  getFenceLanguage,\n  getInlineContent,\n  getLineMeta,\n  getPrefix,\n  hasLineContent,\n} from \"./example-utilities\";\n\n/** Captures `@example` headers and bodies for analysis. */\nconst examplePattern =\n  /^(?<header>\\s*\\*?\\s*@example\\b[^\\n]*)(?<body>[\\s\\S]*?)(?=^\\s*\\*?\\s*@\\w+|(?![\\s\\S]))/gmu;\n\n/** Type definition for rule data. */\ninterface FenceState {\n  /** CurrentFenceHasContent field value. */\n  currentFenceHasContent: boolean;\n\n  /** HasEmptyFence field value. */\n  hasEmptyFence: boolean;\n\n  /** InFence field value. */\n  inFence: boolean;\n\n  /** MissingLanguage field value. */\n  missingLanguage: boolean;\n\n  /** SawFence field value. */\n  sawFence: boolean;\n}\n\n/**\n * Updates fence state based on the detected language.\n * @param state Current fence tracking state.\n * @param language Fence language string.\n * @returns Updated fence tracking state.\n * @example\n * ```typescript\n * const next = updateFenceState(state, \"typescript\");\n * ```\n */\nconst updateFenceState = (state: FenceState, language: string): FenceState => {\n  if (!state.inFence) {\n    if (language.length === 0) {\n      return { ...state, missingLanguage: true, sawFence: true };\n    }\n\n    return {\n      ...state,\n      currentFenceHasContent: false,\n      inFence: true,\n      missingLanguage: false,\n      sawFence: true,\n    };\n  }\n\n  return {\n    ...state,\n    currentFenceHasContent: false,\n    hasEmptyFence: state.hasEmptyFence || !state.currentFenceHasContent,\n    inFence: false,\n    missingLanguage: false,\n    sawFence: true,\n  };\n};\n\n/**\n * Updates fence tracking for a single example line.\n * @param state Current fence tracking state.\n * @param line Example line to inspect.\n * @returns Updated fence tracking state.\n * @example\n * ```typescript\n * const next = updateFenceStateForLine(state, \" * ok\");\n * ```\n */\nconst updateFenceStateForLine = (\n  state: FenceState,\n  line: string,\n): FenceState => {\n  const language = getFenceLanguage(line);\n\n  if (language !== void 0) {\n    return updateFenceState(state, language);\n  }\n\n  if (state.inFence && hasLineContent(line)) {\n    return { ...state, currentFenceHasContent: true };\n  }\n\n  return state;\n};\n\n/** Type definition for rule data. */\ninterface ExampleContentContext {\n  /** Body field value. */\n  body: string;\n\n  /** Header field value. */\n  header: string;\n}\n\n/** Type definition for rule data. */\ninterface FenceAnalysis {\n  /** HasEmptyFence field value. */\n  hasEmptyFence: boolean;\n\n  /** MissingLanguage field value. */\n  missingLanguage: boolean;\n\n  /** SawFence field value. */\n  sawFence: boolean;\n}\n\n/**\n * Analyzes fenced code blocks for missing language identifiers.\n * @param content Example content to analyze.\n * @returns Fence analysis results.\n * @example\n * ```typescript\n * const analysis = analyzeFenceContent(\"```typescript\\nconst value = 1;\\n```\");\n * ```\n */\nfunction analyzeFenceContent(content: string): FenceAnalysis {\n  const lines = content.split(/\\r?\\n/u);\n  let state: FenceState = {\n    currentFenceHasContent: false,\n    hasEmptyFence: false,\n    inFence: false,\n    missingLanguage: false,\n    sawFence: false,\n  };\n\n  for (const line of lines) {\n    state = updateFenceStateForLine(state, line);\n\n    if (state.missingLanguage) {\n      break;\n    }\n  }\n\n  if (state.inFence && !state.currentFenceHasContent) {\n    state = { ...state, hasEmptyFence: true };\n  }\n\n  return {\n    hasEmptyFence: state.hasEmptyFence,\n    missingLanguage: state.missingLanguage,\n    sawFence: state.sawFence,\n  };\n}\n\n/**\n * Builds example content from an inline header and body lines.\n * @param context Example header and body lines.\n * @returns Combined example content.\n * @example\n * ```typescript\n * const content = buildExampleContent({ body: \"* ok\", header: \"* @example\" });\n * ```\n */\nfunction buildExampleContent(context: ExampleContentContext): string {\n  const { body, header } = context;\n  const inlineContent = getInlineContent(header);\n\n  if (inlineContent.length > 0) {\n    return `${inlineContent}\\n${body}`;\n  }\n\n  return body;\n}\n\n/**\n * Builds an Example from a regex match and raw comment value.\n * @param match Regex match from the example pattern.\n * @param commentValue Raw comment value.\n * @returns Example metadata extracted from the match.\n * @example\n * ```typescript\n * const example = buildExampleFromMatch(match, commentValue);\n * ```\n */\nfunction buildExampleFromMatch(\n  match: RegExpMatchArray,\n  commentValue: string,\n): Example {\n  const [full] = match;\n  const header = match.groups?.[\"header\"] ?? \"\";\n  const body = match.groups?.[\"body\"] ?? \"\";\n  const startOffset = match.index ?? 0;\n  const content = buildExampleContent({ body, header });\n  const prefix = getPrefix(header);\n  const { endIndex, endOffset, lineIndex } = getLineMeta({\n    commentValue,\n    full,\n    startOffset,\n  });\n\n  return {\n    content: content.trim(),\n    endIndex,\n    endOffset,\n    lineIndex,\n    prefix,\n    startOffset,\n  };\n}\n\n/**\n * Checks example content for required fences and language.\n * @param content Example content to inspect.\n * @returns Problem identifier when the content is invalid.\n * @example\n * ```typescript\n * const problem = checkExampleContent(\"```typescript\\nconst ok = true;\\n```\");\n * ```\n */\nfunction checkExampleContent(content: string): Problem | undefined {\n  if (content.trim().length === 0) {\n    return \"emptyExample\";\n  }\n  const { hasEmptyFence, missingLanguage, sawFence } =\n    analyzeFenceContent(content);\n\n  if (missingLanguage) {\n    return \"missingLanguage\";\n  }\n\n  if (sawFence && hasEmptyFence) {\n    return \"emptyExample\";\n  }\n\n  if (!sawFence) {\n    return \"missingFence\";\n  }\n\n  return void 0;\n}\n\n/**\n * Extracts all `@example` entries from a JSDoc comment value.\n * Uses a multiline regex to capture the header and following lines\n * until the next JSDoc tag or the end of the comment.\n * @param commentValue Raw comment value.\n * @returns Extracted examples.\n * @example\n * ```typescript\n * const examples = getExamples(\"* @example\\n* ```typescript\\n* ok\\n* ```\");\n * ```\n */\nfunction getExamples(commentValue: string): Example[] {\n  const examples: Example[] = [];\n\n  for (const match of commentValue.matchAll(examplePattern)) {\n    examples.push(buildExampleFromMatch(match, commentValue));\n  }\n\n  return examples;\n}\n\nexport { buildExampleFromMatch, checkExampleContent, getExamples };\n"]}

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

@@ -1,5 +1,5 @@
 import type { Rule } from "eslint";
-import type { Example, Problem } from "./types";
+import type { Example, Problem } from "./types.js";
 /** Type definition for rule data. */
 interface FixerContext {
     /** AbsoluteEnd field value. */
@@ -44,6 +44,6 @@ declare function buildMissingLanguageFix(original: string): string | undefined;
  * const fixer = createFixer(context);
  * ```
  */
-declare function createFixer(context: FixerContext): (fixer: Rule.RuleFixer) => null | Rule.Fix;
+declare function createFixer(context: FixerContext): (fixer: Rule.RuleFixer) => Rule.Fix | undefined;
 export { buildMissingFenceFix, buildMissingLanguageFix, createFixer };
 //# sourceMappingURL=fixes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fixes.d.ts","sourceRoot":"","sources":["../../../../src/domain/docs/require-example-language/fixes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AA8BhD,qCAAqC;AACrC,UAAU,YAAY;IACpB,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,oCAAoC;IACpC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,2BAA2B;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,8BAA8B;IAC9B,UAAU,EAAE,MAAM,CAAC;CACpB;AA2CD;;;;;;;;GAQG;AACH,iBAAS,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAgBtD;AAED;;;;;;;;GAQG;AACH,iBAAS,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAiBrE;AAED;;;;;;;;GAQG;AACH,iBAAS,WAAW,CAClB,OAAO,EAAE,YAAY,GACpB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,KAAK,IAAI,CAAC,GAAG,GAAG,SAAS,CAYjD;AAwHD,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,WAAW,EAAE,CAAC"}

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(context: NormalizeContentLinesContext): 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 };"]}

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":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AA0EtC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAS,qBAAqB,CAC5B,OAAgC;IAEhC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IAC5E,MAAM,GAAG,GAAG,kBAAkB,CAAC;QAC7B,OAAO;QACP,OAAO;QACP,gBAAgB;QAChB,OAAO;QACP,UAAU;KACX,CAAC,CAAC;IACH,MAAM,SAAS,GACb,GAAG,KAAK,KAAK,CAAC;QACZ,CAAC,CAAC,KAAK,CAAC;QACR,CAAC,CAAC,CAAC,KAAqB,EAAiC,EAAE,CACvD,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;IACzB,MAAM,GAAG,GAAG,iBAAiB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAEhD,IAAI,GAAG,KAAK,KAAK,CAAC,EAAE,CAAC;QACnB,OAAO;YACL,GAAG,EAAE,SAAS;YACd,GAAG;YACH,SAAS,EAAE,OAAO;SACnB,CAAC;IACJ,CAAC;IAED,OAAO;QACL,GAAG,EAAE,SAAS;QACd,SAAS,EAAE,OAAO;QAClB,IAAI,EAAE,UAAU,CAAC,GAAgB;KAClC,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,SAAS,kBAAkB,CACzB,OAA2B;IAE3B,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,OAAO,CAAC;IAC5E,MAAM,aAAa,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IACzC,MAAM,kBAAkB,GACtB,OAAO,aAAa,KAAK,QAAQ,CAAC,CAAC,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IACjE,MAAM,aAAa,GACjB,OAAO,kBAAkB,KAAK,QAAQ;QACpC,CAAC,CAAC,kBAAkB,GAAG,OAAO,CAAC,WAAW;QAC1C,CAAC,CAAC,KAAK,CAAC,CAAC;IACb,MAAM,WAAW,GACf,OAAO,kBAAkB,KAAK,QAAQ;QACpC,CAAC,CAAC,kBAAkB,GAAG,OAAO,CAAC,SAAS;QACxC,CAAC,CAAC,KAAK,CAAC,CAAC;IAEb,IAAI,OAAO,aAAa,KAAK,QAAQ,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;QACzE,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,OAAO,WAAW,CAAC;QACjB,WAAW;QACX,aAAa;QACb,OAAO;QACP,gBAAgB;QAChB,OAAO;QACP,UAAU,EAAE,UAAU,CAAC,IAAI;KAC5B,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,SAAS,iBAAiB,CACxB,OAAgB,EAChB,OAAgB;IAEhB,MAAM,IAAI,GACR,OAAO,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,KAAK,QAAQ;QACzC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,GAAG,OAAO,CAAC,SAAS;QAC5C,CAAC,CAAC,KAAK,CAAC,CAAC;IAEb,IAAI,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACpB,OAAO,KAAK,CAAC,CAAC;IAChB,CAAC;IAED,OAAO;QACL,GAAG,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE;QACxB,KAAK,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE;KAC3B,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,aAAa,CAAC,OAA6B;IAClD,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC;IAC7E,MAAM,OAAO,GAAG,mBAAmB,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAErD,IAAI,OAAO,KAAK,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO;IACT,CAAC;IAED,MAAM,UAAU,GAAG,qBAAqB,CAAC;QACvC,OAAO;QACP,OAAO;QACP,gBAAgB;QAChB,OAAO;QACP,UAAU,EAAE,WAAW,CAAC,UAAU;KACnC,CAAC,CAAC;IAEH,WAAW,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;AACjC,CAAC;AAED,OAAO,EAAE,qBAAqB,EAAE,aAAa,EAAE,CAAC","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 as Rule.Node,\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;AAMnC;;GAEG;AACH,QAAA,MAAM,0BAA0B,EAAE,IAAI,CAAC,UAkCtC,CAAC;AAEF,OAAO,EAAE,0BAA0B,EAAE,CAAC"}