@wdprlib/parser 3.2.0 → 4.0.0

package/src/parser/rules/block/parsing/rule-dispatch.ts

@@ -0,0 +1,44 @@
+import type { Token } from "../../../../lexer";
+import type { BlockRule } from "../../types";
+
+/**
+ * Determines whether a block rule is eligible for the current token.
+ *
+ * A rule is eligible if:
+ * 1. The token is at line start (when `rule.requiresLineStart` is true).
+ * 2. The token's type is in the rule's `startTokens` list (or the list
+ *    is empty, meaning the rule is a universal fallback).
+ *
+ * @param rule  - The block rule to check.
+ * @param token - The current token.
+ * @returns `true` if the rule may be attempted.
+ */
+export function canApplyBlockRule(rule: BlockRule, token: Token): boolean {
+  if (rule.requiresLineStart && !token.lineStart) {
+    return false;
+  }
+  if (rule.startTokens.length === 0) {
+    return true; // fallback rule
+  }
+  return rule.startTokens.includes(token.type);
+}
+
+const blockRuleCandidateCache = new WeakMap<BlockRule[], Map<string, BlockRule[]>>();
+
+export function getCandidateBlockRules(blockRules: BlockRule[], token: Token): BlockRule[] {
+  let byToken = blockRuleCandidateCache.get(blockRules);
+  if (!byToken) {
+    byToken = new Map();
+    blockRuleCandidateCache.set(blockRules, byToken);
+  }
+
+  const key = `${token.type}:${token.lineStart ? "1" : "0"}`;
+  const cached = byToken.get(key);
+  if (cached) {
+    return cached;
+  }
+
+  const candidates = blockRules.filter((rule) => canApplyBlockRule(rule, token));
+  byToken.set(key, candidates);
+  return candidates;
+}

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

@@ -0,0 +1,80 @@
+/**
+ *
+ * Block rule for Wikidot pipe-syntax tables.
+ *
+ * Wikidot tables are written using `||` delimiters at the start of a line:
+ *
+ * ```
+ * || Cell 1 || Cell 2 ||
+ * || Cell 3 || Cell 4 ||
+ * ```
+ *
+ * Cell variants:
+ * - `||` -- normal cell (`<td>`)
+ * - `||~` -- header cell (`<th>`)
+ * - `||<` -- left-aligned cell
+ * - `||>` -- right-aligned cell (TABLE_RIGHT)
+ * - `||=` -- center-aligned cell
+ *
+ * Colspan is achieved by using multiple consecutive `||` before content:
+ * `||||` = colspan 2, `||||||` = colspan 3, etc.
+ *
+ * Key Wikidot behaviour:
+ * - Cells MUST be terminated by another `||` (or variant). Unterminated
+ *   cells (reaching end of line without a closing `||`) are discarded.
+ * - If all cells in a row are unterminated, one empty cell is kept.
+ * - Content within cells supports inline markup (bold, links, etc.).
+ * - Leading and trailing whitespace in cell content is trimmed.
+ *
+ * The table element carries `_source: "pipe"` in its attributes to
+ * distinguish it from block-syntax tables (`[[table]]`).
+ *
+ * @module
+ */
+import type { Element, TableData } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { isPipeTableToken, parsePipeTableRows } from "./pipe";
+
+/**
+ * Block rule for pipe-syntax tables.
+ *
+ * Parsing strategy:
+ * 1. Verify the first token is a table column token at line start.
+ * 2. Parse consecutive rows (each row is a line starting with a table
+ *    column token).
+ * 3. Each row is parsed by `parseTableRow()`, which iterates cells
+ *    via `parseCellStart()` and `parseTableCell()`.
+ * 4. Emit a `table` element with `_source: "pipe"`.
+ */
+export const tableRule: BlockRule = {
+  name: "table",
+  startTokens: ["TABLE_MARKER", "TABLE_HEADER", "TABLE_LEFT", "TABLE_CENTER", "TABLE_RIGHT"],
+  requiresLineStart: true,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const firstToken = currentToken(ctx);
+
+    if (!firstToken.lineStart || !isPipeTableToken(firstToken.type)) {
+      return { success: false };
+    }
+
+    const rowResult = parsePipeTableRows(ctx, ctx.pos);
+
+    const tableData: TableData = {
+      attributes: { _source: "pipe" },
+      rows: rowResult.rows,
+    };
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "table",
+          data: tableData,
+        },
+      ],
+      consumed: rowResult.consumed,
+    };
+  },
+};

package/src/parser/rules/block/table/pipe/cell-start.ts

