@vesk/runtime 0.0.1

package/dist/md.js

@@ -0,0 +1,507 @@
+// =============================================================
+// Markdown rendering for <Md content={...} />.
+//
+// Tokenizer-based (no regex) — mirrors the compiler's no-regex
+// rule for source-text handling. Raw HTML is never passed through;
+// everything is escaped so content is safe to render as-is.
+// =============================================================
+export function escapeHtml(s) {
+    let out = '';
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === '&')
+            out += '&amp;';
+        else if (ch === '<')
+            out += '&lt;';
+        else if (ch === '>')
+            out += '&gt;';
+        else if (ch === '"')
+            out += '&quot;';
+        else
+            out += ch;
+    }
+    return out;
+}
+function isBlank(line) {
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch !== ' ' && ch !== '\t')
+            return false;
+    }
+    return true;
+}
+function leadingSpaces(line) {
+    let n = 0;
+    for (let i = 0; i < line.length; i++) {
+        if (line[i] === '\t')
+            n += 4 - (n % 4);
+        else if (line[i] === ' ')
+            n++;
+        else
+            break;
+    }
+    return n;
+}
+function headingLevel(line) {
+    let n = 0;
+    while (n < line.length && line[n] === '#')
+        n++;
+    if (n === 0 || n > 6)
+        return 0;
+    if (n < line.length && (line[n] === ' ' || line[n] === '\t'))
+        return n;
+    return 0;
+}
+function isHr(line) {
+    const t = line.trim();
+    if (t.length < 3)
+        return false;
+    const ch = t[0];
+    if (ch !== '-' && ch !== '*' && ch !== '_')
+        return false;
+    for (let i = 1; i < t.length; i++) {
+        if (t[i] !== ch && t[i] !== ' ')
+            return false;
+    }
+    return true;
+}
+function fenceInfo(line) {
+    const t = line.trim();
+    const ch = t[0];
+    if (ch !== '`' && ch !== '~')
+        return null;
+    let n = 0;
+    while (n < t.length && t[n] === ch)
+        n++;
+    if (n < 3)
+        return null;
+    return { char: ch, len: n, lang: t.slice(n).trim() };
+}
+function isFenceClose(line, char, len) {
+    const t = line.trim();
+    if (t[0] !== char)
+        return false;
+    let n = 0;
+    while (n < t.length && t[n] === char)
+        n++;
+    if (n < len)
+        return false;
+    for (let i = n; i < t.length; i++) {
+        if (t[i] !== ' ')
+            return false;
+    }
+    return true;
+}
+function parseListMarker(line) {
+    const indent = leadingSpaces(line);
+    let i = indent;
+    const ch = line[i];
+    if (ch === '-' || ch === '*' || ch === '+') {
+        if (i + 1 < line.length && (line[i + 1] === ' ' || line[i + 1] === '\t')) {
+            return { ordered: false, number: 0, indent, contentStart: i + 2 };
+        }
+        return null;
+    }
+    let num = 0;
+    const digitsStart = i;
+    while (i < line.length && line[i] >= '0' && line[i] <= '9') {
+        num = num * 10 + (line.charCodeAt(i) - 48);
+        i++;
+    }
+    if (i === digitsStart)
+        return null;
+    if (i < line.length && line[i] === '.' && i + 1 < line.length && (line[i + 1] === ' ' || line[i + 1] === '\t')) {
+        return { ordered: true, number: num, indent, contentStart: i + 2 };
+    }
+    return null;
+}
+function parseBlocks(lines) {
+    const blocks = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (isBlank(line)) {
+            i++;
+            continue;
+        }
+        const trimmed = line.trim();
+        const indent = leadingSpaces(line);
+        const fence = fenceInfo(trimmed);
+        if (fence) {
+            const codeLines = [];
+            i++;
+            while (i < lines.length) {
+                const l = lines[i];
+                if (isFenceClose(l, fence.char, fence.len)) {
+                    i++;
+                    break;
+                }
+                codeLines.push(l);
+                i++;
+            }
+            blocks.push({ type: 'code', code: codeLines.join('\n'), lang: fence.lang });
+            continue;
+        }
+        if (indent >= 4) {
+            const codeLines = [];
+            while (i < lines.length) {
+                const l = lines[i];
+                if (isBlank(l)) {
+                    codeLines.push('');
+                    i++;
+                    continue;
+                }
+                const lIndent = leadingSpaces(l);
+                if (lIndent < 4)
+                    break;
+                codeLines.push(l.slice(4));
+                i++;
+            }
+            while (codeLines.length > 0 && codeLines[codeLines.length - 1] === '')
+                codeLines.pop();
+            blocks.push({ type: 'code', code: codeLines.join('\n'), lang: '' });
+            continue;
+        }
+        const level = headingLevel(line);
+        if (level > 0) {
+            blocks.push({ type: 'heading', level, text: line.slice(level).trim() });
+            i++;
+            continue;
+        }
+        if (isHr(line)) {
+            blocks.push({ type: 'hr' });
+            i++;
+            continue;
+        }
+        if (trimmed[0] === '>') {
+            const quoteLines = [];
+            while (i < lines.length) {
+                const l = lines[i];
+                const t = l.trim();
+                if (isBlank(l))
+                    break;
+                if (t[0] !== '>')
+                    break;
+                let rest = t.length > 1 ? t.slice(1) : '';
+                if (rest[0] === ' ')
+                    rest = rest.slice(1);
+                quoteLines.push(rest);
+                i++;
+            }
+            blocks.push({ type: 'blockquote', blocks: parseBlocks(quoteLines) });
+            continue;
+        }
+        const marker = parseListMarker(line);
+        if (marker) {
+            const list = {
+                type: 'list',
+                ordered: marker.ordered,
+                items: [],
+            };
+            while (i < lines.length) {
+                const l = lines[i];
+                const m = parseListMarker(l);
+                if (!m)
+                    break;
+                if (m.ordered !== list.ordered)
+                    break;
+                const contentIndent = m.contentStart;
+                const itemLines = [l.slice(m.contentStart)];
+                i++;
+                while (i < lines.length) {
+                    const c = lines[i];
+                    if (isBlank(c)) {
+                        i++;
+                        continue;
+                    }
+                    const cm = parseListMarker(c);
+                    const cIndent = leadingSpaces(c);
+                    if (cm && cIndent < contentIndent && cm.ordered === m.ordered)
+                        break;
+                    if (cIndent >= contentIndent) {
+                        itemLines.push(c.slice(Math.min(c.length, contentIndent)));
+                        i++;
+                        continue;
+                    }
+                    break;
+                }
+                list.items.push({ blocks: parseBlocks(itemLines) });
+            }
+            blocks.push(list);
+            continue;
+        }
+        const paraLines = [trimmed];
+        i++;
+        while (i < lines.length) {
+            const l = lines[i];
+            if (isBlank(l))
+                break;
+            const t = l.trim();
+            if (headingLevel(l) > 0)
+                break;
+            if (isHr(l))
+                break;
+            if (fenceInfo(t))
+                break;
+            if (t[0] === '>')
+                break;
+            if (parseListMarker(l))
+                break;
+            if (leadingSpaces(l) >= 4)
+                break;
+            paraLines.push(t);
+            i++;
+        }
+        blocks.push({ type: 'paragraph', text: paraLines.join(' ') });
+    }
+    return blocks;
+}
+function renderListItem(item) {
+    const blocks = item.blocks;
+    if (blocks.length === 1 && blocks[0].type === 'paragraph') {
+        return `<li>${renderInline(blocks[0].text)}</li>`;
+    }
+    const parts = [];
+    for (let i = 0; i < blocks.length; i++) {
+        const b = blocks[i];
+        if (i === 0 && b.type === 'paragraph') {
+            parts.push(renderInline(b.text));
+        }
+        else {
+            parts.push(renderBlock(b));
+        }
+    }
+    return `<li>${parts.join('\n')}</li>`;
+}
+function renderBlock(b) {
+    if (b.type === 'paragraph') {
+        return `<p>${renderInline(b.text)}</p>`;
+    }
+    if (b.type === 'heading') {
+        return `<h${b.level}>${renderInline(b.text)}</h${b.level}>`;
+    }
+    if (b.type === 'hr') {
+        return '<hr />';
+    }
+    if (b.type === 'code') {
+        const lang = b.lang ? ` class="language-${escapeHtml(b.lang)}"` : '';
+        return `<pre><code${lang}>${escapeHtml(b.code)}</code></pre>`;
+    }
+    if (b.type === 'blockquote') {
+        return `<blockquote>${renderBlocks(b.blocks)}</blockquote>`;
+    }
+    return renderList(b);
+}
+function renderList(b) {
+    const tag = b.ordered ? 'ol' : 'ul';
+    const items = b.items.map(renderListItem).join('\n');
+    return `<${tag}>\n${items}\n</${tag}>`;
+}
+function renderBlocks(blocks) {
+    const out = [];
+    for (const b of blocks) {
+        out.push(renderBlock(b));
+    }
+    return out.join('\n');
+}
+function parseLink(text, start) {
+    let i = start;
+    let isImage = false;
+    if (text[i] === '!' && text[i + 1] === '[') {
+        isImage = true;
+        i++;
+    }
+    if (text[i] !== '[')
+        return null;
+    i++;
+    let depth = 1;
+    let labelEnd = -1;
+    let j = i;
+    while (j < text.length) {
+        if (text[j] === '[')
+            depth++;
+        else if (text[j] === ']') {
+            depth--;
+            if (depth === 0) {
+                labelEnd = j;
+                break;
+            }
+        }
+        j++;
+    }
+    if (labelEnd === -1)
+        return null;
+    const label = text.slice(i, labelEnd);
+    j = labelEnd + 1;
+    if (text[j] !== '(')
+        return null;
+    j++;
+    while (j < text.length && text[j] === ' ')
+        j++;
+    const urlStart = j;
+    depth = 1;
+    let urlEnd = -1;
+    while (j < text.length) {
+        if (text[j] === '(')
+            depth++;
+        else if (text[j] === ')') {
+            depth--;
+            if (depth === 0) {
+                urlEnd = j;
+                break;
+            }
+        }
+        j++;
+    }
+    if (urlEnd === -1)
+        return null;
+    const url = text.slice(urlStart, urlEnd).trim();
+    if (url === '')
+        return null;
+    return { text: label, url, alt: label, image: isImage, end: urlEnd + 1 };
+}
+function findDelimiter(text, from, delim) {
+    return text.indexOf(delim, from);
+}
+function renderInline(text) {
+    let out = '';
+    let i = 0;
+    while (i < text.length) {
+        const ch = text[i];
+        if (ch === '\\' && i + 1 < text.length) {
+            out += escapeHtml(text[i + 1]);
+            i += 2;
+            continue;
+        }
+        if (ch === '`') {
+            let n = 0;
+            while (i + n < text.length && text[i + n] === '`')
+                n++;
+            const delim = '`'.repeat(n);
+            const close = findDelimiter(text, i + n, delim);
+            if (close !== -1) {
+                let code = text.slice(i + n, close);
+                code = code.split('\n').join(' ');
+                out += `<code>${escapeHtml(code)}</code>`;
+                i = close + n;
+                continue;
+            }
+            out += '`';
+            i++;
+            continue;
+        }
+        if (ch === '~' && text[i + 1] === '~') {
+            const close = findDelimiter(text, i + 2, '~~');
+            if (close !== -1 && close > i + 2) {
+                out += `<del>${renderInline(text.slice(i + 2, close))}</del>`;
+                i = close + 2;
+                continue;
+            }
+            out += '~';
+            i++;
+            continue;
+        }
+        if (ch === '*' || ch === '_') {
+            const next = text[i + 1];
+            if (next !== ' ' && next !== '\t' && next !== undefined) {
+                const inner = tryEmphasis(text, i);
+                if (inner) {
+                    out += inner.html;
+                    i = inner.end;
+                    continue;
+                }
+            }
+            out += ch;
+            i++;
+            continue;
+        }
+        if (ch === '[' || (ch === '!' && text[i + 1] === '[')) {
+            const link = parseLink(text, i);
+            if (link) {
+                if (link.image) {
+                    out += `<img src="${escapeHtml(link.url)}" alt="${escapeHtml(link.alt)}" />`;
+                }
+                else {
+                    out += `<a href="${escapeHtml(link.url)}">${renderInline(link.text)}</a>`;
+                }
+                i = link.end;
+                continue;
+            }
+        }
+        out += escapeHtml(ch);
+        i++;
+    }
+    return out;
+}
+function tryEmphasis(text, start) {
+    const ch = text[start];
+    if (text[start + 1] === ch) {
+        let j = start + 2;
+        while (j < text.length) {
+            if (text[j] === ch && text[j + 1] === ch) {
+                if (j > start + 2 && (text[j - 1] === ' ' || text[j - 1] === '\t')) {
+                    j += 2;
+                    continue;
+                }
+                return { html: `<strong>${renderInline(text.slice(start + 2, j))}</strong>`, end: j + 2 };
+            }
+            j++;
+        }
+    }
+    let j = start + 1;
+    while (j < text.length) {
+        if (text[j] === ch) {
+            if (j > start + 1 && (text[j - 1] === ' ' || text[j - 1] === '\t')) {
+                j++;
+                continue;
+            }
+            return { html: `<em>${renderInline(text.slice(start + 1, j))}</em>`, end: j + 1 };
+        }
+        j++;
+    }
+    return null;
+}
+export function renderMarkdown(md) {
+    const lines = String(md == null ? '' : md).split('\n');
+    return renderBlocks(parseBlocks(lines));
+}
+function mdIsSSR() {
+    return typeof document === 'undefined';
+}
+/**
+ * Renders markdown as HTML. On the server it returns an HTML string; on the
+ * client it claims the SSR-rendered subtree during hydration (or builds a
+ * fresh wrapper element for SPA navigation).
+ */
+export function Md(props, _registry, hydrate) {
+    const content = props.content == null ? '' : String(props.content);
+    const html = renderMarkdown(content);
+    const className = props.className != null ? String(props.className) : props.class != null ? String(props.class) : '';
+    const style = props.style != null ? String(props.style) : '';
+    if (mdIsSSR()) {
+        const attrs = className ? ` class="${escapeHtml(className)}"` : '';
+        const styleAttr = style ? ` style="${style.split('"').join('&quot;')}"` : '';
+        return `<div${attrs}${styleAttr}>${html}</div>`;
+    }
+    if (hydrate && typeof hydrate.nextElement === 'function') {
+        let el = hydrate.nextElement('div');
+        if (el && !el.parentNode && hydrate.root) {
+            const existing = hydrate.root.querySelector('div');
+            if (existing)
+                el = existing;
+        }
+        el.innerHTML = html;
+        if (className)
+            el.className = className;
+        if (style)
+            el.style.cssText = style;
+        return document.createDocumentFragment();
+    }
+    const div = document.createElement('div');
+    div.innerHTML = html;
+    if (className)
+        div.className = className;
+    if (style)
+        div.style.cssText = style;
+    return div;
+}

