@wdprlib/parser 3.1.2 → 4.0.0

package/src/parser/rules/block/bibliography/body.ts

@@ -0,0 +1,81 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../utils";
+import { parseBibliographyEntry, type BibliographyEntry } from "./entries";
+
+export interface BibliographyBodyResult {
+  entries: BibliographyEntry[];
+  consumed: number;
+  foundClose: boolean;
+}
+
+export function collectBibliographyBody(
+  ctx: ParseContext,
+  startPos: number,
+): BibliographyBodyResult {
+  const entries: BibliographyEntry[] = [];
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      break;
+    }
+
+    const closeConsumed = consumeBibliographyClose(ctx, pos);
+    if (closeConsumed !== null) {
+      return {
+        entries,
+        consumed: consumed + closeConsumed,
+        foundClose: true,
+      };
+    }
+
+    if (token.type === "WHITESPACE" || token.type === "NEWLINE") {
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    if (token.type === "COLON" && token.lineStart) {
+      const result = parseBibliographyEntry(ctx, pos);
+      if (result) {
+        entries.push(result.entry);
+        pos += result.consumed;
+        consumed += result.consumed;
+        continue;
+      }
+    }
+
+    pos++;
+    consumed++;
+  }
+
+  return { entries, consumed, foundClose: false };
+}
+
+function consumeBibliographyClose(ctx: ParseContext, startPos: number): number | null {
+  const openToken = ctx.tokens[startPos];
+  if (openToken?.type !== "BLOCK_END_OPEN") {
+    return null;
+  }
+
+  const closeNameResult = parseBlockName(ctx, startPos + 1);
+  if (closeNameResult?.name !== "bibliography") {
+    return null;
+  }
+
+  let pos = startPos + 1 + closeNameResult.consumed;
+  let consumed = 1 + closeNameResult.consumed;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
+    consumed++;
+  }
+
+  return consumed;
+}

package/src/parser/rules/block/bibliography/entries.ts

@@ -0,0 +1,49 @@
+import type { DefinitionListItem, Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseBibliographyContent } from "./entry-content";
+import { parseBibliographyKey } from "./entry-key";
+
+/**
+ * Internal representation of a single bibliography entry parsed from
+ * the `: label : content` line(s) inside the bibliography block.
+ */
+export interface BibliographyEntry {
+  /** The identifier used in `((bibcite label))` references. */
+  label: string;
+  /** Parsed inline elements for the label portion (the key). */
+  key: Element[];
+  /** Parsed inline elements for the citation text. */
+  content: Element[];
+}
+
+/**
+ * Parses one bibliography entry from the token stream.
+ */
+export function parseBibliographyEntry(
+  ctx: ParseContext,
+  startPos: number,
+): { entry: BibliographyEntry; consumed: number } | null {
+  const keyResult = parseBibliographyKey(ctx, startPos);
+  if (!keyResult) {
+    return null;
+  }
+
+  const contentResult = parseBibliographyContent(ctx, startPos + keyResult.consumed);
+
+  return {
+    entry: {
+      label: keyResult.label,
+      key: keyResult.key,
+      content: contentResult.content,
+    },
+    consumed: keyResult.consumed + contentResult.consumed,
+  };
+}
+
+export function toDefinitionListItems(entries: BibliographyEntry[]): DefinitionListItem[] {
+  return entries.map((entry) => ({
+    key_string: entry.label,
+    key: entry.key,
+    value: entry.content,
+  }));
+}

package/src/parser/rules/block/bibliography/entry-content.ts