@@ -0,0 +1,69 @@
+import type { Alignment } from "@wdprlib/ast";
+import type { ParseContext } from "../../../types";
+
+export interface CellStart {
+  align?: Alignment;
+  header: boolean;
+  colspan: number;
+}
+
+export function parseCellStart(
+  ctx: ParseContext,
+  startPos: number,
+): { cellStart: CellStart; consumed: number } | null {
+  let pos = startPos;
+  let colspan = 0;
+  let align: Alignment | undefined;
+  let header = false;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token) break;
+
+    if (token.type === "TABLE_HEADER") {
+      colspan++;
+      header = true;
+      pos++;
+      break;
+    }
+    if (token.type === "TABLE_LEFT") {
+      colspan++;
+      align = "left";
+      pos++;
+      break;
+    }
+    if (token.type === "TABLE_CENTER") {
+      colspan++;
+      align = "center";
+      pos++;
+      break;
+    }
+    if (token.type === "TABLE_RIGHT") {
+      colspan++;
+      align = "right";
+      pos++;
+      break;
+    }
+    if (token.type === "TABLE_MARKER") {
+      colspan++;
+      pos++;
+      continue;
+    }
+    if (colspan > 0) {
+      return {
+        cellStart: { align, header, colspan },
+        consumed: pos - startPos,
+      };
+    }
+    return null;
+  }
+
+  if (colspan > 0) {
+    return {
+      cellStart: { align, header, colspan },
+      consumed: pos - startPos,
+    };
+  }
+
+  return null;
+}

package/src/parser/rules/block/table/pipe/cell.ts

@@ -0,0 +1,106 @@
+import type { Element, TableCell } from "@wdprlib/ast";
+import type { ParseContext } from "../../../types";
+import { getCandidateInlineRules } from "../../../inline/utils";
+import type { CellStart } from "./cell-start";
+import { isPipeTableToken } from "./tokens";
+import { trimElements } from "./trim";
+
+export function parseTableCell(
+  ctx: ParseContext,
+  startPos: number,
+  cellStart: CellStart,
+): { cell: TableCell; consumed: number; terminatedProperly: boolean } {
+  let pos = startPos;
+  let consumed = 0;
+  const children: Element[] = [];
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  const { inlineRules } = ctx;
+  const inlineCtx: ParseContext = { ...ctx, pos };
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "NEWLINE" || token.type === "EOF") {
+      break;
+    }
+    if (isPipeTableToken(token.type)) {
+      break;
+    }
+
+    if (tryConsumeUnderscoreLineBreak(ctx, pos, children)) {
+      pos += 3;
+      consumed += 3;
+      continue;
+    }
+
+    if (token.type === "WHITESPACE") {
+      children.push({ element: "text", data: token.value });
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    inlineCtx.pos = pos;
+    let matched = false;
+
+    for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
+      const result = rule.parse(inlineCtx);
+      if (result.success) {
+        children.push(...result.elements);
+        consumed += result.consumed;
+        pos += result.consumed;
+        matched = true;
+        break;
+      }
+    }
+
+    if (!matched) {
+      children.push({ element: "text", data: token.value });
+      consumed++;
+      pos++;
+    }
+  }
+
+  const currentToken = ctx.tokens[pos];
+  const terminatedProperly = currentToken ? isPipeTableToken(currentToken.type) : false;
+
+  return {
+    cell: {
+      header: cellStart.header,
+      "column-span": cellStart.colspan,
+      align: terminatedProperly ? (cellStart.align ?? null) : null,
+      attributes: {},
+      elements: terminatedProperly ? trimElements(children) : [],
+    },
+    consumed,
+    terminatedProperly,
+  };
+}
+
+function tryConsumeUnderscoreLineBreak(
+  ctx: ParseContext,
+  pos: number,
+  children: Element[],
+): boolean {
+  const token = ctx.tokens[pos];
+  if (token?.type !== "WHITESPACE") {
+    return false;
+  }
+
+  const nextTok = ctx.tokens[pos + 1];
+  const afterTok = ctx.tokens[pos + 2];
+  if (
+    nextTok?.type === "UNDERSCORE" &&
+    afterTok &&
+    (afterTok.type === "NEWLINE" || afterTok.type === "EOF")
+  ) {
+    children.push({ element: "line-break" });
+    return true;
+  }
+
+  return false;
+}

package/src/parser/rules/block/table/pipe/index.ts

@@ -0,0 +1,2 @@
+export { isPipeTableToken } from "./tokens";
+export { parsePipeTableRows } from "./row";

package/src/parser/rules/block/table/pipe/row.ts

