@wdprlib/parser 3.2.0 → 4.1.0

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

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

@@ -0,0 +1,75 @@
+import type { ParseContext } from "../../types";
+import { parseAttributes, parseBlockName } from "../utils";
+
+export interface TableRowOpenResult {
+  attrs: Record<string, string>;
+  pos: number;
+  consumed: number;
+}
+
+export function parseTableRowOpen(ctx: ParseContext, startPos: number): TableRowOpenResult | 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 !== "row") {
+    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 {
+    attrs: attrResult.attrs,
+    pos,
+    consumed,
+  };
+}
+
+export function isTableRowClose(ctx: ParseContext, pos: number): boolean {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+    return false;
+  }
+
+  return parseBlockName(ctx, pos + 1)?.name === "row";
+}
+
+export function consumeTableRowClose(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;
+}

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

@@ -0,0 +1,80 @@
+import type { TableCell, TableRow } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../utils";
+import { parseTableBlockCell } from "./cell";
+import { consumeTableRowClose, isTableRowClose, parseTableRowOpen } from "./row-boundary";
+
+/**
+ * Parses a `[[row ...]]...[[/row]]` block, collecting its child cells.
+ */
+export function parseTableBlockRow(
+  ctx: ParseContext,
+  startPos: number,
+): { row: TableRow; consumed: number } | null {
+  const openResult = parseTableRowOpen(ctx, startPos);
+  if (!openResult) {
+    return null;
+  }
+
+  let pos = openResult.pos;
+  let consumed = openResult.consumed;
+
+  const cells: TableCell[] = [];
+  let foundRowClose = false;
+
+  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;
+    }
+
+    if (isTableRowClose(ctx, pos)) {
+      foundRowClose = true;
+      const closeConsumed = consumeTableRowClose(ctx, pos);
+      pos += closeConsumed;
+      consumed += closeConsumed;
+      break;
+    }
+
+    if (token.type === "BLOCK_OPEN") {
+      const cellNameResult = parseBlockName(ctx, pos + 1);
+      if (cellNameResult?.name === "cell" || cellNameResult?.name === "hcell") {
+        const cellResult = parseTableBlockCell(ctx, pos);
+        if (cellResult) {
+          cells.push(cellResult.cell);
+          pos += cellResult.consumed;
+          consumed += cellResult.consumed;
+          continue;
+        }
+      }
+    }
+
+    pos++;
+    consumed++;
+  }
+
+  if (!foundRowClose) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-block",
+      message: "Missing closing tag [[/row]] for [[row]]",
+      position: ctx.tokens[startPos]?.position ?? {
+        start: { line: 0, column: 0, offset: 0 },
+        end: { line: 0, column: 0, offset: 0 },
+      },
+    });
+  }
+
+  return {
+    row: {
+      attributes: openResult.attrs,
+      cells,
+    },
+    consumed,
+  };
+}

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

@@ -0,0 +1,64 @@
+import type { TabData } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseTab } from "./tab";
+import { consumeNamedCloseTag, isTabviewClose } from "./tags";
+
+export interface TabviewBodyResult {
+  tabs: TabData[];
+  consumed: number;
+  closeConsumed: number;
+  foundClose: boolean;
+  invalidContent: boolean;
+}
+
+export function collectTabviewBody(ctx: ParseContext, startPos: number): TabviewBodyResult {
+  const tabs: TabData[] = [];
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    if (ctx.tokens[pos]?.type === "EOF") {
+      break;
+    }
+
+    if (isTabviewClose(ctx, pos)) {
+      return {
+        tabs,
+        consumed,
+        closeConsumed: consumeNamedCloseTag(ctx, pos),
+        foundClose: true,
+        invalidContent: false,
+      };
+    }
+
+    const tabResult = parseTab({ ...ctx, pos });
+    if (tabResult) {
+      tabs.push(tabResult.tab);
+      pos += tabResult.consumed;
+      consumed += tabResult.consumed;
+      continue;
+    }
+
+    if (ctx.tokens[pos]?.type === "WHITESPACE" || ctx.tokens[pos]?.type === "NEWLINE") {
+      pos++;
+      consumed++;
+      continue;
+    }
+
+    return {
+      tabs,
+      consumed,
+      closeConsumed: 0,
+      foundClose: false,
+      invalidContent: true,
+    };
+  }
+
+  return {
+    tabs,
+    consumed,
+    closeConsumed: 0,
+    foundClose: false,
+    invalidContent: false,
+  };
+}