@wdprlib/parser 3.1.2 → 4.0.0

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";
+}

package/src/parser/rules/block/table-block/cell-content/index.ts

@@ -0,0 +1,88 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../../types";
+import { getCandidateInlineRules } from "../../../inline/utils";
+import { getCandidateBlockRules } from "../../utils";
+import { createCellContentAccumulator, unwrapSingleInlineParagraph } from "./segments";
+import { consumeCellContentNewline } from "../cell-newline";
+
+export interface CellContentResult {
+  elements: Element[];
+  consumed: number;
+  hadParagraphBreaks: boolean;
+}
+
+export { unwrapSingleInlineParagraph };
+
+export function parseCellContent(
+  ctx: ParseContext,
+  closeCondition: (ctx: ParseContext) => boolean,
+): CellContentResult {
+  const content = createCellContentAccumulator();
+  let consumed = 0;
+  let pos = ctx.pos;
+  const checkCtx: ParseContext = { ...ctx, pos };
+  const blockCtx: ParseContext = { ...ctx, pos };
+  const inlineCtx: ParseContext = { ...ctx, pos };
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      break;
+    }
+
+    checkCtx.pos = pos;
+    if (closeCondition(checkCtx)) {
+      break;
+    }
+
+    if (token.type === "NEWLINE") {
+      const newlineResult = consumeCellContentNewline(ctx, pos, content);
+      consumed += newlineResult.consumed;
+      pos += newlineResult.consumed;
+      continue;
+    }
+
+    if (token.type === "WHITESPACE" && token.lineStart) {
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    let matched = false;
+    blockCtx.pos = pos;
+
+    for (const rule of getCandidateBlockRules(ctx.blockRules, token)) {
+      const result = rule.parse(blockCtx);
+      if (result.success) {
+        content.addBlockElements(result.elements);
+        consumed += result.consumed;
+        pos += result.consumed;
+        matched = true;
+        break;
+      }
+    }
+
+    if (matched) continue;
+
+    inlineCtx.pos = pos;
+
+    for (const rule of getCandidateInlineRules(ctx.inlineRules, token.type)) {
+      const result = rule.parse(inlineCtx);
+      if (result.success) {
+        content.addInlineElements(result.elements);
+        consumed += result.consumed;
+        pos += result.consumed;
+        matched = true;
+        break;
+      }
+    }
+
+    if (!matched) {
+      content.addInline({ element: "text", data: token.value });
+      consumed++;
+      pos++;
+    }
+  }
+
+  return { ...content.finish(), consumed };
+}

package/src/parser/rules/block/table-block/cell-content/segments.ts

