@codeperfect/eslint-plugin 1.0.0

package/dist/docs/require-example-language/empty-fence-fixes.js

@@ -0,0 +1,169 @@
+/**
+ * Closes a fence and updates the state.
+ * @param state Current fence state.
+ * @param line Fence line being processed.
+ * @returns Updated fence state.
+ * @example
+ * ```typescript
+ * const next = closeFence(state, " * ```");
+ * ```
+ */
+function closeFence(state, line) {
+    const fenceLines = [...state.currentFence, line];
+    const shouldRemove = !state.hasFenceContent;
+    const hasNonEmptyFence = state.hasNonEmptyFence || state.hasFenceContent;
+    const output = shouldRemove ? state.output : [...state.output, ...fenceLines];
+    return {
+        ...state,
+        currentFence: [],
+        hasFenceContent: false,
+        hasNonEmptyFence,
+        inFence: false,
+        output,
+        removed: state.removed || shouldRemove,
+    };
+}
+/**
+ * Finalizes fence output, including any unclosed fences.
+ * @param state Current fence state.
+ * @returns Finalized fence state.
+ * @example
+ * ```typescript
+ * const next = finalizeFenceState(state);
+ * ```
+ */
+function finalizeFenceState(state) {
+    if (state.inFence) {
+        return {
+            ...state,
+            currentFence: [],
+            hasFenceContent: false,
+            hasNonEmptyFence: state.hasNonEmptyFence || state.hasFenceContent,
+            inFence: false,
+            output: [...state.output, ...state.currentFence],
+        };
+    }
+    return state;
+}
+/**
+ * Determines whether a line contains non-empty content.
+ * @param line Line text to check.
+ * @returns True when the line contains content.
+ * @example
+ * ```typescript
+ * const ok = isContentLine(" * const ok = true;");
+ * ```
+ */
+function isContentLine(line) {
+    const trimmed = line.replace(/^\s*\*?\s?/u, "").trim();
+    return trimmed.length > 0;
+}
+/**
+ * Opens a new fenced block.
+ * @param state Current fence state.
+ * @param line Fence line being processed.
+ * @returns Updated fence state.
+ * @example
+ * ```typescript
+ * const next = openFence(state, " * ```typescript");
+ * ```
+ */
+function openFence(state, line) {
+    return {
+        ...state,
+        currentFence: [line],
+        hasFenceContent: false,
+        hasNonEmptyFence: state.hasNonEmptyFence,
+        inFence: true,
+    };
+}
+/**
+ * Parses a fence line for its leading prefix and language.
+ * @param line Fence line to parse.
+ * @returns Parsed fence info when matched.
+ * @example
+ * ```typescript
+ * const info = parseFenceLine(" * ```typescript");
+ * ```
+ */
+function parseFenceLine(line) {
+    const fenceMatch = /^(?<leading>\s*\*?\s*)```(?<lang>[^\s`]+)?[ \t]*$/u.exec(line);
+    if (fenceMatch === null) {
+        return void 0;
+    }
+    const groups = fenceMatch.groups ?? {};
+    const leading = typeof groups["leading"] === "string" ? groups["leading"] : "";
+    const language = typeof groups["lang"] === "string" ? groups["lang"] : "";
+    return { language, leading };
+}
+/**
+ * Removes fenced blocks that contain no content.
+ * @param original Original comment text.
+ * @returns Updated comment text when a fence is removed.
+ * @example
+ * ```typescript
+ * const updated = removeEmptyFences("* ```typescript\n* ```\n* ok");
+ * ```
+ */
+function removeEmptyFences(original) {
+    const lineBreak = original.includes("\r\n") ? "\r\n" : "\n";
+    const lines = original.split(/\r?\n/u);
+    const initialState = {
+        currentFence: [],
+        hasFenceContent: false,
+        hasNonEmptyFence: false,
+        inFence: false,
+        output: [],
+        removed: false,
+    };
+    let state = initialState;
+    for (const line of lines) {
+        const fenceInfo = parseFenceLine(line);
+        state =
+            fenceInfo === void 0
+                ? updateContentState(state, line)
+                : updateFenceState(state, line);
+    }
+    const finalState = finalizeFenceState(state);
+    return finalState.removed && finalState.hasNonEmptyFence
+        ? finalState.output.join(lineBreak)
+        : void 0;
+}
+/**
+ * Updates the state with a non-fence line.
+ * @param state Current fence state.
+ * @param line Line being processed.
+ * @returns Updated fence state.
+ * @example
+ * ```typescript
+ * const next = updateContentState(state, " * const ok = true;");
+ * ```
+ */
+function updateContentState(state, line) {
+    if (state.inFence) {
+        return {
+            ...state,
+            currentFence: [...state.currentFence, line],
+            hasFenceContent: state.hasFenceContent || isContentLine(line),
+        };
+    }
+    return { ...state, output: [...state.output, line] };
+}
+/**
+ * Opens or closes a fence based on the current state.
+ * @param state Current fence state.
+ * @param line Fence line being processed.
+ * @returns Updated fence state.
+ * @example
+ * ```typescript
+ * const next = updateFenceState(state, " * ```");
+ * ```
+ */
+function updateFenceState(state, line) {
+    if (state.inFence) {
+        return closeFence(state, line);
+    }
+    return openFence(state, line);
+}
+export { parseFenceLine, removeEmptyFences };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"empty-fence-fixes.js","sourceRoot":"","sources":["../../../src/docs/require-example-language/empty-fence-fixes.ts"],"names":[],"mappings":"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","sourcesContent":["/** Type definition for rule data. */\ninterface EmptyFenceState {\n  /** CurrentFence field value. */\n  currentFence: string[];\n\n  /** HasFenceContent field value. */\n  hasFenceContent: boolean;\n\n  /** HasNonEmptyFence field value. */\n  hasNonEmptyFence: boolean;\n\n  /** InFence field value. */\n  inFence: boolean;\n\n  /** Output field value. */\n  output: string[];\n\n  /** Removed field value. */\n  removed: boolean;\n}\n\n/** Type definition for rule data. */\ninterface FenceLineInfo {\n  /** Language field value. */\n  language: string;\n\n  /** Leading field value. */\n  leading: string;\n}\n\n/**\n * Closes a fence and updates the state.\n * @param state Current fence state.\n * @param line Fence line being processed.\n * @returns Updated fence state.\n * @example\n * ```typescript\n * const next = closeFence(state, \" * ```\");\n * ```\n */\nfunction closeFence(state: EmptyFenceState, line: string): EmptyFenceState {\n  const fenceLines = [...state.currentFence, line];\n  const shouldRemove = !state.hasFenceContent;\n  const hasNonEmptyFence = state.hasNonEmptyFence || state.hasFenceContent;\n  const output = shouldRemove ? state.output : [...state.output, ...fenceLines];\n\n  return {\n    ...state,\n    currentFence: [],\n    hasFenceContent: false,\n    hasNonEmptyFence,\n    inFence: false,\n    output,\n    removed: state.removed || shouldRemove,\n  };\n}\n\n/**\n * Finalizes fence output, including any unclosed fences.\n * @param state Current fence state.\n * @returns Finalized fence state.\n * @example\n * ```typescript\n * const next = finalizeFenceState(state);\n * ```\n */\nfunction finalizeFenceState(state: EmptyFenceState): EmptyFenceState {\n  if (state.inFence) {\n    return {\n      ...state,\n      currentFence: [],\n      hasFenceContent: false,\n      hasNonEmptyFence: state.hasNonEmptyFence || state.hasFenceContent,\n      inFence: false,\n      output: [...state.output, ...state.currentFence],\n    };\n  }\n\n  return state;\n}\n\n/**\n * Determines whether a line contains non-empty content.\n * @param line Line text to check.\n * @returns True when the line contains content.\n * @example\n * ```typescript\n * const ok = isContentLine(\" * const ok = true;\");\n * ```\n */\nfunction isContentLine(line: string): boolean {\n  const trimmed = line.replace(/^\\s*\\*?\\s?/u, \"\").trim();\n  return trimmed.length > 0;\n}\n\n/**\n * Opens a new fenced block.\n * @param state Current fence state.\n * @param line Fence line being processed.\n * @returns Updated fence state.\n * @example\n * ```typescript\n * const next = openFence(state, \" * ```typescript\");\n * ```\n */\nfunction openFence(state: EmptyFenceState, line: string): EmptyFenceState {\n  return {\n    ...state,\n    currentFence: [line],\n    hasFenceContent: false,\n    hasNonEmptyFence: state.hasNonEmptyFence,\n    inFence: true,\n  };\n}\n\n/**\n * Parses a fence line for its leading prefix and language.\n * @param line Fence line to parse.\n * @returns Parsed fence info when matched.\n * @example\n * ```typescript\n * const info = parseFenceLine(\" * ```typescript\");\n * ```\n */\nfunction parseFenceLine(line: string): FenceLineInfo | undefined {\n  const fenceMatch = /^(?<leading>\\s*\\*?\\s*)```(?<lang>[^\\s`]+)?[ \\t]*$/u.exec(\n    line,\n  );\n\n  if (fenceMatch === null) {\n    return void 0;\n  }\n\n  const groups = fenceMatch.groups ?? {};\n  const leading =\n    typeof groups[\"leading\"] === \"string\" ? groups[\"leading\"] : \"\";\n  const language = typeof groups[\"lang\"] === \"string\" ? groups[\"lang\"] : \"\";\n\n  return { language, leading };\n}\n\n/**\n * Removes fenced blocks that contain no content.\n * @param original Original comment text.\n * @returns Updated comment text when a fence is removed.\n * @example\n * ```typescript\n * const updated = removeEmptyFences(\"* ```typescript\\n* ```\\n* ok\");\n * ```\n */\nfunction removeEmptyFences(original: string): string | undefined {\n  const lineBreak = original.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\n  const lines = original.split(/\\r?\\n/u);\n  const initialState: EmptyFenceState = {\n    currentFence: [],\n    hasFenceContent: false,\n    hasNonEmptyFence: false,\n    inFence: false,\n    output: [],\n    removed: false,\n  };\n  let state = initialState;\n\n  for (const line of lines) {\n    const fenceInfo = parseFenceLine(line);\n    state =\n      fenceInfo === void 0\n        ? updateContentState(state, line)\n        : updateFenceState(state, line);\n  }\n\n  const finalState = finalizeFenceState(state);\n\n  return finalState.removed && finalState.hasNonEmptyFence\n    ? finalState.output.join(lineBreak)\n    : void 0;\n}\n\n/**\n * Updates the state with a non-fence line.\n * @param state Current fence state.\n * @param line Line being processed.\n * @returns Updated fence state.\n * @example\n * ```typescript\n * const next = updateContentState(state, \" * const ok = true;\");\n * ```\n */\nfunction updateContentState(\n  state: EmptyFenceState,\n  line: string,\n): EmptyFenceState {\n  if (state.inFence) {\n    return {\n      ...state,\n      currentFence: [...state.currentFence, line],\n      hasFenceContent: state.hasFenceContent || isContentLine(line),\n    };\n  }\n\n  return { ...state, output: [...state.output, line] };\n}\n\n/**\n * Opens or closes a fence based on the current state.\n * @param state Current fence state.\n * @param line Fence line being processed.\n * @returns Updated fence state.\n * @example\n * ```typescript\n * const next = updateFenceState(state, \" * ```\");\n * ```\n */\nfunction updateFenceState(\n  state: EmptyFenceState,\n  line: string,\n): EmptyFenceState {\n  if (state.inFence) {\n    return closeFence(state, line);\n  }\n\n  return openFence(state, line);\n}\n\nexport { parseFenceLine, removeEmptyFences };\n"]}

