@wdprlib/parser 3.1.2 → 4.0.0

package/src/parser/rules/inline/expr/branch.ts

@@ -0,0 +1,104 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { getCandidateInlineRules } from "../utils";
+import { advanceExprDepth } from "./depth";
+
+export interface BranchParseResult {
+  elements: Element[];
+  consumed: number;
+  endedWithPipe: boolean;
+}
+
+export interface ExpressionTextResult {
+  text: string;
+  consumed: number;
+  endedWithPipe: boolean;
+}
+
+/**
+ * Parses inline content for the then/else branches of `[[#if]]` and `[[#ifexpr]]`.
+ */
+export function parseInlineBranch(ctx: ParseContext, startPos: number): BranchParseResult {
+  const elements: Element[] = [];
+  let consumed = 0;
+  let pos = startPos;
+  let depth = 0;
+
+  const { inlineRules } = ctx;
+  const inlineCtx: ParseContext = { ...ctx, pos };
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF" || token.type === "NEWLINE") {
+      break;
+    }
+
+    const nextDepth = advanceExprDepth(token, depth);
+    if (nextDepth.shouldBreak) {
+      break;
+    }
+    depth = nextDepth.depth;
+
+    if (token.type === "PIPE" && depth === 0) {
+      return { elements, consumed, endedWithPipe: true };
+    }
+
+    inlineCtx.pos = pos;
+    let matched = false;
+
+    for (const rule of getCandidateInlineRules(inlineRules, token.type)) {
+      if (rule.startTokens.includes("PIPE") || rule.startTokens.includes("BLOCK_CLOSE")) {
+        continue;
+      }
+      const result = rule.parse(inlineCtx);
+      if (result.success) {
+        elements.push(...result.elements);
+        consumed += result.consumed;
+        pos += result.consumed;
+        matched = true;
+        break;
+      }
+    }
+
+    if (!matched) {
+      elements.push({ element: "text", data: token.value });
+      consumed++;
+      pos++;
+    }
+  }
+
+  return { elements, consumed, endedWithPipe: false };
+}
+
+/**
+ * Collects raw text for the expression or condition portion of expr rules.
+ */
+export function collectExpressionText(ctx: ParseContext, startPos: number): ExpressionTextResult {
+  const parts: string[] = [];
+  let consumed = 0;
+  let pos = startPos;
+  let depth = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF" || token.type === "NEWLINE") {
+      break;
+    }
+
+    const nextDepth = advanceExprDepth(token, depth);
+    if (nextDepth.shouldBreak) {
+      break;
+    }
+    depth = nextDepth.depth;
+
+    if (token.type === "PIPE" && depth === 0) {
+      return { text: parts.join("").trim(), consumed, endedWithPipe: true };
+    }
+
+    parts.push(token.value);
+    consumed++;
+    pos++;
+  }
+
+  return { text: parts.join("").trim(), consumed, endedWithPipe: false };
+}

package/src/parser/rules/inline/expr/conditional-branch.ts

@@ -0,0 +1,27 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseInlineBranch } from "./branch";
+import { skipWhitespace } from "./syntax";
+
+export interface ConditionalBranchResult {
+  elements: Element[];
+  consumed: number;
+  nextPos: number;
+  endedWithPipe: boolean;
+}
+
+export function parseConditionalBranch(
+  ctx: ParseContext,
+  startPos: number,
+): ConditionalBranchResult {
+  const branchStart = skipWhitespace(ctx, startPos);
+  const leadingWhitespaceConsumed = branchStart - startPos;
+  const branchResult = parseInlineBranch(ctx, branchStart);
+
+  return {
+    elements: branchResult.elements,
+    consumed: leadingWhitespaceConsumed + branchResult.consumed,
+    nextPos: branchStart + branchResult.consumed,
+    endedWithPipe: branchResult.endedWithPipe,
+  };
+}

package/src/parser/rules/inline/expr/conditional.ts