@@ -0,0 +1,134 @@
+import type { Element } from "@wdprlib/ast";
+
+export interface CellContentAccumulator {
+  addInline(element: Element): void;
+  addInlineElements(elements: Element[]): void;
+  addBlockElements(elements: Element[]): void;
+  addParagraphBreak(): void;
+  closeInlineSegmentBeforeBlock(): void;
+  isEmpty(): boolean;
+  finish(): { elements: Element[]; hadParagraphBreaks: boolean };
+}
+
+export function createCellContentAccumulator(): CellContentAccumulator {
+  const elements: Element[] = [];
+  let currentSegment: Element[] = [];
+  let hasMultipleParts = false;
+  let hasBlockElement = false;
+  let hadParagraphBreaks = false;
+
+  const flushSegment = (wrapInParagraph: boolean) => {
+    trimSegment(currentSegment);
+    if (currentSegment.length === 0) return;
+
+    if (wrapInParagraph) {
+      elements.push({
+        element: "container",
+        data: {
+          type: "paragraph",
+          attributes: {},
+          elements: [...currentSegment],
+        },
+      });
+    } else {
+      elements.push(...currentSegment);
+    }
+    currentSegment = [];
+  };
+
+  return {
+    addInline(element: Element) {
+      currentSegment.push(element);
+    },
+    addInlineElements(nextElements: Element[]) {
+      currentSegment.push(...nextElements);
+    },
+    addBlockElements(blockElements: Element[]) {
+      if (currentSegment.length > 0) {
+        flushSegment(true);
+        hasMultipleParts = true;
+      }
+
+      elements.push(...blockElements);
+      hasBlockElement = true;
+      hasMultipleParts = true;
+    },
+    addParagraphBreak() {
+      flushSegment(true);
+      hasMultipleParts = true;
+      hadParagraphBreaks = true;
+    },
+    closeInlineSegmentBeforeBlock() {
+      flushSegment(true);
+      hasMultipleParts = true;
+    },
+    isEmpty() {
+      return currentSegment.length === 0 && elements.length === 0;
+    },
+    finish() {
+      flushSegment(hasMultipleParts || hasBlockElement);
+      return { elements, hadParagraphBreaks };
+    },
+  };
+}
+
+export function unwrapSingleInlineParagraph(elements: Element[]): Element[] {
+  if (elements.length !== 1) {
+    return elements;
+  }
+
+  const first = elements[0];
+  if (first?.element !== "container" || first.data.type !== "paragraph") {
+    return elements;
+  }
+
+  const innerElements = first.data.elements;
+  const hasBlockElement = innerElements.some((element) => isBlockElement(element));
+  return hasBlockElement ? elements : innerElements;
+}
+
+function trimSegment(elements: Element[]): void {
+  trimSegmentEnd(elements);
+  trimSegmentStart(elements);
+}
+
+function trimSegmentEnd(elements: Element[]): void {
+  while (elements.length > 0) {
+    const last = elements[elements.length - 1];
+    if (isBlankText(last) || last?.element === "line-break") {
+      elements.pop();
+      continue;
+    }
+
+    break;
+  }
+}
+
+function trimSegmentStart(elements: Element[]): void {
+  while (elements.length > 0 && isBlankText(elements[0])) {
+    elements.shift();
+  }
+}
+
+function isBlankText(element: Element | undefined): boolean {
+  return (
+    element?.element === "text" && typeof element.data === "string" && element.data.trim() === ""
+  );
+}
+
+function isBlockElement(element: Element): boolean {
+  switch (element.element) {
+    case "table":
+    case "code":
+    case "list":
+    case "iframe":
+      return true;
+  }
+
+  return (
+    element.element === "container" &&
+    (element.data.type === "paragraph" ||
+      element.data.type === "div" ||
+      element.data.type === "blockquote")
+  );
+}

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

@@ -0,0 +1,47 @@
+import type { ParseContext } from "../../types";
+import type { CellContentAccumulator } from "./cell-content/segments";
+
+export interface CellNewlineResult {
+  consumed: number;
+}
+
+export function consumeCellContentNewline(
+  ctx: ParseContext,
+  startPos: number,
+  content: CellContentAccumulator,
+): CellNewlineResult {
+  let pos = startPos + 1;
+  let consumed = 1;
+
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    while (ctx.tokens[pos]?.type === "NEWLINE") {
+      pos++;
+      consumed++;
+    }
+
+    content.addParagraphBreak();
+
+    while (ctx.tokens[pos]?.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+    }
+
+    return { consumed };
+  }
+
+  const nextToken = ctx.tokens[pos];
+  if (!nextToken || nextToken.type === "BLOCK_END_OPEN" || nextToken.type === "EOF") {
+    return { consumed };
+  }
+
+  if (nextToken.type === "BLOCK_OPEN") {
+    content.closeInlineSegmentBeforeBlock();
+    return { consumed };
+  }
+
+  if (!content.isEmpty()) {
+    content.addInline({ element: "line-break" });
+  }
+
+  return { consumed };
+}

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