package/dist/docs/require-example-language/example-utilities.d.ts

@@ -0,0 +1,70 @@
+/** Type definition for rule data. */
+interface LineMeta {
+    /** EndIndex field value. */
+    endIndex: number;
+    /** EndOffset field value. */
+    endOffset: number;
+    /** LineIndex field value. */
+    lineIndex: number;
+}
+/** Type definition for rule data. */
+interface LineMetaContext {
+    /** CommentValue field value. */
+    commentValue: string;
+    /** Full field value. */
+    full: string;
+    /** StartOffset field value. */
+    startOffset: number;
+}
+/**
+ * Extracts the language from a fence line when present.
+ * @param line Fence line to inspect.
+ * @returns Language tag when present.
+ * @example
+ * ```typescript
+ * const lang = getFenceLanguage(" * ```typescript");
+ * ```
+ */
+declare function getFenceLanguage(line: string): string | undefined;
+/**
+ * Extracts inline example content from the header line.
+ * @param header Example header line.
+ * @returns Inline example content.
+ * @example
+ * ```typescript
+ * const text = getInlineContent("* @example hello");
+ * ```
+ */
+declare function getInlineContent(header: string): string;
+/**
+ * Computes line metadata from the raw comment value.
+ * @param context Comment metadata context.
+ * @returns Line metadata for the example.
+ * @example
+ * ```typescript
+ * const meta = getLineMeta({ commentValue: "* ok", full: "* ok", startOffset: 0 });
+ * ```
+ */
+declare function getLineMeta(context: LineMetaContext): LineMeta;
+/**
+ * Resolves the leading prefix used by example lines.
+ * @param header Example header line.
+ * @returns The leading prefix string.
+ * @example
+ * ```typescript
+ * const prefix = getPrefix(" * @example");
+ * ```
+ */
+declare function getPrefix(header: string): string;
+/**
+ * Determines whether a content line contains non-empty example text.
+ * @param line Line text to check.
+ * @returns True when the line contains content.
+ * @example
+ * ```typescript
+ * const ok = hasLineContent(" * const value = 1;");
+ * ```
+ */
+declare function hasLineContent(line: string): boolean;
+export { getFenceLanguage, getInlineContent, getLineMeta, getPrefix, hasLineContent, };
+//# sourceMappingURL=example-utilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"example-utilities.d.ts","sourceRoot":"","sources":["../../../src/docs/require-example-language/example-utilities.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,UAAU,QAAQ;IAChB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;IAEjB,6BAA6B;IAC7B,SAAS,EAAE,MAAM,CAAC;IAElB,6BAA6B;IAC7B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qCAAqC;AACrC,UAAU,eAAe;IACvB,gCAAgC;IAChC,YAAY,EAAE,MAAM,CAAC;IAErB,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC;IAEb,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,iBAAS,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAU1D;AAED;;;;;;;;GAQG;AACH,iBAAS,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED;;;;;;;;GAQG;AACH,iBAAS,WAAW,CAAC,OAAO,EAAE,eAAe,GAAG,QAAQ,CAQvD;AAED;;;;;;;;GAQG;AACH,iBAAS,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAQzC;AAED;;;;;;;;GAQG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAG7C;AAED,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,WAAW,EACX,SAAS,EACT,cAAc,GACf,CAAC"}

