@wdprlib/parser 3.1.2 → 3.2.0

package/src/parser/rules/block/orphan-li.ts

@@ -0,0 +1,177 @@
+/**
+ *
+ * Block rule for `[[li]]...[[/li]]` appearing outside of any `[[ul]]`/`[[ol]]` block.
+ *
+ * When `[[li]]` is used without an enclosing list block, Wikidot does NOT
+ * create a list item. Instead, it treats the tags as literal text and
+ * renders the body content without `<p>` wrapping, using `<br />` for
+ * newlines.
+ *
+ * Example input:
+ * ```
+ * [[li]]
+ * Baz
+ * [[/li]]
+ * ```
+ *
+ * Rendered output:
+ * ```
+ * [[li]]<br />Baz<br />[[/li]]
+ * ```
+ *
+ * This rule exists to correctly consume and reproduce that output. Without
+ * it, the parser would try to match `[[li]]` against other block rules
+ * and potentially produce incorrect results.
+ *
+ * If no `[[/li]]` closing tag is found, the rule fails.
+ *
+ * @module
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../types";
+import { currentToken } from "../types";
+import { parseBlockName } from "./utils";
+
+/**
+ * Tests whether the tokens at `pos` form a `[[li]]` opening tag.
+ * Only the exact name `"li"` matches; `[[li_]]` is not recognised.
+ *
+ * @param ctx - Parse context.
+ * @param pos - Token index to inspect.
+ * @returns The number of tokens consumed, or `null` if not matched.
+ */
+function isLiOpen(ctx: ParseContext, pos: number): { consumed: number } | null {
+  if (ctx.tokens[pos]?.type !== "BLOCK_OPEN") return null;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (!nameResult) return null;
+  if (nameResult.name === "li") {
+    return { consumed: 1 + nameResult.consumed };
+  }
+  return null;
+}
+
+/**
+ * Tests whether the tokens at `pos` form a `[[/li]]` closing tag.
+ *
+ * @param ctx - Parse context.
+ * @param pos - Token index to inspect.
+ * @returns The number of tokens consumed (including BLOCK_CLOSE), or `null`.
+ */
+function isLiClose(ctx: ParseContext, pos: number): { consumed: number } | null {
+  if (ctx.tokens[pos]?.type !== "BLOCK_END_OPEN") return null;
+  const nameResult = parseBlockName(ctx, pos + 1);
+  if (!nameResult || nameResult.name !== "li") return null;
+  let consumed = 1 + nameResult.consumed;
+  if (ctx.tokens[pos + consumed]?.type === "BLOCK_CLOSE") consumed++;
+  return { consumed };
+}
+
+/**
+ * Block rule for orphaned `[[li]]...[[/li]]` (outside any list block).
+ *
+ * The opening and closing tags are emitted as literal text elements, and
+ * newlines within the body become `<br />` elements. Leading whitespace
+ * on each line is discarded.
+ */
+export const orphanLiRule: BlockRule = {
+  name: "orphan-li",
+  startTokens: ["BLOCK_OPEN"],
+  requiresLineStart: false,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    const openToken = currentToken(ctx);
+    if (openToken.type !== "BLOCK_OPEN") {
+      return { success: false };
+    }
+
+    // Check for [[li]] (not [[li_]])
+    const liOpen = isLiOpen(ctx, ctx.pos);
+    if (!liOpen) {
+      return { success: false };
+    }
+
+    let pos = ctx.pos + liOpen.consumed;
+    let consumed = liOpen.consumed;
+
+    // Expect ]]
+    if (ctx.tokens[pos]?.type !== "BLOCK_CLOSE") {
+      return { success: false };
+    }
+    pos++;
+    consumed++;
+
+    // Collect content until [[/li]]
+    const elements: Element[] = [];
+    let foundClose = false;
+
+    // Output [[li]] as text
+    elements.push({ element: "text", data: "[[" });
+    elements.push({ element: "text", data: "li" });
+    elements.push({ element: "text", data: "]]" });
+
+    // Wikidot outputs: [[li]]<br />Baz<br />[[/li]]
+    // - Newline after [[li]] becomes <br />
+    // - Newline after content becomes <br />
+    // - No <br /> right before [[/li]]
+
+    while (pos < ctx.tokens.length) {
+      const token = ctx.tokens[pos];
+      if (!token || token.type === "EOF") break;
+
+      // Check for [[/li]] close
+      const liClose = isLiClose(ctx, pos);
+      if (liClose) {
+        foundClose = true;
+        // Output [[/li]] as text (no <br /> before it)
+        elements.push({ element: "text", data: "[[/" });
+        elements.push({ element: "text", data: "li" });
+        elements.push({ element: "text", data: "]]" });
+        consumed += liClose.consumed;
+        pos += liClose.consumed;
+        // Skip trailing newline
+        if (ctx.tokens[pos]?.type === "NEWLINE") {
+          pos++;
+          consumed++;
+        }
+        break;
+      }
+
+      // Handle newlines - convert to <br />
+      if (token.type === "NEWLINE") {
+        elements.push({ element: "line-break" });
+        pos++;
+        consumed++;
+        continue;
+      }
+
+      // Skip leading whitespace on lines
+      if (token.type === "WHITESPACE" && token.lineStart) {
+        pos++;
+        consumed++;
+        continue;
+      }
+
+      // Other content
+      elements.push({ element: "text", data: token.value });
+      pos++;
+      consumed++;
+    }
+
+    // Require closing tag - without it, fail to prevent consuming entire document
+    if (!foundClose) {
+      ctx.diagnostics.push({
+        severity: "warning",
+        code: "unclosed-block",
+        message: "Missing closing tag [[/li]] for [[li]]",
+        position: openToken.position,
+      });
+      return { success: false };
+    }
+
+    return {
+      success: true,
+      elements,
+      consumed,
+    };
+  },
+};