@@ -0,0 +1,64 @@
+import type { TableCell } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseTableCellAttributes } from "./cell-attributes";
+import {
+  consumeTableCellClose,
+  createCellCloseCondition,
+  parseTableCellOpen,
+} from "./cell-boundary";
+import { parseCellContent, unwrapSingleInlineParagraph } from "./cell-content";
+
+/**
+ * Parses a `[[cell ...]]...[[/cell]]` or `[[hcell ...]]...[[/hcell]]` block.
+ */
+export function parseTableBlockCell(
+  ctx: ParseContext,
+  startPos: number,
+): { cell: TableCell; consumed: number } | null {
+  const openResult = parseTableCellOpen(ctx, startPos);
+  if (!openResult) {
+    return null;
+  }
+
+  let pos = openResult.pos;
+  let consumed = openResult.consumed;
+  const cellAttrs = parseTableCellAttributes(openResult.attrs);
+  const closeName = openResult.tagName;
+  const bodyCtx: ParseContext = { ...ctx, pos };
+  const bodyResult = parseCellContent(bodyCtx, createCellCloseCondition(closeName));
+  consumed += bodyResult.consumed;
+  pos += bodyResult.consumed;
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-block",
+      message: `Missing closing tag [[/${closeName}]] for [[${closeName}]]`,
+      position: ctx.tokens[startPos]?.position ?? {
+        start: { line: 0, column: 0, offset: 0 },
+        end: { line: 0, column: 0, offset: 0 },
+      },
+    });
+  }
+
+  if (ctx.tokens[pos]?.type === "BLOCK_END_OPEN") {
+    const closeConsumed = consumeTableCellClose(ctx, pos);
+    pos += closeConsumed;
+    consumed += closeConsumed;
+  }
+
+  const elements = bodyResult.hadParagraphBreaks
+    ? bodyResult.elements
+    : unwrapSingleInlineParagraph(bodyResult.elements);
+
+  return {
+    cell: {
+      header: openResult.isHeader,
+      "column-span": cellAttrs.colspan,
+      align: cellAttrs.align,
+      attributes: cellAttrs.attributes,
+      elements,
+    },
+    consumed,
+  };
+}

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

@@ -0,0 +1,113 @@
+/**
+ *
+ * Block rule for the explicit block-syntax table:
+ * `[[table]][[row]][[cell]]...[[/cell]][[/row]][[/table]]`.
+ *
+ * This is the structured alternative to the pipe-syntax table (`||`).
+ * Each element carries optional HTML attributes:
+ *
+ * ```
+ * [[table class="wiki-table"]]
+ *   [[row]]
+ *     [[hcell style="width: 50%"]]Header[[/hcell]]
+ *     [[cell colspan="2"]]Data[[/cell]]
+ *   [[/row]]
+ * [[/table]]
+ * ```
+ *
+ * Key details:
+ * - `[[hcell]]` produces header cells (`<th>`), `[[cell]]` produces data
+ *   cells (`<td>`).
+ * - `colspan` is extracted from cell attributes and mapped to `column-span`.
+ * - Alignment can be derived from the `style` attribute's `text-align` value.
+ * - Cell content supports both block and inline elements, including nested
+ *   tables. The custom `parseCellContent()` handles paragraph wrapping
+ *   and block detection within cells.
+ * - Empty tables or tables with only empty rows fail the rule, falling
+ *   back to text rendering.
+ * - The table element carries `_source: "block"` in attributes to
+ *   distinguish it from pipe-syntax tables.
+ *
+ * @module
+ */
+import type { Element, TableData } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseBlockName, parseAttributes } from "../utils";
+import { collectTableBlockBody } from "./body";
+
+/**
+ * Block rule for `[[table]]...[[/table]]` with `[[row]]` and
+ * `[[cell]]`/`[[hcell]]` children.
+ */
+export const tableBlockRule: BlockRule = {
+  name: "table-block",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    let pos = ctx.pos + 1;
+    let consumed = 1;
+
+    const nameResult = parseBlockName(ctx, pos);
+    if (!nameResult || nameResult.name !== "table") {
+      return { success: false };
+    }
+
+    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 { success: false };
+    }
+    pos++;
+    consumed++;
+
+    if (ctx.tokens[pos]?.type === "NEWLINE") {
+      pos++;
+      consumed++;
+    }
+
+    const bodyResult = collectTableBlockBody(ctx, pos);
+    consumed += bodyResult.consumed;
+
+    if (!bodyResult.foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/table]] for [[table]]",
+        position: openToken.position,
+      });
+    }
+
+    const hasValidContent = bodyResult.rows.some((row) => row.cells.length > 0);
+    if (!hasValidContent) {
+      return { success: false };
+    }
+
+    const tableData: TableData = {
+      attributes: { ...attrResult.attrs, _source: "block" },
+      rows: bodyResult.rows,
+    };
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "table",
+          data: tableData,
+        },
+      ],
+      consumed,
+    };
+  },
+};