package/dist/docs/require-example-language/example-utilities.js

@@ -0,0 +1,76 @@
+/**
+ * Extracts the language from a fence line when present.
+ * @param line Fence line to inspect.
+ * @returns Language tag when present.
+ * @example
+ * ```typescript
+ * const lang = getFenceLanguage(" * ```typescript");
+ * ```
+ */
+function getFenceLanguage(line) {
+    const fenceMatch = /^(?<leading>\s*\*?\s*)```(?<lang>[^\s`]+)?[ \t]*$/u.exec(line);
+    if (fenceMatch === null) {
+        return void 0;
+    }
+    return fenceMatch.groups?.["lang"] ?? "";
+}
+/**
+ * Extracts inline example content from the header line.
+ * @param header Example header line.
+ * @returns Inline example content.
+ * @example
+ * ```typescript
+ * const text = getInlineContent("* @example hello");
+ * ```
+ */
+function getInlineContent(header) {
+    const inlineMatch = /^.*@example\b\s?(?<c>.*)$/u.exec(header);
+    return inlineMatch?.groups?.["c"] ?? "";
+}
+/**
+ * Computes line metadata from the raw comment value.
+ * @param context Comment metadata context.
+ * @returns Line metadata for the example.
+ * @example
+ * ```typescript
+ * const meta = getLineMeta({ commentValue: "* ok", full: "* ok", startOffset: 0 });
+ * ```
+ */
+function getLineMeta(context) {
+    const { commentValue, full, startOffset } = context;
+    const lineIndex = commentValue.slice(0, startOffset).split(/\r?\n/u).length - 1;
+    const endOffset = startOffset + full.length;
+    const endIndex = lineIndex + full.split(/\r?\n/u).length - 1;
+    return { endIndex, endOffset, lineIndex };
+}
+/**
+ * Resolves the leading prefix used by example lines.
+ * @param header Example header line.
+ * @returns The leading prefix string.
+ * @example
+ * ```typescript
+ * const prefix = getPrefix(" * @example");
+ * ```
+ */
+function getPrefix(header) {
+    const prefixMatch = header.indexOf("@example");
+    if (prefixMatch === -1) {
+        return "";
+    }
+    return header.slice(0, prefixMatch);
+}
+/**
+ * Determines whether a content line contains non-empty example text.
+ * @param line Line text to check.
+ * @returns True when the line contains content.
+ * @example
+ * ```typescript
+ * const ok = hasLineContent(" * const value = 1;");
+ * ```
+ */
+function hasLineContent(line) {
+    const trimmed = line.replace(/^\s*\*?\s?/u, "").trim();
+    return trimmed.length > 0;
+}
+export { getFenceLanguage, getInlineContent, getLineMeta, getPrefix, hasLineContent, };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/docs/require-example-language/examples.d.ts