package/src/parser/rules/block/paragraph.ts

@@ -0,0 +1,157 @@
+/**
+ * Paragraph rule
+ *
+ * Collects inline content until paragraph break (double newline) or end of input.
+ * Line breaks within paragraphs are handled by the newlineLineBreakRule.
+ */
+import type { Element } from "@wdprlib/ast";
+import type { BlockRule, ParseContext, RuleResult } from "../types";
+import { parseInlineUntil } from "../inline/utils";
+
+/**
+ * Process closeSpan markers in inline content
+ * When we find a _closeSpan marker, wrap all preceding content in a span
+ */
+function processCloseSpanMarkers(elements: Element[]): Element[] {
+  const result: Element[] = [];
+
+  for (let i = 0; i < elements.length; i++) {
+    const elem = elements[i];
+
+    if (!elem) continue;
+
+    // Check for closeSpan marker
+    if (
+      elem.element === "container" &&
+      elem.data &&
+      typeof elem.data === "object" &&
+      "type" in elem.data &&
+      elem.data.type === "span" &&
+      "attributes" in elem.data &&
+      typeof elem.data.attributes === "object" &&
+      elem.data.attributes &&
+      "_closeSpan" in elem.data.attributes
+    ) {
+      // Wrap all preceding content in a span
+      if (result.length > 0) {
+        const spanContent = [...result];
+        result.length = 0; // Clear result
+        result.push({
+          element: "container",
+          data: {
+            type: "span",
+            attributes: {},
+            elements: spanContent,
+          },
+        });
+      }
+      // Don't add the marker itself to output
+    } else {
+      result.push(elem);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Paragraph is the fallback block rule
+ * It collects inline content until blank line (double newline)
+ *
+ * Wikidot behavior:
+ * - Single newline → <br> (handled by newlineLineBreakRule)
+ * - Blank line (double newline) → new paragraph
+ */
+export const paragraphRule: BlockRule = {
+  name: "paragraph",
+  startTokens: [], // matches anything not matched by other rules
+  requiresLineStart: false,
+
+  parse(ctx: ParseContext): RuleResult<Element> {
+    // Parse inline content, including NEWLINEs
+    // Stop at double NEWLINE (paragraph break) or EOF
+    const result = parseInlineContent(ctx);
+
+    // Filter out empty paragraphs
+    if (result.elements.length === 0) {
+      return { success: false };
+    }
+
+    // Process closeSpan markers (for split spans)
+    let elements = processCloseSpanMarkers(result.elements);
+
+    // Remove trailing line-breaks (they shouldn't appear at end of paragraph)
+    // Exception: line-breaks flagged by preserveTrailingLineBreak context are kept
+    while (elements.length > 0 && elements[elements.length - 1]?.element === "line-break") {
+      const lastEl = elements[elements.length - 1] as any;
+      if (lastEl._preservedTrailingBreak) {
+        delete lastEl._preservedTrailingBreak;
+        break;
+      }
+      elements.pop();
+    }
+
+    // Remove trailing whitespace-only text nodes
+    while (elements.length > 0) {
+      const last = elements[elements.length - 1];
+      if (
+        last?.element === "text" &&
+        "data" in last &&
+        typeof last.data === "string" &&
+        last.data.trim() === ""
+      ) {
+        elements.pop();
+      } else {
+        break;
+      }
+    }
+
+    // Remove leading line-breaks
+    while (elements.length > 0 && elements[0]?.element === "line-break") {
+      elements.shift();
+    }
+
+    if (elements.length === 0) {
+      return { success: false };
+    }
+
+    // Wikidot: text lines immediately before a definition list are not
+    // wrapped in <p>. Check if next token starts a definition list.
+    const nextPos = ctx.pos + result.consumed;
+    const nextToken = ctx.tokens[nextPos];
+    if (nextToken?.type === "COLON" && nextToken.lineStart) {
+      return {
+        success: true,
+        elements: [...elements, { element: "line-break" }],
+        consumed: result.consumed,
+      };
+    }
+
+    return {
+      success: true,
+      elements: [
+        {
+          element: "container",
+          data: {
+            type: "paragraph",
+            attributes: {},
+            elements,
+          },
+        },
+      ],
+      consumed: result.consumed,
+    };
+  },
+};
+
+/**
+ * Parse inline content until paragraph break or EOF
+ */
+function parseInlineContent(ctx: ParseContext): {
+  elements: Element[];
+  consumed: number;
+} {
+  // Use the standard inline parser which now handles NEWLINEs
+  // The parser will stop at double NEWLINE (paragraph break)
+  return parseInlineUntil(ctx, "PARAGRAPH_BREAK" as any);
+}