@@ -0,0 +1,80 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { currentToken } from "../../types";
+import { collectExpressionText } from "./branch";
+import { parseConditionalBranch } from "./conditional-branch";
+import { MAX_EXPRESSION_LENGTH, parseExprOpener } from "./syntax";
+
+export type ConditionalKeyword = "if" | "ifexpr";
+
+export type ConditionalParseResult =
+  | {
+      success: true;
+      head: string;
+      thenElements: Element[];
+      elseElements: Element[];
+      consumed: number;
+    }
+  | { success: false };
+
+export function parseConditional(
+  ctx: ParseContext,
+  keyword: ConditionalKeyword,
+): ConditionalParseResult {
+  if (currentToken(ctx).type !== "BLOCK_OPEN") {
+    return { success: false };
+  }
+
+  const opener = parseExprOpener(ctx, keyword);
+  if (!opener.success) {
+    return { success: false };
+  }
+
+  let pos = opener.pos;
+  let consumed = opener.consumed;
+
+  const headResult = collectExpressionText(ctx, pos);
+  if (!headResult.endedWithPipe || headResult.text.length > MAX_EXPRESSION_LENGTH) {
+    return { success: false };
+  }
+
+  pos += headResult.consumed;
+  consumed += headResult.consumed;
+
+  if (ctx.tokens[pos]?.type !== "PIPE") {
+    return { success: false };
+  }
+  pos++;
+  consumed++;
+
+  const thenResult = parseConditionalBranch(ctx, pos);
+  pos = thenResult.nextPos;
+  consumed += thenResult.consumed;
+
+  let elseElements: Element[] = [];
+  if (thenResult.endedWithPipe) {
+    if (ctx.tokens[pos]?.type !== "PIPE") {
+      return { success: false };
+    }
+    pos++;
+    consumed++;
+
+    const elseResult = parseConditionalBranch(ctx, pos);
+    elseElements = elseResult.elements;
+    pos = elseResult.nextPos;
+    consumed += elseResult.consumed;
+  }
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return { success: false };
+  }
+  consumed++;
+
+  return {
+    success: true,
+    head: headResult.text,
+    thenElements: thenResult.elements,
+    elseElements,
+    consumed,
+  };
+}

package/src/parser/rules/inline/expr/depth.ts

@@ -0,0 +1,25 @@
+import type { Token } from "../../../../lexer";
+
+export interface ExprDepthStep {
+  depth: number;
+  shouldBreak: boolean;
+}
+
+export function advanceExprDepth(token: Token, depth: number): ExprDepthStep {
+  if (
+    token.type === "BLOCK_OPEN" ||
+    token.type === "BLOCK_END_OPEN" ||
+    token.type === "LINK_OPEN"
+  ) {
+    return { depth: depth + 1, shouldBreak: false };
+  }
+
+  if (token.type === "BLOCK_CLOSE" || token.type === "LINK_CLOSE") {
+    if (depth === 0) {
+      return { depth, shouldBreak: true };
+    }
+    return { depth: depth - 1, shouldBreak: false };
+  }
+
+  return { depth, shouldBreak: false };
+}

package/src/parser/rules/inline/expr/elements.ts

@@ -0,0 +1,39 @@
+import type { Element } from "@wdprlib/ast";
+
+export function createExprElement(expression: string): Element {
+  return { element: "expr", data: { expression } };
+}
+
+export function createIfElement(
+  condition: string,
+  thenElements: Element[],
+  elseElements: Element[],
+): Element {
+  return {
+    element: "if",
+    data: {
+      condition,
+      // AST shape is fixed by @wdprlib/ast; this is not a Promise-like API.
+      // oxlint-disable-next-line unicorn/no-thenable
+      then: thenElements,
+      else: elseElements,
+    },
+  };
+}
+
+export function createIfExprElement(
+  expression: string,
+  thenElements: Element[],
+  elseElements: Element[],
+): Element {
+  return {
+    element: "ifexpr",
+    data: {
+      expression,
+      // AST shape is fixed by @wdprlib/ast; this is not a Promise-like API.
+      // oxlint-disable-next-line unicorn/no-thenable
+      then: thenElements,
+      else: elseElements,
+    },
+  };
+}

package/src/parser/rules/inline/expr/index.ts

@@ -0,0 +1,84 @@
+/**
+ * Public inline rules for Wikidot expression and conditional syntax.
+ *
+ * @module
+ */
+
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { collectExpressionText } from "./branch";
+import { parseConditional } from "./conditional";
+import { createExprElement, createIfElement, createIfExprElement } from "./elements";
+import { MAX_EXPRESSION_LENGTH, parseExprOpener } from "./syntax";
+
+export const exprRule: InlineRule = {
+  name: "expr",
+  startTokens: ["BLOCK_OPEN"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    if (currentToken(ctx).type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    const opener = parseExprOpener(ctx, "expr");
+    if (!opener.success) {
+      return { success: false };
+    }
+
+    let pos = opener.pos;
+    let consumed = opener.consumed;
+
+    const exprResult = collectExpressionText(ctx, pos);
+    const expression = exprResult.text;
+    pos += exprResult.consumed;
+    consumed += exprResult.consumed;
+
+    if (expression.length > MAX_EXPRESSION_LENGTH || ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      return { success: false };
+    }
+    consumed++;
+
+    return {
+      success: true,
+      elements: [createExprElement(expression)],
+      consumed,
+    };
+  },
+};
+
+export const ifRule: InlineRule = {
+  name: "if",
+  startTokens: ["BLOCK_OPEN"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const parsed = parseConditional(ctx, "if");
+    if (!parsed.success) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [createIfElement(parsed.head, parsed.thenElements, parsed.elseElements)],
+      consumed: parsed.consumed,
+    };
+  },
+};
+
+export const ifExprRule: InlineRule = {
+  name: "ifexpr",
+  startTokens: ["BLOCK_OPEN"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const parsed = parseConditional(ctx, "ifexpr");
+    if (!parsed.success) {
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements: [createIfExprElement(parsed.head, parsed.thenElements, parsed.elseElements)],
+      consumed: parsed.consumed,
+    };
+  },
+};