@@ -0,0 +1,88 @@
+import type { TableCell, TableRow } from "@wdprlib/ast";
+import type { ParseContext } from "../../../types";
+import { parseCellStart } from "./cell-start";
+import { parseTableCell } from "./cell";
+import { isPipeTableToken } from "./tokens";
+
+export function parsePipeTableRows(
+  ctx: ParseContext,
+  startPos: number,
+): { rows: TableRow[]; consumed: number } {
+  const rows: TableRow[] = [];
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+
+    if (!token || !token.lineStart || !isPipeTableToken(token.type)) {
+      break;
+    }
+
+    const rowResult = parseTableRow(ctx, pos);
+    rows.push(rowResult.row);
+    pos += rowResult.consumed;
+    consumed += rowResult.consumed;
+  }
+
+  return { rows, consumed };
+}
+
+function parseTableRow(ctx: ParseContext, startPos: number): { row: TableRow; consumed: number } {
+  const cells: TableCell[] = [];
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "NEWLINE" || token.type === "EOF") {
+      break;
+    }
+
+    const startResult = parseCellStart(ctx, pos);
+    if (!startResult) {
+      break;
+    }
+
+    pos += startResult.consumed;
+    consumed += startResult.consumed;
+
+    const nextToken = ctx.tokens[pos];
+    if (!nextToken || nextToken.type === "NEWLINE" || nextToken.type === "EOF") {
+      break;
+    }
+
+    const cellResult = parseTableCell(ctx, pos, startResult.cellStart);
+    if (cellResult.terminatedProperly) {
+      cells.push(cellResult.cell);
+    }
+    pos += cellResult.consumed;
+    consumed += cellResult.consumed;
+  }
+
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    consumed++;
+  }
+
+  if (cells.length === 0) {
+    cells.push(createEmptyTableCell());
+  }
+
+  return {
+    row: {
+      attributes: {},
+      cells,
+    },
+    consumed,
+  };
+}
+
+function createEmptyTableCell(): TableCell {
+  return {
+    header: false,
+    "column-span": 1,
+    align: null,
+    attributes: {},
+    elements: [],
+  };
+}

package/src/parser/rules/block/table/pipe/tokens.ts

@@ -0,0 +1,14 @@
+import type { TokenType } from "../../../../../lexer/tokens";
+
+export function isPipeTableToken(type: TokenType): boolean {
+  switch (type) {
+    case "TABLE_MARKER":
+    case "TABLE_HEADER":
+    case "TABLE_LEFT":
+    case "TABLE_CENTER":
+    case "TABLE_RIGHT":
+      return true;
+    default:
+      return false;
+  }
+}

package/src/parser/rules/block/table/pipe/trim.ts

@@ -0,0 +1,50 @@
+import type { Element } from "@wdprlib/ast";
+
+export function trimElements(elements: Element[]): Element[] {
+  let start = 0;
+  let end = elements.length;
+  let firstReplacement: Element | null = null;
+  let lastReplacement: Element | null = null;
+
+  while (start < end) {
+    const first = elements[start];
+    if (first?.element !== "text" || typeof first.data !== "string") {
+      break;
+    }
+
+    const trimmed = first.data.trimStart();
+    if (trimmed === "") {
+      start++;
+    } else {
+      firstReplacement = trimmed === first.data ? null : { element: "text", data: trimmed };
+      break;
+    }
+  }
+
+  while (start < end) {
+    const last = elements[end - 1];
+    if (last?.element !== "text" || typeof last.data !== "string") {
+      break;
+    }
+
+    const trimmed = last.data.trimEnd();
+    if (trimmed === "") {
+      end--;
+    } else {
+      lastReplacement = trimmed === last.data ? null : { element: "text", data: trimmed };
+      break;
+    }
+  }
+
+  const result = elements.slice(start, end);
+  if (result.length > 0) {
+    if (firstReplacement) {
+      result[0] = firstReplacement;
+    }
+    if (lastReplacement) {
+      result[result.length - 1] = lastReplacement;
+    }
+  }
+
+  return result;
+}

package/src/parser/rules/block/table-block/body.ts

