@urbicon-ui/blocks 6.35.0 → 6.36.0

package/dist/components/Chat/markdown/blocks.js

@@ -0,0 +1,462 @@
+import { parseInlines } from './inline.js';
+import { repairMarkdownTail } from './repair.js';
+function splitLines(text) {
+    const lines = [];
+    let start = 0;
+    for (let i = 0; i <= text.length; i += 1) {
+        if (i === text.length || text[i] === '\n') {
+            lines.push({ text: text.slice(start, i), start });
+            start = i + 1;
+        }
+    }
+    return lines;
+}
+const FENCE_OPEN = /^ {0,3}(```+)\s*([^\s`]*)\s*$/;
+const HEADING = /^ {0,3}(#{1,6})\s+(.*?)(?:\s+#+\s*)?$/;
+const HR = /^ {0,3}([-*_])(?:\s*\1){2,}\s*$/;
+const QUOTE = /^ {0,3}>\s?/;
+const LIST_MARKER = /^(\s*)([-*+]|\d{1,9}[.)])(\s+|$)/;
+const TABLE_DELIMITER = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;
+const REF_DEF = /^ {0,3}\[([^\]]+)\]:\s*(\S+)(?:\s+["'(](.*)["')])?\s*$/;
+function isBlank(line) {
+    return line.trim().length === 0;
+}
+export function scanBlocks(text) {
+    const lines = splitLines(text);
+    const blocks = [];
+    const refs = new Map();
+    let unstableRefLabel;
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (isBlank(line.text)) {
+            i += 1;
+            continue;
+        }
+        const fence = FENCE_OPEN.exec(line.text);
+        if (fence) {
+            const marker = fence[1];
+            const code = [];
+            let open = true;
+            let j = i + 1;
+            for (; j < lines.length; j += 1) {
+                const closing = /^ {0,3}(```+)\s*$/.exec(lines[j].text);
+                if (closing && closing[1].length >= marker.length) {
+                    open = false;
+                    j += 1;
+                    break;
+                }
+                code.push(lines[j].text);
+            }
+            blocks.push({ type: 'fence', start: line.start, lang: fence[2] || undefined, code, open });
+            i = j;
+            continue;
+        }
+        const heading = HEADING.exec(line.text);
+        if (heading) {
+            blocks.push({
+                type: 'heading',
+                start: line.start,
+                level: heading[1].length,
+                text: heading[2]
+            });
+            i += 1;
+            continue;
+        }
+        if (HR.test(line.text) && !LIST_MARKER.test(line.text)) {
+            blocks.push({ type: 'hr', start: line.start });
+            i += 1;
+            continue;
+        }
+        if (QUOTE.test(line.text)) {
+            const quoteLines = [];
+            let j = i;
+            while (j < lines.length && QUOTE.test(lines[j].text)) {
+                quoteLines.push(lines[j].text.replace(QUOTE, ''));
+                j += 1;
+            }
+            blocks.push({ type: 'quote', start: line.start, lines: quoteLines });
+            i = j;
+            continue;
+        }
+        const listMatch = LIST_MARKER.exec(line.text);
+        if (listMatch && !HR.test(line.text)) {
+            const baseIndent = listMatch[1].length;
+            const ordered = /\d/.test(listMatch[2]);
+            const startNumber = ordered ? Number.parseInt(listMatch[2], 10) : undefined;
+            const listLines = [];
+            let j = i;
+            let pendingBlanks = 0;
+            while (j < lines.length) {
+                const current = lines[j].text;
+                if (isBlank(current)) {
+                    pendingBlanks += 1;
+                    j += 1;
+                    continue;
+                }
+                const marker = LIST_MARKER.exec(current);
+                const indent = /^\s*/.exec(current)?.[0].length ?? 0;
+                const isSameKindMarker = marker && marker[1].length <= baseIndent + 1 && /\d/.test(marker[2]) === ordered;
+                const isContinuation = indent >= baseIndent + 2;
+                const isLazy = pendingBlanks === 0 && listLines.length > 0 && !marker;
+                if (isSameKindMarker || isContinuation || (isLazy && indent > 0) || (isLazy && !marker)) {
+                    for (; pendingBlanks > 0; pendingBlanks -= 1)
+                        listLines.push('');
+                    listLines.push(current);
+                    j += 1;
+                    continue;
+                }
+                break;
+            }
+            blocks.push({ type: 'list', start: line.start, ordered, startNumber, lines: listLines });
+            i = j;
+            continue;
+        }
+        const refDef = REF_DEF.exec(line.text);
+        if (refDef) {
+            const label = refDef[1].trim().toLowerCase();
+            // First definition wins (CommonMark) — critical for stream/one-shot parity.
+            if (!refs.has(label)) {
+                refs.set(label, { href: refDef[2], title: refDef[3] });
+                // `splitLines` emits a trailing empty line when the text ends in \n,
+                // so index === length-1 means this line is still unterminated.
+                if (i === lines.length - 1)
+                    unstableRefLabel = label;
+            }
+            i += 1;
+            continue;
+        }
+        if (line.text.includes('|') &&
+            i + 1 < lines.length &&
+            TABLE_DELIMITER.test(lines[i + 1].text)) {
+            const rows = [];
+            let j = i + 2;
+            while (j < lines.length && !isBlank(lines[j].text) && lines[j].text.includes('|')) {
+                rows.push(lines[j].text);
+                j += 1;
+            }
+            blocks.push({
+                type: 'table',
+                start: line.start,
+                header: line.text,
+                delimiter: lines[i + 1].text,
+                rows
+            });
+            i = j;
+            continue;
+        }
+        // Paragraph: consecutive non-blank lines that start no other block type.
+        const paragraphLines = [line.text];
+        let j = i + 1;
+        while (j < lines.length) {
+            const current = lines[j].text;
+            if (isBlank(current) ||
+                FENCE_OPEN.test(current) ||
+                HEADING.test(current) ||
+                HR.test(current) ||
+                QUOTE.test(current) ||
+                LIST_MARKER.exec(current) ||
+                (current.includes('|') && j + 1 < lines.length && TABLE_DELIMITER.test(lines[j + 1].text))) {
+                break;
+            }
+            paragraphLines.push(current);
+            j += 1;
+        }
+        blocks.push({ type: 'paragraph', start: line.start, lines: paragraphLines });
+        i = j;
+    }
+    return { blocks, refs, unstableRefLabel };
+}
+function materialize(raw, ctx) {
+    switch (raw.type) {
+        case 'paragraph':
+            return { kind: 'paragraph', children: parseInlines(raw.lines.join('\n'), ctx) };
+        case 'heading':
+            return { kind: 'heading', level: raw.level, children: parseInlines(raw.text, ctx) };
+        case 'fence':
+            return {
+                kind: 'code-block',
+                lang: raw.lang,
+                code: raw.code.join('\n'),
+                ...(raw.open ? { open: true } : {})
+            };
+        case 'hr':
+            return { kind: 'hr' };
+        case 'quote': {
+            const inner = scanBlocks(raw.lines.join('\n'));
+            return { kind: 'blockquote', children: inner.blocks.map((b) => materialize(b, ctx)) };
+        }
+        case 'table':
+            return materializeTable(raw, ctx);
+        case 'list':
+            return materializeList(raw, ctx);
+    }
+}
+const TASK_MARKER = /^\[([ xX])\]\s+/;
+function materializeList(raw, ctx) {
+    const items = [];
+    let currentContent = null;
+    let currentChecked;
+    let contentIndent = 2;
+    const flush = () => {
+        if (currentContent === null)
+            return;
+        const inner = scanBlocks(currentContent.join('\n'));
+        items.push({
+            children: inner.blocks.map((b) => materialize(b, ctx)),
+            ...(currentChecked !== undefined ? { checked: currentChecked } : {})
+        });
+    };
+    for (const line of raw.lines) {
+        const marker = LIST_MARKER.exec(line);
+        const indent = /^\s*/.exec(line)?.[0].length ?? 0;
+        if (marker &&
+            indent <= (items.length === 0 && currentContent === null ? indent : contentIndent - 1)) {
+            flush();
+            contentIndent = marker[1].length + marker[2].length + (marker[3]?.length || 1);
+            let rest = line.slice(marker[0].length);
+            const task = TASK_MARKER.exec(rest);
+            currentChecked = undefined;
+            if (task) {
+                currentChecked = task[1] !== ' ';
+                rest = rest.slice(task[0].length);
+            }
+            currentContent = [rest];
+        }
+        else if (currentContent) {
+            currentContent.push(line.slice(Math.min(indent, contentIndent)));
+        }
+    }
+    flush();
+    return {
+        kind: 'list',
+        ordered: raw.ordered,
+        ...(raw.ordered && raw.startNumber !== undefined && raw.startNumber !== 1
+            ? { start: raw.startNumber }
+            : {}),
+        items
+    };
+}
+function splitTableRow(row) {
+    const cells = [];
+    let current = '';
+    for (let i = 0; i < row.length; i += 1) {
+        const ch = row[i];
+        if (ch === '\\' && row[i + 1] === '|') {
+            current += '|';
+            i += 1;
+        }
+        else if (ch === '|') {
+            cells.push(current);
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+    }
+    cells.push(current);
+    // Leading/trailing pipes produce empty edge cells — drop them.
+    if (cells.length > 0 && cells[0].trim() === '')
+        cells.shift();
+    if (cells.length > 0 && cells[cells.length - 1].trim() === '')
+        cells.pop();
+    return cells.map((c) => c.trim());
+}
+function materializeTable(raw, ctx) {
+    const align = splitTableRow(raw.delimiter).map((cell) => {
+        const left = cell.startsWith(':');
+        const right = cell.endsWith(':');
+        if (left && right)
+            return 'center';
+        if (right)
+            return 'right';
+        if (left)
+            return 'left';
+        return null;
+    });
+    const header = splitTableRow(raw.header).map((cell) => parseInlines(cell, ctx));
+    const rows = raw.rows.map((row) => splitTableRow(row).map((cell) => parseInlines(cell, ctx)));
+    return { kind: 'table', align, header, rows };
+}
+// ── Normalization (streaming-safe CRLF handling) ─────────────────────────────
+function normalizeChunk(chunk, prevEndedWithCR) {
+    let text = chunk;
+    if (prevEndedWithCR && text.startsWith('\n'))
+        text = text.slice(1);
+    const endsWithCR = text.endsWith('\r');
+    text = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    return { text, endsWithCR };
+}
+// ── One-shot parse ───────────────────────────────────────────────────────────
+export function parseMarkdown(text, options = {}) {
+    const normalized = normalizeChunk(text, false).text;
+    const { blocks: rawBlocks, refs } = scanBlocks(normalized);
+    const ctx = { linkRefs: refs, options };
+    const blocks = rawBlocks.map((raw, index) => Object.assign(materialize(raw, ctx), { key: index }));
+    return { blocks, linkRefs: refs };
+}
+// ── Incremental parser ───────────────────────────────────────────────────────
+/** Blocks kept unsettled at the end of the stream (see module docstring). */
+const TAIL_BUFFER = 2;
+export function createIncrementalParser(options = {}) {
+    let raw = '';
+    let norm = '';
+    let endsWithCR = false;
+    let settledUpTo = 0;
+    let settled = [];
+    let settledRefs = new Map();
+    let unresolvedLabels = new Set();
+    let nextKey = 0;
+    let doc = { blocks: [], linkRefs: settledRefs };
+    function mergeRefs(tailRefs) {
+        const merged = new Map(settledRefs);
+        for (const [label, def] of tailRefs) {
+            if (!merged.has(label))
+                merged.set(label, def);
+        }
+        return merged;
+    }
+    function compute() {
+        const tail = norm.slice(settledUpTo);
+        const scan = scanBlocks(tail);
+        const merged = mergeRefs(scan.refs);
+        // Late reference definition that a settled block failed to resolve →
+        // re-parse everything, reconciling keys so the UI patches in place. An
+        // unstable definition (final unterminated line) does not count as
+        // arrived yet — invalidating on it would freeze a half-streamed URL.
+        let invalidated = false;
+        for (const label of unresolvedLabels) {
+            if (scan.refs.has(label) && label !== scan.unstableRefLabel && !settledRefs.has(label)) {
+                invalidated = true;
+                break;
+            }
+        }
+        if (invalidated) {
+            const previous = doc.blocks;
+            settledUpTo = 0;
+            settled = [];
+            settledRefs = new Map();
+            unresolvedLabels = new Set();
+            nextKey = 0;
+            computeFresh(previous);
+            return;
+        }
+        computeTail(tail, scan, merged);
+    }
+    function computeFresh(previousBlocks) {
+        const tail = norm;
+        const scan = scanBlocks(tail);
+        computeTail(tail, scan, mergeRefs(scan.refs));
+        // Key reconciliation by position: same-kind blocks keep their old key.
+        let maxKey = -1;
+        doc.blocks.forEach((block, index) => {
+            const old = previousBlocks[index];
+            if (old && old.kind === block.kind)
+                block.key = old.key;
+            maxKey = Math.max(maxKey, block.key);
+        });
+        nextKey = Math.max(nextKey, maxKey + 1);
+    }
+    function computeTail(tail, scan, merged) {
+        const rawBlocks = scan.blocks;
+        // Settle everything before the second-to-last block. Never settle while
+        // the raw text ends in a bare CR (its normalization could still change).
+        if (rawBlocks.length > TAIL_BUFFER && !endsWithCR) {
+            const settleCount = rawBlocks.length - TAIL_BUFFER;
+            const boundary = rawBlocks[settleCount].start;
+            // Settling must never bake in a half-streamed definition — resolve
+            // against stable refs only; the unresolved hook plus the invalidation
+            // path above pick the block up once the definition completes.
+            const stableRefs = scan.unstableRefLabel === undefined ? merged : new Map(merged);
+            if (scan.unstableRefLabel !== undefined && !settledRefs.has(scan.unstableRefLabel)) {
+                stableRefs.delete(scan.unstableRefLabel);
+            }
+            const settleCtx = {
+                linkRefs: stableRefs,
+                options,
+                onUnresolvedRef: (label) => unresolvedLabels.add(label)
+            };
+            for (let k = 0; k < settleCount; k += 1) {
+                // A settling block must keep the key it was *displayed* under, or the
+                // keyed {#each} remounts it. In the steady state nextKey coincides
+                // with the shown key by construction, but after a computeFresh
+                // reconciliation the shown keys lag behind nextKey — so always prefer
+                // the previous document's key at this position (same kind).
+                const prevShown = doc.blocks[settled.length + k];
+                const block = materialize(rawBlocks[k], settleCtx);
+                block.key = prevShown && prevShown.kind === block.kind ? prevShown.key : nextKey;
+                nextKey = Math.max(nextKey, block.key + 1);
+                settled.push(block);
+            }
+            // Reference definitions inside the settled region become permanent.
+            const settledRegion = scanBlocks(tail.slice(0, boundary));
+            for (const [label, def] of settledRegion.refs) {
+                if (!settledRefs.has(label))
+                    settledRefs.set(label, def);
+            }
+            settledUpTo += boundary;
+            computeTail(norm.slice(settledUpTo), scanBlocks(norm.slice(settledUpTo)), merged);
+            return;
+        }
+        // Display path: repair only the last block's slice, then parse the buffer.
+        let displayText = tail;
+        if (rawBlocks.length > 0) {
+            const lastStart = rawBlocks[rawBlocks.length - 1].start;
+            displayText = tail.slice(0, lastStart) + repairMarkdownTail(tail.slice(lastStart));
+        }
+        const displayScan = scanBlocks(displayText);
+        const displayRefs = mergeRefs(displayScan.refs);
+        const ctx = { linkRefs: displayRefs, options };
+        // Tail keys mirror the settle path: reuse the key each position was last
+        // displayed under (kept stable across computeFresh reconciliation); fresh
+        // positions draw collision-free keys above nextKey without persisting the
+        // counter — the same position deterministically redraws the same key.
+        const usedKeys = new Set(settled.map((block) => block.key));
+        let alloc = nextKey;
+        const takeFresh = () => {
+            while (usedKeys.has(alloc))
+                alloc += 1;
+            const key = alloc;
+            alloc += 1;
+            return key;
+        };
+        const tailBlocks = displayScan.blocks.map((rawBlock, index) => {
+            const block = materialize(rawBlock, ctx);
+            const prevShown = doc.blocks[settled.length + index];
+            block.key =
+                prevShown && prevShown.kind === block.kind && !usedKeys.has(prevShown.key)
+                    ? prevShown.key
+                    : takeFresh();
+            usedKeys.add(block.key);
+            return block;
+        });
+        doc = { blocks: [...settled, ...tailBlocks], linkRefs: displayRefs };
+    }
+    return {
+        append(chunk) {
+            raw += chunk;
+            const normalized = normalizeChunk(chunk, endsWithCR);
+            norm += normalized.text;
+            endsWithCR = normalized.endsWithCR;
+            compute();
+            return doc;
+        },
+        get document() {
+            return doc;
+        },
+        get source() {
+            return raw;
+        },
+        reset() {
+            raw = '';
+            norm = '';
+            endsWithCR = false;
+            settledUpTo = 0;
+            settled = [];
+            settledRefs = new Map();
+            unresolvedLabels = new Set();
+            nextKey = 0;
+            doc = { blocks: [], linkRefs: settledRefs };
+        }
+    };
+}

package/dist/components/Chat/markdown/inline.d.ts

@@ -0,0 +1,31 @@
+import type { InlineNode, MarkdownParseOptions } from './types.js';
+/**
+ * Inline parser for the streaming-markdown subset: code spans, links/images
+ * (inline + reference + shortcut), citations, emphasis (`*`/`_`), strong,
+ * strikethrough (`~~`), hard breaks, optional autolinks. Raw HTML is not a
+ * concept here — angle brackets are plain text (decision A2).
+ *
+ * Two passes: tokenize into a flat list (code/link/image/citation/break/text
+ * and emphasis delimiter runs), then match delimiter runs into a tree. The
+ * delimiter rules are CommonMark-lite: `*` needs non-space on the inner side,
+ * `_` additionally must not sit inside a word, `~~` only pairs as a double.
+ */
+export interface InlineContext {
+    linkRefs: ReadonlyMap<string, {
+        href: string;
+        title?: string;
+    }>;
+    options: MarkdownParseOptions;
+    /**
+     * Fired for `[label][ref]` / `[label]` candidates whose definition is not
+     * (yet) known. The incremental parser uses this to know which settled
+     * blocks must be invalidated when a late `[ref]: url` definition streams in.
+     */
+    onUnresolvedRef?: (label: string) => void;
+}
+export declare function parseInlines(input: string, ctx: InlineContext): InlineNode[];
+/** Parse citation markers of the form 【id】 (some models emit fullwidth brackets). */
+export declare function tryFullwidthCitation(input: string, at: number, ctx: InlineContext): {
+    node: InlineNode;
+    end: number;
+} | null;