package/src/parser/rules/inline/expr/syntax.ts

@@ -0,0 +1,45 @@
+import type { ParseContext } from "../../types";
+
+export const MAX_EXPRESSION_LENGTH = 256;
+
+type ExprKeyword = "expr" | "if" | "ifexpr";
+
+export type ExprOpenerResult =
+  | { success: true; pos: number; consumed: number }
+  | { success: false };
+
+export function parseExprOpener(ctx: ParseContext, keyword: ExprKeyword): ExprOpenerResult {
+  let pos = ctx.pos + 1;
+  let consumed = 1;
+
+  const hashToken = ctx.tokens[pos];
+  if (!hashToken || hashToken.type !== "HASH") {
+    return { success: false };
+  }
+  pos++;
+  consumed++;
+
+  const idToken = ctx.tokens[pos];
+  if (!idToken || idToken.type !== "IDENTIFIER" || idToken.value !== keyword) {
+    return { success: false };
+  }
+  pos++;
+  consumed++;
+
+  const nextPos = skipWhitespace(ctx, pos);
+  consumed += nextPos - pos;
+
+  return {
+    success: true,
+    pos: nextPos,
+    consumed,
+  };
+}
+
+export function skipWhitespace(ctx: ParseContext, startPos: number): number {
+  let pos = startPos;
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+  }
+  return pos;
+}

package/src/parser/rules/inline/footnote/child.ts

@@ -0,0 +1,22 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseInlineUntil } from "../utils";
+
+export interface FootnoteChildResult {
+  elements: Element[];
+  consumed: number;
+}
+
+export function parseFootnoteChild(ctx: ParseContext, pos: number): FootnoteChildResult {
+  const token = ctx.tokens[pos];
+  if (!token) {
+    return { elements: [], consumed: 0 };
+  }
+
+  const inlineResult = parseInlineUntil({ ...ctx, pos }, "BLOCK_END_OPEN");
+  if (inlineResult.elements.length > 0) {
+    return { elements: inlineResult.elements, consumed: inlineResult.consumed };
+  }
+
+  return { elements: [{ element: "text", data: token.value }], consumed: 1 };
+}

package/src/parser/rules/inline/footnote/close.ts

@@ -0,0 +1,33 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../../common";
+
+export interface FootnoteCloseResult {
+  consumed: number;
+}
+
+export function tryConsumeFootnoteClose(
+  ctx: ParseContext,
+  pos: number,
+): FootnoteCloseResult | null {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") {
+    return null;
+  }
+
+  const closeNameResult = parseBlockName(ctx, pos + 1);
+  if (!closeNameResult || closeNameResult.name !== "footnote") {
+    return null;
+  }
+
+  let closePos = pos + 1 + closeNameResult.consumed;
+  let consumed = 1 + closeNameResult.consumed;
+
+  while (ctx.tokens[closePos]?.type === "WHITESPACE") {
+    closePos++;
+    consumed++;
+  }
+  if (ctx.tokens[closePos]?.type === "BLOCK_CLOSE") {
+    consumed++;
+  }
+
+  return { consumed };
+}

package/src/parser/rules/inline/footnote/content.ts

@@ -0,0 +1,54 @@
+import type { Element } from "@wdprlib/ast";
+import type { ParseContext } from "../../types";
+import { parseFootnoteChild } from "./child";
+import { tryConsumeFootnoteClose } from "./close";
+import { consumeFootnoteNewline } from "./newline";
+
+export interface FootnoteContentResult {
+  paragraphs: Element[][];
+  consumed: number;
+  foundClose: boolean;
+}
+
+export function parseFootnoteContent(ctx: ParseContext, startPos: number): FootnoteContentResult {
+  const paragraphs: Element[][] = [[]];
+  let currentParagraph = 0;
+  let pos = startPos;
+  let consumed = 0;
+
+  while (pos < ctx.tokens.length) {
+    const token = ctx.tokens[pos];
+    if (!token || token.type === "EOF") {
+      break;
+    }
+
+    const closeResult = tryConsumeFootnoteClose(ctx, pos);
+    if (closeResult) {
+      return {
+        paragraphs,
+        consumed: consumed + closeResult.consumed,
+        foundClose: true,
+      };
+    }
+
+    if (token.type === "NEWLINE") {
+      const newlineResult = consumeFootnoteNewline(ctx, pos);
+      pos += newlineResult.consumed;
+      consumed += newlineResult.consumed;
+      if (newlineResult.paragraphBreak) {
+        currentParagraph++;
+        paragraphs[currentParagraph] = [];
+      } else {
+        paragraphs[currentParagraph]!.push({ element: "line-break" });
+      }
+      continue;
+    }
+
+    const child = parseFootnoteChild(ctx, pos);
+    paragraphs[currentParagraph]!.push(...child.elements);
+    pos += child.consumed;
+    consumed += child.consumed;
+  }
+
+  return { paragraphs, consumed, foundClose: false };
+}