@@ -0,0 +1,79 @@
+import type { TableRow } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../utils";
+import { parseTableBlockRow } from "./structure";
+
+export interface TableBlockBodyResult {
+  rows: TableRow[];
+  consumed: number;
+  foundClose: boolean;
+}
+
+export function collectTableBlockBody(ctx: ParseContext, startPos: number): TableBlockBodyResult {
+  const rows: TableRow[] = [];
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    while (ctx.tokens[pos]?.type === "WHITESPACE" || ctx.tokens[pos]?.type === "NEWLINE") {
+      pos++;
+      consumed++;
+    }
+
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      break;
+    }
+
+    const closeConsumed = consumeTableClose(ctx, pos);
+    if (closeConsumed !== null) {
+      return {
+        rows,
+        consumed: consumed + closeConsumed,
+        foundClose: true,
+      };
+    }
+
+    if (token.type === "BLOCK_OPEN") {
+      const rowNameResult = parseBlockName(ctx, pos + 1);
+      if (rowNameResult?.name === "row") {
+        const rowResult = parseTableBlockRow(ctx, pos);
+        if (rowResult) {
+          rows.push(rowResult.row);
+          pos += rowResult.consumed;
+          consumed += rowResult.consumed;
+          continue;
+        }
+      }
+    }
+
+    pos++;
+    consumed++;
+  }
+
+  return { rows, consumed, foundClose: false };
+}
+
+function consumeTableClose(ctx: ParseContext, startPos: number): number | null {
+  if (ctx.tokens[startPos]?.type !== "BLOCK_END_OPEN") {
+    return null;
+  }
+
+  const closeNameResult = parseBlockName(ctx, startPos + 1);
+  if (closeNameResult?.name !== "table") {
+    return null;
+  }
+
+  let pos = startPos + 1 + closeNameResult.consumed;
+  let consumed = 1 + closeNameResult.consumed;
+
+  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
+    pos++;
+    consumed++;
+  }
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    consumed++;
+  }
+
+  return consumed;
+}

package/src/parser/rules/block/table-block/cell-attributes.ts

@@ -0,0 +1,33 @@
+import type { Alignment } from "@wdprlib/ast";
+
+export interface ParsedTableCellAttributes {
+  colspan: number;
+  align: Alignment | null;
+  attributes: Record<string, string>;
+}
+
+export function parseTableCellAttributes(attrs: Record<string, string>): ParsedTableCellAttributes {
+  const cellAttrs = { ...attrs };
+  const colspan = cellAttrs.colspan ? parseInt(cellAttrs.colspan, 10) : 1;
+  const align = parseCellAlignment(cellAttrs.style);
+
+  delete cellAttrs.colspan;
+
+  return {
+    colspan,
+    align,
+    attributes: cellAttrs,
+  };
+}
+
+function parseCellAlignment(style: string | undefined): Alignment | null {
+  if (!style) return null;
+
+  const alignMatch = style.match(/text-align:\s*(left|center|right)/i);
+  const value = alignMatch?.[1]?.toLowerCase();
+  return isAlignment(value) ? value : null;
+}
+
+function isAlignment(value: string | undefined): value is Alignment {
+  return value === "left" || value === "center" || value === "right";
+}

package/src/parser/rules/block/table-block/cell-boundary.ts

@@ -0,0 +1,99 @@
+import type { ParseContext } from "../../types";
+import { parseAttributes, parseBlockName } from "../utils";
+
+export type TableCellTagName = "cell" | "hcell";
+
+export interface TableCellOpenResult {
+  tagName: TableCellTagName;
+  isHeader: boolean;
+  attrs: Record<string, string>;
+  pos: number;
+  consumed: number;
+}
+
+export function parseTableCellOpen(
+  ctx: ParseContext,
+  startPos: number,
+): TableCellOpenResult | 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 || !isTableCellTagName(nameResult.name)) {
+    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 {
+    tagName: nameResult.name,
+    isHeader: nameResult.name === "hcell",
+    attrs: attrResult.attrs,
+    pos,
+    consumed,
+  };
+}
+
+export function isTableCellClose(
+  ctx: ParseContext,
+  pos: number,
+  closeName: TableCellTagName,
+): boolean {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+    return false;
+  }
+
+  return parseBlockName(ctx, pos + 1)?.name === closeName;
+}
+
+export function createCellCloseCondition(
+  closeName: TableCellTagName,
+): (ctx: ParseContext) => boolean {
+  return (ctx: ParseContext): boolean => isTableCellClose(ctx, ctx.pos, closeName);
+}
+
+export function consumeTableCellClose(ctx: ParseContext, startPos: number): number {
+  let pos = startPos + 1;
+  let consumed = 1;
+
+  const closeNameResult = parseBlockName(ctx, pos);
+  if (closeNameResult) {
+    pos += closeNameResult.consumed;
+    consumed += closeNameResult.consumed;
+  }
+  if (ctx.tokens[pos]?.type === "BLOCK_CLOSE") {
+    pos++;
+    consumed++;
+  }
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    consumed++;
+  }
+
+  return consumed;
+}
+
+function isTableCellTagName(name: string): name is TableCellTagName {
+  return name === "cell" || name === "hcell";
+}