@wdprlib/parser 3.2.0 → 4.1.0

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

@@ -0,0 +1,90 @@
+/**
+ *
+ * Block rule for Wikidot tabbed content: `[[tabview]]` (or `[[tabs]]`).
+ *
+ * A tabview contains one or more `[[tab Label]]...[[/tab]]` blocks:
+ *
+ * ```
+ * [[tabview]]
+ * [[tab First Tab]]
+ * Content of the first tab.
+ * [[/tab]]
+ * [[tab Second Tab]]
+ * Content of the second tab.
+ * [[/tab]]
+ * [[/tabview]]
+ * ```
+ *
+ * Key behaviours:
+ * - Both `[[tabview]]` and `[[tabs]]` are accepted as the outer wrapper.
+ * - Any attributes or text after the block name on the opening tag are
+ *   silently ignored (Wikidot behaviour: `[[tabview Foo]]` is valid).
+ * - If a tab has no label, it defaults to `"untitled"`.
+ * - Tab body content is parsed as block-level markup.
+ * - An empty tabview (no tabs) fails the rule, falling back to text.
+ * - Non-tab content between tabs (other than whitespace/newlines) causes
+ *   the rule to fail.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { collectTabviewBody } from "./body";
+import { parseTabviewOpen } from "./open";
+
+/**
+ * Block rule for `[[tabview]]`/`[[tabs]]` with `[[tab]]` children.
+ */
+export const tabviewRule: BlockRule = {
+  name: "tabview",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    const openResult = parseTabviewOpen(ctx, ctx.pos);
+    if (!openResult) {
+      return { success: false };
+    }
+
+    const bodyResult = collectTabviewBody(ctx, ctx.pos + openResult.consumed);
+    let consumed = openResult.consumed + bodyResult.consumed;
+
+    if (bodyResult.invalidContent) {
+      return { success: false };
+    }
+
+    if (!bodyResult.foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: `Missing closing tag [[/${openResult.blockName}]] for [[${openResult.blockName}]]`,
+        position: openToken.position,
+      });
+    }
+
+    if (bodyResult.closeConsumed > 0) {
+      consumed += bodyResult.closeConsumed;
+    }
+
+    if (bodyResult.tabs.length === 0) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "tab-view",
+          data: bodyResult.tabs,
+        },
+      ],
+      consumed,
+    };
+  },
+};

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

@@ -0,0 +1,50 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../utils";
+
+export interface TabviewOpenResult {
+  blockName: string;
+  consumed: number;
+}
+
+export function parseTabviewOpen(ctx: ParseContext, startPos: number): TabviewOpenResult | null {
+  if (ctx.tokens[startPos]?.type !== "BLOCK_OPEN") {
+    return null;
+  }
+
+  let pos = startPos + 1;
+  let consumed = 1;
+
+  const nameResult = parseBlockName(ctx, pos);
+  if (!nameResult) {
+    return null;
+  }
+
+  const blockName = nameResult.name.toLowerCase();
+  if (blockName !== "tabview" && blockName !== "tabs") {
+    return null;
+  }
+
+  pos += nameResult.consumed;
+  consumed += nameResult.consumed;
+
+  while (
+    pos < ctx.tokens.length &&
+    ctx.tokens[pos]?.type !== "BLOCK_CLOSE" &&
+    ctx.tokens[pos]?.type !== "NEWLINE"
+  ) {
+    pos++;
+    consumed++;
+  }
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    consumed++;
+  }
+
+  return { blockName, consumed };
+}

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

@@ -0,0 +1,92 @@
+import type { TabData } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseBlockName, parseBlocksUntil } from "../utils";
+import { consumeNamedCloseTag, isTabClose } from "./tags";
+
+/**
+ * Parses a single `[[tab Label]]...[[/tab]]` block within a tabview.
+ */
+export function parseTab(ctx: ParseContext): { tab: TabData; consumed: number } | null {
+  let pos = ctx.pos;
+  let consumed = 0;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE" || ctx.tokens[pos]?.type === "NEWLINE") {
+    pos++;
+    consumed++;
+  }
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_OPEN") {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  const nameResult = parseBlockName(ctx, pos);
+  if (!nameResult || nameResult.name.toLowerCase() !== "tab") {
+    return null;
+  }
+  pos += nameResult.consumed;
+  consumed += nameResult.consumed;
+
+  let label = "";
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token) break;
+    if (token.type === "BLOCK_CLOSE") {
+      break;
+    }
+    if (token.type === "NEWLINE") {
+      return null;
+    }
+    if (label === "" && token.type === "WHITESPACE") {
+      pos++;
+      consumed++;
+      continue;
+    }
+    label += token.value;
+    pos++;
+    consumed++;
+  }
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+  pos++;
+  consumed++;
+
+  if (ctx.tokens[pos]?.type === "NEWLINE") {
+    pos++;
+    consumed++;
+  }
+
+  const bodyCtx: ParseContext = { ...ctx, pos };
+  const bodyResult = parseBlocksUntil(bodyCtx, (checkCtx) => isTabClose(checkCtx, checkCtx.pos));
+  consumed += bodyResult.consumed;
+  pos += bodyResult.consumed;
+
+  if (!isTabClose(ctx, pos)) {
+    ctx.diagnostics.push({
+      severity: "warning",
+      code: "unclosed-block",
+      message: "Missing closing tag [[/tab]] for [[tab]]",
+      position: ctx.tokens[ctx.pos]?.position ?? {
+        start: { line: 0, column: 0, offset: 0 },
+        end: { line: 0, column: 0, offset: 0 },
+      },
+    });
+  }
+
+  if (isTabClose(ctx, pos)) {
+    const closeConsumed = consumeNamedCloseTag(ctx, pos);
+    pos += closeConsumed;
+    consumed += closeConsumed;
+  }
+
+  return {
+    tab: {
+      label: label.trim() || "untitled",
+      elements: bodyResult.elements,
+    },
+    consumed,
+  };
+}

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