package/src/parser/rules/inline/footnote/elements.ts

@@ -0,0 +1,38 @@
+import type { Element } from "@wdprlib/ast";
+
+export function buildFootnoteChildren(paragraphs: Element[][]): Element[] {
+  const children: Element[] = [];
+
+  for (let i = 0; i < paragraphs.length; i++) {
+    const para = trimLineBreaks(paragraphs[i] ?? []);
+    if (para.length === 0) {
+      continue;
+    }
+
+    if (i === 0) {
+      children.push(...para);
+    } else {
+      children.push({
+        element: "container",
+        data: {
+          type: "paragraph",
+          attributes: {},
+          elements: para,
+        },
+      });
+    }
+  }
+
+  return children;
+}
+
+function trimLineBreaks(elements: Element[]): Element[] {
+  const result = [...elements];
+  while (result.length > 0 && result[0]?.element === "line-break") {
+    result.shift();
+  }
+  while (result.length > 0 && result[result.length - 1]?.element === "line-break") {
+    result.pop();
+  }
+  return result;
+}

package/src/parser/rules/inline/footnote/index.ts

@@ -0,0 +1,54 @@
+/**
+ *
+ * Parses the Wikidot footnote syntax: `[[footnote]]content[[/footnote]]`.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { InlineRule, ParseContext, RuleResult } from "../../types";
+import { currentToken } from "../../types";
+import { parseFootnoteContent } from "./content";
+import { buildFootnoteChildren } from "./elements";
+import { parseFootnoteOpen } from "./open";
+
+export const footnoteRule: InlineRule = {
+  name: "footnote",
+  startTokens: ["BLOCK_OPEN"],
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    const openResult = parseFootnoteOpen(ctx);
+    if (!openResult) {
+      return { success: false };
+    }
+
+    const contentResult = parseFootnoteContent(ctx, openResult.bodyStart);
+    const consumed = openResult.consumed + contentResult.consumed;
+    const children = buildFootnoteChildren(contentResult.paragraphs);
+
+    if (!contentResult.foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/footnote]] for [[footnote]]",
+        position: openToken.position,
+      });
+    }
+
+    ctx.footnotes.push(children);
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "footnote",
+        },
+      ],
+      consumed,
+    };
+  },
+};

package/src/parser/rules/inline/footnote/newline.ts

@@ -0,0 +1,27 @@
+import type { ParseContext } from "../../types";
+
+export interface FootnoteNewlineResult {
+  consumed: number;
+  paragraphBreak: boolean;
+}
+
+export function consumeFootnoteNewline(ctx: ParseContext, pos: number): FootnoteNewlineResult {
+  let nextPos = pos + 1;
+  let consumed = 1;
+
+  while (ctx.tokens[nextPos]?.type === "WHITESPACE") {
+    nextPos++;
+    consumed++;
+  }
+
+  if (ctx.tokens[nextPos]?.type !== "NEWLINE") {
+    return { consumed, paragraphBreak: false };
+  }
+
+  while (ctx.tokens[nextPos]?.type === "NEWLINE") {
+    nextPos++;
+    consumed++;
+  }
+
+  return { consumed, paragraphBreak: true };
+}

package/src/parser/rules/inline/footnote/open.ts

@@ -0,0 +1,38 @@
+import type { ParseContext } from "../../types";
+import { parseBlockName } from "../../common";
+
+export interface FootnoteOpenResult {
+  bodyStart: number;
+  consumed: number;
+}
+
+export function parseFootnoteOpen(ctx: ParseContext): FootnoteOpenResult | null {
+  if (ctx.tokens[ctx.pos]?.type !== "BLOCK_OPEN") {
+    return null;
+  }
+
+  let pos = ctx.pos + 1;
+  let consumed = 1;
+
+  const nameResult = parseBlockName(ctx, pos);
+  if (!nameResult || nameResult.name !== "footnote") {
+    return null;
+  }
+
+  pos += nameResult.consumed;
+  consumed += nameResult.consumed;
+
+  while (ctx.tokens[pos]?.type === "WHITESPACE") {
+    pos++;
+    consumed++;
+  }
+
+  if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+    return null;
+  }
+
+  pos++;
+  consumed++;
+
+  return { bodyStart: pos, consumed };
+}