@redocly/recheck 0.1.0 → 0.3.0

package/dist/rules/token/helpers.d.ts

@@ -0,0 +1,313 @@
+import type { Token, TokenTree } from '../../parser/types.js';
+/**
+ * Adds a range of numbers (inclusive of both bounds) to a set.
+ */
+export declare function addRangeToSet(set: Set<number>, start: number, end: number): void;
+/**
+ * A line/column range within a file (1-based, inclusive of both ends).
+ * Shares field names with `Token`'s start/end line/column so a `Token` can
+ * be passed directly wherever a `FileRange` is expected.
+ */
+export interface FileRange {
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+}
+/**
+ * Returns whether two ranges (or Tokens) overlap anywhere. Ported from
+ * markdownlint's helpers/helpers.cjs `hasOverlap`.
+ */
+export declare function hasOverlap(rangeA: FileRange, rangeB: FileRange): boolean;
+/**
+ * Filter a token tree, or an arbitrary token array (accepted so
+ * `blanksAroundLists`/MD032 can start the walk from `list.children`
+ * instead of the whole tree), by predicate — walking depth-first. Ported
+ * from upstream's `filterByPredicate(tokens, allowed, transformChildren)`:
+ * `transformChildren`, when given, replaces a token's own `children` array
+ * for traversal purposes only (the returned `result` array is unaffected) —
+ * upstream uses this to redirect traversal into htmlFlow subtokens, and
+ * MD032 uses it to stop descending into nested lists (so only *top-level*
+ * lists are returned) and to skip "non-content" token subtrees entirely.
+ * Omitting `transformChildren` walks every real child, matching every
+ * batch 1/2 caller's usage (none needed it before MD032).
+ */
+export declare function filterByPredicate(tree: TokenTree | Token[], predicate: (token: Token) => boolean, transformChildren?: (token: Token) => Token[]): Token[];
+/**
+ * Gets a list of nested token descendants by type path. Each path element
+ * matches one depth of descent and may be a single type or (per upstream's
+ * own signature, `helpers/helpers.cjs`'s shared `getDescendantsByType`) an
+ * array of alternative types to match at that depth — used by batch 5's
+ * `link-image-style` (MD054) for `resourceDestination`'s
+ * literal/raw-destination split and `autolink`'s email/protocol split.
+ * Earlier batches (see `getHeadingText` below) predate this and call once
+ * per alternative instead, merging results themselves; both styles coexist
+ * since neither is wrong, but new callers needing an alternation can now
+ * use a single call.
+ */
+export declare function getDescendantsByType(token: Token, typePath: readonly (string | readonly string[])[]): Token[];
+/**
+ * Gets the nearest parent of one of the specified types for a token.
+ */
+export declare function getParentOfType(token: Token, types: readonly string[]): Token | null;
+/**
+ * Gets the heading level of an atx or setext heading token. Matches
+ * upstream: looks for a direct child of type `atxHeadingSequence` or
+ * `setextHeadingLine` (the setext underline is a direct child of
+ * `setextHeading`, not nested further) and reads its level from the text.
+ */
+export declare function getHeadingLevel(heading: Token): number;
+/**
+ * Gets the heading style of an atx or setext heading token: `'setext'` for
+ * setext headings, `'atx'` for a plain atx heading (one `atxHeadingSequence`
+ * child), or `'atx_closed'` for a closed atx heading (a trailing
+ * `atxHeadingSequence` closing marker as a second direct-child sequence).
+ */
+export declare function getHeadingStyle(heading: Token): 'setext' | 'atx' | 'atx_closed';
+/**
+ * Gets the heading text of an atx or setext heading token. Descends into
+ * `atxHeadingText`/`setextHeadingText` (nested arbitrarily deep under the
+ * heading, e.g. inside inline containers) and concatenates all non-htmlText
+ * descendant text, collapsing internal newlines (setext headings can span
+ * multiple lines) to single spaces.
+ */
+export declare function getHeadingText(heading: Token): string;
+/**
+ * Gets the blockquote prefix text (if any) for the specified line number,
+ * e.g. `"> "` for a line inside a single-level blockquote. Upstream filters
+ * a flat token list by type via `filterByTypes`; Recheck's `TokenTree`
+ * already carries a flat list (`tree.flat`), so this takes the tree
+ * directly rather than a pre-filtered token array.
+ */
+export declare function getBlockQuotePrefixText(tree: TokenTree, lineNumber: number, count?: number): string;
+/**
+ * Returns true iff the input line is blank (contains nothing, whitespace,
+ * blockquote markers, or HTML comments (unclosed start/end comments
+ * allowed)). Ported from markdownlint's helpers/helpers.cjs `isBlankLine`.
+ */
+export declare function isBlankLine(line: string): boolean;
+/**
+ * Set of token types that do not contain document content (used to skip
+ * over "non-content" tokens — indentation, blank lines, container prefixes
+ * — when scanning for a document's first meaningful token). Ported from
+ * markdownlint's helpers/micromark-helpers.cjs `nonContentTokens`.
+ */
+export declare const nonContentTokens: Set<string>;
+/**
+ * Returns the last line number (1-based, inclusive) of the document's YAML
+ * frontmatter block, or 0 if there is none.
+ *
+ * Upstream markdownlint slices frontmatter out of `content` entirely
+ * before tokenizing (see markdownlint's `removeFrontMatter`) — every
+ * rule's `params.lines`/token stream is already frontmatter-free, with
+ * `frontMatterLines.length` added back only when reporting an error's line
+ * number. Recheck's parser instead keeps a `yaml` token (and all its
+ * descendant tokens — `yamlFence`, `yamlValue`, etc. — individually
+ * present in `tree.flat`, a full depth-first flattening) as real content.
+ * Rules that scan `ctx.lines` by index, or walk `ctx.tree.flat` from the
+ * top of the document looking for the first "real" token, must skip every
+ * line up to and including this one to match upstream's behavior — see
+ * first-line-h1.ts, single-h1.ts, and line-length.ts for call sites.
+ */
+export declare function getFrontmatterEndLine(tree: TokenTree): number;
+/**
+ * Returns true iff the document's YAML front matter contains a title — i.e.
+ * the `pattern` regex matches at least one of the front matter block's lines.
+ *
+ * WHY THIS EXISTS: it ports upstream markdownlint's `front_matter_title`
+ * rule option (implemented there by helpers/helpers.cjs's own
+ * `frontMatterHasTitle`), which exists on exactly three upstream rules —
+ * MD001 (our heading-increment), MD025 (single-h1), and MD041
+ * (first-line-h1); see
+ * https://github.com/DavidAnson/markdownlint/blob/main/doc/md001.md.
+ * When the front matter declares a title, it counts as the document's
+ * implicit top-level (h1) heading:
+ * - heading-increment then expects the first body heading to be an h2;
+ * - single-h1 treats it as the document's one H1, so EVERY body h1 is a
+ *   violation;
+ * - first-line-h1 is satisfied by it outright and checks nothing else.
+ *
+ * The default pattern is `^\s*"?title"?\s*[:=]`: a `title` key, optionally
+ * double-quoted, followed by `:` (YAML) or `=` (TOML-style front matter),
+ * matched case-insensitively. Each of the three rules declares that default
+ * in its own `defaults` object — exactly as each upstream rule declares its
+ * own default — and this helper only encapsulates the matching.
+ *
+ * CONTRACT: `pattern` is the raw config value (`ctx.config.frontMatterTitle`);
+ * configuring the empty string `''` (or a nullish value) disables the
+ * behavior entirely — this helper then always returns false — matching
+ * upstream's documented "specify `""` for `front_matter_title`" opt-out.
+ *
+ * Upstream builds the regex with the `i` flag only and tests it against each
+ * front matter LINE individually (`frontMatterLines.some(...)`), where
+ * `frontMatterLines` is the whole regex-matched front matter block —
+ * INCLUDING both delimiter fence lines — split on line endings (see
+ * markdownlint's `removeFrontMatter`). Recheck's parser keeps that same
+ * block as one `yaml` token (see getFrontmatterEndLine's doc comment above)
+ * whose text spans opening fence through closing fence with no trailing
+ * newline, so splitting it on `newLineRe` reproduces upstream's lines
+ * exactly, and the regex is tested per line here too. (Testing the whole
+ * block with `im` instead is NOT equivalent: a custom pattern containing a
+ * literal `\n`, or one where `\s*`/`[\s\S]*` can absorb a line ending —
+ * e.g. `author:.*\s*title` — would match across lines, which upstream
+ * never does.)
+ */
+export declare function frontMatterHasTitle(tree: TokenTree, pattern: unknown): boolean;
+/**
+ * Returns true iff the token is an HTML comment (`<!-- ... -->`) that is
+ * valid per the CommonMark spec (comment body doesn't start with `>` or
+ * `->`, and doesn't end with `-`). Ported from markdownlint's
+ * helpers/micromark-helpers.cjs `isHtmlFlowComment`.
+ */
+export declare function isHtmlFlowComment(token: Token): boolean;
+/**
+ * Replaces the content of valid CommonMark HTML comments with the `.`
+ * "safe" character, preserving every line/column position in the rest of
+ * the document (never removes characters, never touches `\r`/`\n`).
+ * Ported from markdownlint's helpers/helpers.cjs `clearHtmlCommentText`.
+ *
+ * This is upstream's OWN pre-processing pass -- run once, globally, before
+ * `params.lines` is computed -- so that rules doing plain text/line
+ * scanning (as opposed to token-tree scanning) never see real content
+ * inside an HTML comment: trailing whitespace inside a comment isn't
+ * "trailing whitespace" (MD009), a tab inside a comment isn't a "hard
+ * tab" (MD010), reversed-link syntax inside a comment isn't a broken link
+ * (MD011), etc. Token-tree-based scanning (e.g. MD033/MD037, which read
+ * `params.parsers.micromark.tokens`) is unaffected -- those tokens are
+ * built from the ORIGINAL, uncleared content upstream, matching how
+ * recheck's own token tree (`ctx.tree`) is never cleared either; only
+ * `ctx.lines` (see core/runner.ts) uses this cleared text.
+ */
+export declare function clearHtmlCommentText(text: string): string;
+/**
+ * Returns true iff the heading is a DocFX tab heading (an atx heading whose
+ * entire text is a single link with a `#tab/...` destination) — see
+ * https://dotnet.github.io/docfx/docs/markdown.html?tabs=linux%2Cdotnet#tabs.
+ * Ported from markdownlint's helpers/micromark-helpers.cjs `isDocfxTab`.
+ */
+export declare const endOfLineHtmlEntityRe: RegExp;
+export declare const endOfLineGemojiCodeRe: RegExp;
+export declare const allPunctuation = ".,;:!?\u3002\uFF0C\uFF1B\uFF1A\uFF01\uFF1F";
+export declare const allPunctuationNoQuestion: string;
+/**
+ * Escapes a string for safe use inside a RegExp character class/pattern.
+ * Ported from markdownlint's helpers/helpers.cjs `escapeForRegExp`.
+ */
+export declare function escapeForRegExp(str: string): string;
+/**
+ * Replaces lone (unpaired) surrogate code units with U+FFFD, matching the
+ * behavior of `String.prototype.toWellFormed()` (ES2024). Recheck's
+ * `tsconfig.json` targets ES2021 (shared across the whole package, not
+ * something this rule port should widen), so `link-fragments` (MD051) —
+ * the only upstream rule using `.toWellFormed()` (on heading/fragment text
+ * before `encodeURIComponent`, which throws on lone surrogates) — calls
+ * this instead of the native method.
+ */
+export declare function toWellFormedString(str: string): string;
+/**
+ * HTML tag information: whether it's a closing tag and its (lowercased-by-
+ * caller-if-needed) name. Ported from markdownlint's
+ * helpers/micromark-helpers.cjs `getHtmlTagInfo`.
+ */
+export interface HtmlTagInfo {
+    close: boolean;
+    name: string;
+}
+/**
+ * Gets information about the tag in an HTML token (an `htmlText` token's
+ * opening `<tag ...>` or closing `</tag>`), or `null` if the token's text
+ * doesn't start with a recognizable tag (e.g. an HTML comment). Ported from
+ * markdownlint's helpers/micromark-helpers.cjs `getHtmlTagInfo`.
+ */
+export declare function getHtmlTagInfo(token: Token): HtmlTagInfo | null;
+/**
+ * Builds a RegExp for matching the specified HTML attribute (e.g. `alt=`,
+ * `id=`) within a raw HTML tag's text, capturing its (optionally quoted)
+ * value. Ported from markdownlint's helpers/helpers.cjs `getHtmlAttributeRe`.
+ */
+export declare function getHtmlAttributeRe(name: string): RegExp;
+/**
+ * Truncates long text for use in error context, keeping the start, end, or
+ * both ends depending on which end(s) matter. Ported from markdownlint's
+ * helpers/helpers.cjs `ellipsify`.
+ */
+export declare function ellipsify(text: string, start?: boolean, end?: boolean): string;
+export declare function isDocfxTab(heading: Token | null | undefined): boolean;
+export declare function normalizeReference(s: string): string;
+/** One usage site of a reference/shortcut label: `[lineIndex, columnIndex, length]` (0-based line/column), matching upstream's `number[][]` shape exactly so MD052's line/column math ports verbatim. */
+export type ReferenceDatum = [lineIndex: number, columnIndex: number, length: number];
+export interface GetReferenceLinkImageDataResult {
+    /** Normalized label -> usage sites, for "full"/"collapsed" reference syntax (`[text][label]`, `[label][]`). */
+    references: Map<string, ReferenceDatum[]>;
+    /** Normalized label -> usage sites, for "shortcut" syntax (`[label]`) and footnote calls (`[^label]`). */
+    shortcuts: Map<string, ReferenceDatum[]>;
+    /** Normalized label -> `[lineIndex, destinationText]` for each `[label]: destination` (or footnote `[^label]: ...`) definition. */
+    definitions: Map<string, [number, string]>;
+    /** `[label, lineIndex]` for each definition after the first one seen for that label. */
+    duplicateDefinitions: [string, number][];
+}
+/**
+ * Returns information about reference-style links/images and their
+ * definitions across the whole document: which labels are defined, which
+ * are used (split into "full/collapsed" `references` vs "shortcut"
+ * `shortcuts`, since shortcut syntax is ambiguous with plain bracketed
+ * text), and which definitions are duplicates. Ported from markdownlint's
+ * helpers/helpers.cjs `getReferenceLinkImageData` (there, cached per-lint-
+ * run by lib/cache.mjs; Recheck's token rules have no shared per-run cache
+ * — see no-empty-links.ts's doc comment for the established precedent — so
+ * each of MD051/052/053/054 calls this fresh over the same tree).
+ *
+ * DEVIATION: upstream additionally detects reference syntax that fails to
+ * resolve to any definition at all (`undefinedReferenceShortcut/Collapsed/
+ * Full`) by monkeypatching micromark's internal `labelEnd` tokenizer
+ * (lib/micromark-parse.mjs) to synthesize tokens when label resolution
+ * backtracks to failure. Recheck's parser (src/parser/index.ts) is a much
+ * thinner micromark wrapper with no equivalent hook, and reproducing that
+ * shim correctly is a parser-level change out of scope for a rule port.
+ * Without it, an *undefined* reference/shortcut never becomes a `link`/
+ * `image`/`gfmFootnoteCall` token in Recheck's tree in the first place —
+ * it decomposes into plain `data` tokens — so there is no token for this
+ * function to inspect for that case via the token-shape path alone.
+ * `scanUndefinedReferences` below is a conservative, best-effort text-scan
+ * fallback (restricted to direct `data`/`lineEnding` children of a single
+ * container, requiring non-nested single-bracket-depth text with no `]`
+ * inside — mirroring the upstream shim's own `!text.includes("]")` guard)
+ * so MD052 (whose entire purpose is detecting undefined references) is not
+ * a permanent no-op; it is not a byte-for-byte port of the shim and may
+ * miss or mis-slice pathological/multi-line cases the real shim handles
+ * via micromark's own backtracking state. MD053's `duplicateDefinitions`/
+ * `definitions` and MD054's `definitions` lookups don't depend on this
+ * fallback at all (they only need successfully-resolved usages), so this
+ * deviation is fully scoped to MD052.
+ */
+export declare function getReferenceLinkImageData(tree: TokenTree): GetReferenceLinkImageDataResult;
+export interface ImageDestination {
+    /** The `image` token itself — use its position/text for reporting. */
+    token: Token;
+    /**
+     * The image's destination exactly as written in the source: either the
+     * inline `(path "title")` destination (raw or angle-bracket literal), or
+     * the resolved reference/collapsed/shortcut definition's destination.
+     */
+    destination: string;
+}
+/**
+ * Resolves every `image` token in the tree to its destination path/URL —
+ * both inline syntax (`![alt](path "title")`, including angle-bracket
+ * literal destinations) and reference syntax (`![alt][ref]`, `![alt][]`,
+ * `![alt]`), the latter resolved through `getReferenceLinkImageData`'s
+ * `definitions` map the same way `link-image-style.ts` (MD054) resolves a
+ * reference link/image's destination for its autolink-eligibility check.
+ * An image whose reference never resolves to a definition never becomes an
+ * `image` token in the first place (see `getReferenceLinkImageData`'s
+ * DEVIATION note above) — there's no token to report for those here,
+ * matching every other AST-based rule's treatment of the same tree.
+ *
+ * Shared by `rules/scope/max-image-size.ts` (the rule that flags oversized
+ * images) and `core/files.ts`'s `extractImageReferences` (the on-disk
+ * metadata loader): a single extraction pass so both sides always agree on
+ * exactly which destination string keys a given image's on-disk stats in
+ * `ScopeRuleContext.fileMetadata.images`.
+ */
+export declare function getImageDestinations(tree: TokenTree): ImageDestination[];
+//# sourceMappingURL=helpers.d.ts.map

package/dist/rules/token/helpers.d.ts.map

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