@@ -0,0 +1,73 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseInlineUntil } from "../../inline/utils";
+import { parseBlockName } from "../utils";
+
+export interface BibliographyContentResult {
+  content: Element[];
+  consumed: number;
+}
+
+export function parseBibliographyContent(
+  ctx: ParseContext,
+  startPos: number,
+): BibliographyContentResult {
+  const content: Element[] = [];
+  let pos = startPos;
+  let consumed = 0;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      break;
+    }
+
+    if (token.type === "BLOCK_END_OPEN") {
+      const closeNameResult = parseBlockName(ctx, pos + 1);
+      if (closeNameResult?.name === "bibliography") {
+        break;
+      }
+    }
+
+    if (token.type === "NEWLINE") {
+      const nextToken = ctx.tokens[pos + 1];
+      if (nextToken?.type === "COLON" && nextToken.lineStart) {
+        pos++;
+        consumed++;
+        break;
+      }
+      if (nextToken?.type === "BLOCK_END_OPEN") {
+        pos++;
+        consumed++;
+        break;
+      }
+      if (nextToken?.type === "NEWLINE" || !nextToken || nextToken.type === "EOF") {
+        pos++;
+        consumed++;
+        break;
+      }
+      content.push({ element: "line-break" });
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    const inlineCtx: ParseContext = { ...ctx, pos };
+    const result = parseInlineUntil(inlineCtx, "NEWLINE");
+    if (result.elements.length > 0) {
+      content.push(...result.elements);
+      pos += result.consumed;
+      consumed += result.consumed;
+    } else {
+      pos++;
+      consumed++;
+    }
+  }
+
+  return { content, consumed };
+}

package/src/parser/rules/block/bibliography/entry-key.ts

@@ -0,0 +1,83 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+
+export interface BibliographyKeyResult {
+  label: string;
+  key: Element[];
+  consumed: number;
+}
+
+export function parseBibliographyKey(
+  ctx: ParseContext,
+  startPos: number,
+): BibliographyKeyResult | null {
+  let pos = startPos;
+  let consumed = 0;
+
+  const colonToken = ctx.tokens[pos];
+  if (!colonToken || colonToken.type !== "COLON" || !colonToken.lineStart) {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  const whitespaceAfterColon = ctx.tokens[pos];
+  if (!whitespaceAfterColon || whitespaceAfterColon.type !== "WHITESPACE") {
+    return null;
+  }
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  let label = "";
+  let foundSecondColon = false;
+  const key: Element[] = [];
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "NEWLINE" || token.type === "EOF") {
+      break;
+    }
+    if (token.type === "COLON") {
+      foundSecondColon = true;
+      pos++;
+      consumed++;
+      break;
+    }
+
+    label += token.value;
+    key.push({ element: "text", data: token.value });
+    pos++;
+    consumed++;
+  }
+
+  if (!foundSecondColon) {
+    return null;
+  }
+
+  trimTrailingWhitespaceText(key);
+
+  return {
+    label: label.trim(),
+    key,
+    consumed,
+  };
+}
+
+function trimTrailingWhitespaceText(nodes: Element[]): void {
+  while (nodes.length > 0) {
+    const lastNode = nodes[nodes.length - 1];
+    if (
+      lastNode &&
+      lastNode.element === "text" &&
+      typeof lastNode.data === "string" &&
+      lastNode.data.trim() === ""
+    ) {
+      nodes.pop();
+    } else {
+      break;
+    }
+  }
+}

package/src/parser/rules/block/bibliography/index.ts

@@ -0,0 +1,90 @@
+/**
+ *
+ * Block rule for the Wikidot bibliography block: `[[bibliography]] ... [[/bibliography]]`.
+ *
+ * A bibliography block holds labelled citation entries in a definition-list
+ * format. Each entry follows the pattern:
+ *
+ * ```
+ * : label : Citation description text
+ * ```
+ *
+ * At render time the entries are cross-referenced with inline `((bibcite label))`
+ * markers that appear elsewhere in the document. The parser stores the entries
+ * in the AST as a `bibliography-block` element whose `entries` field is an
+ * array of {@link DefinitionListItem} objects.
+ *
+ * Optional attributes on the opening tag:
+ * - `title` -- custom heading for the bibliography section.
+ * - `hide`  -- when `"true"` or empty string, hides the block from output.
+ *
+ * If no closing `[[/bibliography]]` tag is found, the rule fails to avoid
+ * accidentally consuming the rest of the document.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { collectBibliographyBody } from "./body";
+import { toDefinitionListItems } from "./entries";
+import { parseBibliographyOpen } from "./open";
+
+/**
+ * Block rule for Wikidot `[[bibliography]]...[[/bibliography]]`.
+ *
+ * Parsing strategy:
+ * 1. Match BLOCK_OPEN + block name "bibliography".
+ * 2. Parse optional attributes (`title`, `hide`).
+ * 3. Consume the closing `]]` and optional newline.
+ * 4. Loop over the body, parsing each `: label : content` line via
+ *    `parseBibliographyEntry()`.
+ * 5. Require and consume `[[/bibliography]]`.
+ * 6. Convert entries into {@link DefinitionListItem} format and emit
+ *    a `bibliography-block` element.
+ */
+export const bibliographyRule: BlockRule = {
+  name: "bibliography",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    const openResult = parseBibliographyOpen(ctx, ctx.pos);
+    if (!openResult) {
+      return { success: false };
+    }
+
+    const bodyResult = collectBibliographyBody(ctx, openResult.pos);
+    const consumed = openResult.consumed + bodyResult.consumed;
+
+    if (!bodyResult.foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/bibliography]] for [[bibliography]]",
+        position: openToken.position,
+      });
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "bibliography-block",
+          data: {
+            entries: toDefinitionListItems(bodyResult.entries),
+            title: openResult.title,
+            hide: openResult.hide,
+          },
+        },
+      ],
+      consumed,
+    };
+  },
+};