package/dist/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@vesk/runtime",
+  "version": "0.1.9",
+  "type": "module",
+  "main": "./index-client.js",
+  "types": "./index-client.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index-client.d.ts",
+      "default": "./index-client.js"
+    },
+    "./client": {
+      "types": "./index-client.d.ts",
+      "default": "./index-client.js"
+    },
+    "./server": {
+      "types": "./index-server.d.ts",
+      "default": "./index-server.js"
+    },
+    "./src/*": "./*.js",
+    "./package.json": "./package.json"
+  }
+}

package/dist/portal.d.ts

@@ -0,0 +1,8 @@
+interface PortalProps {
+    target: string | HTMLElement;
+    children?: Node | ((frag: DocumentFragment) => void);
+    [k: string]: unknown;
+}
+export declare function Portal(props: PortalProps, _registry?: Map<string, unknown>, _ctx?: unknown): Node | string;
+export {};
+//# sourceMappingURL=portal.d.ts.map

package/dist/portal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal.d.ts","sourceRoot":"","sources":["../src/portal.ts"],"names":[],"mappings":"AAAA,UAAU,WAAW;IACpB,MAAM,EAAE,MAAM,GAAG,WAAW,CAAC;IAC7B,QAAQ,CAAC,EAAE,IAAI,GAAG,CAAC,CAAC,IAAI,EAAE,gBAAgB,KAAK,IAAI,CAAC,CAAC;IACrD,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CACrB;AAED,wBAAgB,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,MAAM,CAgB1G"}

