@wdprlib/parser 3.2.0 → 4.0.0

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

@@ -1,177 +0,0 @@
-/**
- *
- * 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

@@ -1,157 +0,0 @@
-/**
- * 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);
-}