package/src/parser/rules/block/bibliography/open.ts

@@ -0,0 +1,53 @@
+import type { ParseContext } from "../../types";
+import { parseAttributes, parseBlockName } from "../utils";
+
+export interface BibliographyOpenResult {
+  title: string | null;
+  hide: boolean;
+  pos: number;
+  consumed: number;
+}
+
+export function parseBibliographyOpen(
+  ctx: ParseContext,
+  startPos: number,
+): BibliographyOpenResult | null {
+  let pos = startPos;
+  let consumed = 0;
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_OPEN") {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  const nameResult = parseBlockName(ctx, pos);
+  if (!nameResult || nameResult.name !== "bibliography") {
+    return null;
+  }
+
+  pos += nameResult.consumed;
+  consumed += nameResult.consumed;
+
+  const attrResult = parseAttributes(ctx, pos);
+  pos += attrResult.consumed;
+  consumed += attrResult.consumed;
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    pos++;
+    consumed++;
+  }
+
+  return {
+    title: attrResult.attrs.title ?? null,
+    hide: attrResult.attrs.hide === "true" || attrResult.attrs.hide === "",
+    pos,
+    consumed,
+  };
+}

package/src/parser/rules/block/block-list/bare-content.ts

@@ -0,0 +1,105 @@
+import type { ListItem } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { getCandidateInlineRules } from "../../inline/utils";
+import {
+  appendBareParagraphElements,
+  appendBareParagraphLineBreakIfNeeded,
+  appendBareParagraphText,
+  createBareParagraphState,
+  flushBareParagraph,
+  unwrapSingleBareParagraph,
+} from "./bare-paragraph";
+import { isLiOpen, isListClose, isNestedListOpen, type ListBlockType } from "./tags";
+
+export interface BareListContentResult {
+  item: ListItem | null;
+  consumed: number;
+}
+
+export function parseBareListContent(
+  ctx: ParseContext,
+  startPos: number,
+  listType: ListBlockType,
+): BareListContentResult {
+  const paragraphState = createBareParagraphState();
+  let consumed = 0;
+  let pos = startPos;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") break;
+
+    if (token.type === "NEWLINE") {
+      pos++;
+      consumed++;
+
+      let consecutiveNewlines = 1;
+      while (ctx.tokens[pos]?.type === "NEWLINE") {
+        pos++;
+        consumed++;
+        consecutiveNewlines++;
+      }
+
+      while (ctx.tokens[pos]?.type === "WHITESPACE" && ctx.tokens[pos]?.lineStart) {
+        pos++;
+        consumed++;
+      }
+
+      if (isListBoundary(ctx, pos, listType)) {
+        break;
+      }
+
+      if (consecutiveNewlines >= 2) {
+        flushBareParagraph(paragraphState);
+      } else {
+        appendBareParagraphLineBreakIfNeeded(paragraphState);
+      }
+      continue;
+    }
+
+    if (isListBoundary(ctx, pos, listType)) {
+      break;
+    }
+
+    let matched = false;
+    const inlineCtx: ParseContext = { ...ctx, pos };
+    for (const rule of getCandidateInlineRules(ctx.inlineRules, token.type)) {
+      const result = rule.parse(inlineCtx);
+      if (result.success) {
+        appendBareParagraphElements(paragraphState, result.elements);
+        consumed += result.consumed;
+        pos += result.consumed;
+        matched = true;
+        break;
+      }
+    }
+
+    if (!matched) {
+      appendBareParagraphText(paragraphState, token.value);
+      consumed++;
+      pos++;
+    }
+  }
+
+  flushBareParagraph(paragraphState);
+  if (paragraphState.paragraphs.length === 0) {
+    return { item: null, consumed };
+  }
+
+  return {
+    item: {
+      "item-type": "elements",
+      attributes: { _noMarker: "true" },
+      elements: unwrapSingleBareParagraph(paragraphState.paragraphs),
+    },
+    consumed,
+  };
+}
+
+function isListBoundary(ctx: ParseContext, pos: number, listType: ListBlockType): boolean {
+  return (
+    isListClose(ctx, pos, listType) ||
+    isLiOpen(ctx, pos) !== null ||
+    isNestedListOpen(ctx, pos) !== null
+  );
+}