package/dist/portal.js

@@ -0,0 +1,20 @@
+export function Portal(props, _registry, _ctx) {
+    if (typeof document === 'undefined')
+        return '';
+    const target = typeof props.target === 'string'
+        ? document.querySelector(props.target)
+        : props.target;
+    if (!target)
+        return document.createComment('portal: no target');
+    if (props.children != null) {
+        if (typeof props.children === 'function') {
+            const frag = document.createDocumentFragment();
+            props.children(frag);
+            target.appendChild(frag);
+        }
+        else {
+            target.appendChild(props.children);
+        }
+    }
+    return document.createComment('portal');
+}

package/dist/reconcile.d.ts

@@ -0,0 +1,3 @@
+import type { Block } from '@vesk/runtime/src/ripple-runtime';
+export declare function reconcile<T>(anchor: Node, endAnchor: Node, items: T[], keyFn: (item: T) => string, createItem: (item: T, index: number, effs: Block[]) => void): (newItems: T[]) => void;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../src/reconcile.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAO9D,wBAAgB,SAAS,CAAC,CAAC,EAC1B,MAAM,EAAE,IAAI,EACZ,SAAS,EAAE,IAAI,EACf,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC1B,UAAU,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,IAAI,GACzD,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,IAAI,CA8CzB"}