@@ -0,0 +1,30 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../utils";
+
+export function isTabClose(ctx: ParseContext, pos: number): boolean {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") return false;
+  const closeNameResult = parseBlockName(ctx, pos + 1);
+  return closeNameResult?.name.toLowerCase() === "tab";
+}
+
+export function isTabviewClose(ctx: ParseContext, pos: number): boolean {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") return false;
+  const closeNameResult = parseBlockName(ctx, pos + 1);
+  const closeName = closeNameResult?.name.toLowerCase();
+  return closeName === "tabview" || closeName === "tabs";
+}
+
+export function consumeNamedCloseTag(ctx: ParseContext, pos: number): number {
+  let consumed = 1;
+  const closeNameResult = parseBlockName(ctx, pos + 1);
+  if (closeNameResult) {
+    consumed += closeNameResult.consumed;
+  }
+  if (ctx.tokens[pos + consumed]?.type === "BLOCK_CLOSE") {
+    consumed++;
+  }
+  if (ctx.tokens[pos + consumed]?.type === "NEWLINE") {
+    consumed++;
+  }
+  return consumed;
+}

package/src/parser/rules/block/toc/element.ts

@@ -0,0 +1,11 @@
+import type { Alignment, Element } from "@wdprlib/ast";
+
+export function createTocElement(align: Alignment | null): Element {
+  return {
+    element: "table-of-contents",
+    data: {
+      attributes: {},
+      align,
+    },
+  };
+}

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

@@ -0,0 +1,44 @@
+/**
+ * Table of contents rule: [[toc]], [[f<toc ...]], [[f>toc ...]]
+ *
+ * Variants:
+ * - [[toc]] - basic TOC
+ * - [[f<toc ...]] - float left
+ * - [[f>toc ...]] - float right
+ *
+ * Note: Wikidot ignores attributes on [[toc]] (class, style, id are not applied)
+ * [[>toc]] and [[<toc]] are invalid in Wikidot and not supported.
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { createTocElement } from "./element";
+import { parseTocOpen } from "./open";
+
+export const tocRule: BlockRule = {
+  name: "toc",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: true,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    if (!ctx.settings.enablePageSyntax) {
+      return { success: false };
+    }
+
+    const openResult = parseTocOpen(ctx, ctx.pos);
+    if (!openResult) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [createTocElement(openResult.align)],
+      consumed: openResult.consumed,
+    };
+  },
+};

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

@@ -0,0 +1,84 @@
+import type { Alignment } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+
+export interface TocOpenResult {
+  align: Alignment | null;
+  consumed: number;
+}
+
+export function parseTocOpen(ctx: ParseContext, startPos: number): TocOpenResult | null {
+  if (ctx.tokens[startPos]?.type !== "BLOCK_OPEN") {
+    return null;
+  }
+
+  let pos = startPos + 1;
+  let align: Alignment | null = null;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+  }
+
+  const firstToken = ctx.tokens[pos];
+  if (!isNameToken(firstToken)) {
+    return null;
+  }
+
+  const firstValue = firstToken.value.toLowerCase();
+  if (firstValue === "toc") {
+    pos++;
+  } else if (firstValue === "f") {
+    pos++;
+    const dirToken = ctx.tokens[pos];
+    if (dirToken?.type === "TEXT" && dirToken.value === "<") {
+      align = "left";
+      pos++;
+    } else if (dirToken?.type === "TEXT" && dirToken.value === ">") {
+      align = "right";
+      pos++;
+    } else {
+      return null;
+    }
+
+    const tocToken = ctx.tokens[pos];
+    if (!isNameToken(tocToken) || tocToken.value.toLowerCase() !== "toc") {
+      return null;
+    }
+    pos++;
+  } else {
+    return null;
+  }
+
+  pos = skipUntilClose(ctx, pos);
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+
+  return {
+    align,
+    consumed: pos + 1 - startPos,
+  };
+}
+
+function skipUntilClose(ctx: ParseContext, startPos: number): number {
+  let pos = startPos;
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (
+      !token ||
+      token.type === "BLOCK_CLOSE" ||
+      token.type === "NEWLINE" ||
+      token.type === "EOF"
+    ) {
+      break;
+    }
+    pos++;
+  }
+  return pos;
+}
+
+function isNameToken(
+  token: ParseContext["tokens"][number] | undefined,
+): token is ParseContext["tokens"][number] & { type: "TEXT" | "IDENTIFIER" } {
+  return token?.type === "TEXT" || token?.type === "IDENTIFIER";
+}