package/src/parser/rules/block/block-list/bare-paragraph.ts

@@ -0,0 +1,60 @@
+import type { Element } from "@wdprlib/ast";
+
+export interface BareParagraphState {
+  paragraphs: Element[];
+  current: Element[];
+}
+
+export function createBareParagraphState(): BareParagraphState {
+  return {
+    paragraphs: [],
+    current: [],
+  };
+}
+
+export function appendBareParagraphElements(state: BareParagraphState, elements: Element[]): void {
+  state.current.push(...elements);
+}
+
+export function appendBareParagraphText(state: BareParagraphState, text: string): void {
+  state.current.push({ element: "text", data: text });
+}
+
+export function appendBareParagraphLineBreakIfNeeded(state: BareParagraphState): void {
+  if (state.current.length > 0) {
+    state.current.push({ element: "line-break" });
+  }
+}
+
+export function flushBareParagraph(state: BareParagraphState): void {
+  if (state.current.length === 0) return;
+
+  while (
+    state.current.length > 0 &&
+    state.current[state.current.length - 1]?.element === "line-break"
+  ) {
+    state.current.pop();
+  }
+
+  if (state.current.length > 0) {
+    state.paragraphs.push({
+      element: "container",
+      data: {
+        type: "paragraph",
+        attributes: {},
+        elements: state.current,
+      },
+    });
+  }
+  state.current = [];
+}
+
+export function unwrapSingleBareParagraph(elements: Element[]): Element[] {
+  if (elements.length !== 1) return elements;
+
+  const first = elements[0];
+  if (first?.element !== "container" || first.data.type !== "paragraph") {
+    return elements;
+  }
+  return first.data.elements;
+}

package/src/parser/rules/block/block-list/index.ts

@@ -0,0 +1,51 @@
+/**
+ *
+ * Block rule for the explicit list syntax: `[[ul]]`/`[[ol]]` with `[[li]]` items.
+ *
+ * Wikidot supports two kinds of lists: the lightweight marker syntax
+ * handled by `list.ts`, and the block-level syntax handled here.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseListBlock } from "./list-block";
+import { isNestedListOpen } from "./tags";
+
+/**
+ * Block rule for Wikidot explicit list syntax (`[[ul]]`/`[[ol]]`).
+ *
+ * The entry point verifies that the BLOCK_OPEN is followed by the name
+ * `"ul"` or `"ol"`, then delegates to `parseListBlock()`. On success
+ * a trailing `<br />` element is appended, matching Wikidot's rendering.
+ */
+export const blockListRule: BlockRule = {
+  name: "block-list",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    const listOpen = isNestedListOpen(ctx, ctx.pos);
+    if (!listOpen) {
+      return { success: false };
+    }
+
+    const result = parseListBlock(ctx, ctx.pos, listOpen.type);
+
+    if (!result) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [result.element, { element: "line-break" }],
+      consumed: result.consumed,
+    };
+  },
+};