package/dist/reconcile.js

@@ -0,0 +1,66 @@
+import { destroy_block } from '@vesk/runtime/src/ripple-blocks';
+export function reconcile(anchor, endAnchor, items, keyFn, createItem) {
+    const parent = anchor.parentNode;
+    const map = new Map();
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const key = keyFn(item);
+        const marker = document.createComment('k:' + key);
+        const effs = [];
+        parent.insertBefore(marker, endAnchor);
+        createItem(item, i, effs);
+        map.set(key, { marker, effs });
+    }
+    return (newItems) => {
+        const newKeys = newItems.map(keyFn);
+        const newSet = new Set(newKeys);
+        for (const [key, { marker, effs }] of map) {
+            if (!newSet.has(key)) {
+                removeRange(marker, endAnchor);
+                marker.remove();
+                for (const e of effs)
+                    destroy_block(e);
+                map.delete(key);
+            }
+        }
+        let ref = endAnchor;
+        for (let i = newKeys.length - 1; i >= 0; i--) {
+            const key = newKeys[i];
+            let entry = map.get(key);
+            if (entry) {
+                if (entry.marker.nextSibling !== ref) {
+                    moveBefore(entry.marker, endAnchor, ref);
+                }
+                ref = entry.marker;
+            }
+            else {
+                const marker = document.createComment('k:' + key);
+                const effs = [];
+                parent.insertBefore(marker, ref);
+                createItem(newItems[i], i, effs);
+                map.set(key, { marker, effs });
+                ref = marker;
+            }
+        }
+    };
+}
+function removeRange(start, end) {
+    let n = start.nextSibling;
+    while (n && n !== end && !(n.nodeType === 8 && n.nodeValue && n.nodeValue.startsWith('k:'))) {
+        const next = n.nextSibling;
+        n.remove();
+        n = next;
+    }
+}
+function moveBefore(marker, endAnchor, ref) {
+    const nodes = [];
+    let n = marker.nextSibling;
+    while (n && n !== endAnchor && !(n.nodeType === 8 && n.nodeValue && n.nodeValue.startsWith('k:'))) {
+        nodes.push(n);
+        n = n.nextSibling;
+    }
+    const parent = marker.parentNode;
+    parent.insertBefore(marker, ref);
+    for (const node of nodes)
+        parent.insertBefore(node, ref);
+}