@@ -0,0 +1,36 @@
+import type { Example, Problem } from "./types";
+/**
+ * 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);
+ * ```
+ */
+declare function buildExampleFromMatch(match: RegExpMatchArray, commentValue: string): Example;
+/**
+ * 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```");
+ * ```
+ */
+declare function checkExampleContent(content: string): Problem | undefined;
+/**
+ * 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* ```");
+ * ```
+ */
+declare function getExamples(commentValue: string): Example[];
+export { buildExampleFromMatch, checkExampleContent, getExamples };
+//# sourceMappingURL=examples.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"examples.d.ts","sourceRoot":"","sources":["../../../src/docs/require-example-language/examples.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AA6KhD;;;;;;;;;GASG;AACH,iBAAS,qBAAqB,CAC5B,KAAK,EAAE,gBAAgB,EACvB,YAAY,EAAE,MAAM,GACnB,OAAO,CAqBT;AAED;;;;;;;;GAQG;AACH,iBAAS,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAoBjE;AAED;;;;;;;;;;GAUG;AACH,iBAAS,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,EAAE,CAQpD;AAED,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,WAAW,EAAE,CAAC"}

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

@@ -0,0 +1,181 @@
+import { getFenceLanguage, getInlineContent, getLineMeta, getPrefix, hasLineContent, } from "./example-utilities";
+/** 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/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/require-example-language/fixes.d.ts

@@ -0,0 +1,49 @@
+import type { Rule } from "eslint";
+import type { Example, Problem } from "./types";
+/** Type definition for rule data. */
+interface FixerContext {
+    /** AbsoluteEnd field value. */
+    absoluteEnd: number;
+    /** AbsoluteStart field value. */
+    absoluteStart: number;
+    /** Example field value. */
+    example: Example;
+    /** HasOtherExamples field value. */
+    hasOtherExamples: boolean;
+    /** Problem field value. */
+    problem: Problem;
+    /** SourceText field value. */
+    sourceText: string;
+}
+/**
+ * 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);
+ * ```
+ */
+declare function buildMissingFenceFix(example: Example): string;
+/**
+ * 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* ```");
+ * ```
+ */
+declare function buildMissingLanguageFix(original: string): string | undefined;
+/**
+ * Builds a fixer function for the report.
+ * @param context Fixer context details.
+ * @returns Fixer function for ESLint.
+ * @example
+ * ```typescript
+ * const fixer = createFixer(context);
+ * ```
+ */
+declare function createFixer(context: FixerContext): (fixer: Rule.RuleFixer) => null | Rule.Fix;
+export { buildMissingFenceFix, buildMissingLanguageFix, createFixer };
+//# sourceMappingURL=fixes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fixes.d.ts","sourceRoot":"","sources":["../../../src/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,GAAG,IAAI,CAAC,GAAG,CAY5C;AAwHD,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,WAAW,EAAE,CAAC"}