markstream-svelte 0.0.1-beta.1

package/dist/hydrateCustomTagContent.d.ts

@@ -0,0 +1,3 @@
+import type { BaseNode } from 'stream-markdown-parser';
+export declare function hydrateCustomTagContent<T extends BaseNode>(nodes: readonly T[] | null | undefined, source: string, customHtmlTags?: readonly string[]): T[];
+//# sourceMappingURL=hydrateCustomTagContent.d.ts.map

package/dist/hydrateCustomTagContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrateCustomTagContent.d.ts","sourceRoot":"","sources":["../src/hydrateCustomTagContent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAoBtD,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,QAAQ,EACxD,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,IAAI,GAAG,SAAS,EACtC,MAAM,EAAE,MAAM,EACd,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,GACjC,CAAC,EAAE,CA0CL"}

package/dist/hydrateCustomTagContent.js

@@ -0,0 +1,130 @@
+import { normalizeCustomHtmlTags, normalizeCustomHtmlTagName as normalizeTagName } from 'stream-markdown-parser';
+const TAG_TOKEN_RE = /<\/?([A-Z][\w:-]*)(?:\s[^<>]*)?>/gi;
+export function hydrateCustomTagContent(nodes, source, customHtmlTags) {
+    const normalizedTags = normalizeCustomHtmlTags(customHtmlTags);
+    const tagSet = new Set(normalizedTags);
+    if (!source || tagSet.size === 0 || !Array.isArray(nodes) || nodes.length === 0)
+        return Array.isArray(nodes) ? nodes.slice() : [];
+    const segments = collectCustomTagSegments(source, tagSet);
+    if (segments.length === 0)
+        return nodes.slice();
+    let segmentIndex = 0;
+    const cloned = nodes.map(node => cloneNodeTree(node));
+    const visitNode = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        const tag = resolveCustomTagName(node, tagSet);
+        if (tag) {
+            const segment = consumeNextSegment(segments, tag, () => segmentIndex, nextIndex => (segmentIndex = nextIndex));
+            if (segment) {
+                node.tag = tag;
+                node.type = tag;
+                node.content = segment.innerContent;
+                node.raw = segment.raw;
+                if (typeof node.loading !== 'boolean')
+                    node.loading = segment.loading;
+            }
+        }
+        for (const value of Object.values(node)) {
+            if (!Array.isArray(value))
+                continue;
+            for (const child of value)
+                visitNode(child);
+        }
+    };
+    for (const node of cloned)
+        visitNode(node);
+    return cloned;
+}
+function collectCustomTagSegments(source, tagSet) {
+    const stack = [];
+    const segments = [];
+    let match;
+    TAG_TOKEN_RE.lastIndex = 0;
+    while ((match = TAG_TOKEN_RE.exec(source)) !== null) {
+        const raw = match[0];
+        const tag = normalizeTagName(match[1]);
+        if (!tag || !tagSet.has(tag))
+            continue;
+        const isClosing = raw.startsWith('</');
+        if (!isClosing) {
+            stack.push({
+                tag,
+                start: match.index,
+                openEnd: TAG_TOKEN_RE.lastIndex,
+            });
+            continue;
+        }
+        const openIndex = findLastOpenIndex(stack, tag);
+        if (openIndex < 0)
+            continue;
+        const [open] = stack.splice(openIndex, 1);
+        const closeStart = match.index;
+        const closeEnd = TAG_TOKEN_RE.lastIndex;
+        segments.push({
+            tag,
+            start: open.start,
+            end: closeEnd,
+            innerContent: source.slice(open.openEnd, closeStart),
+            raw: source.slice(open.start, closeEnd),
+            loading: false,
+        });
+    }
+    for (const open of stack) {
+        segments.push({
+            tag: open.tag,
+            start: open.start,
+            end: source.length,
+            innerContent: source.slice(open.openEnd),
+            raw: source.slice(open.start),
+            loading: true,
+        });
+    }
+    return segments.sort((left, right) => {
+        if (left.start !== right.start)
+            return left.start - right.start;
+        return right.end - left.end;
+    });
+}
+function findLastOpenIndex(stack, tag) {
+    var _a;
+    for (let index = stack.length - 1; index >= 0; index -= 1) {
+        if (((_a = stack[index]) === null || _a === void 0 ? void 0 : _a.tag) === tag)
+            return index;
+    }
+    return -1;
+}
+function consumeNextSegment(segments, tag, getIndex, setIndex) {
+    let index = getIndex();
+    while (index < segments.length) {
+        const segment = segments[index];
+        index += 1;
+        if (segment.tag !== tag)
+            continue;
+        setIndex(index);
+        return segment;
+    }
+    setIndex(index);
+    return null;
+}
+function resolveCustomTagName(node, tagSet) {
+    const byTag = normalizeTagName(node.tag);
+    if (byTag && tagSet.has(byTag))
+        return byTag;
+    const byType = normalizeTagName(node.type);
+    return byType && tagSet.has(byType) ? byType : '';
+}
+function cloneNodeTree(node) {
+    if (!node || typeof node !== 'object')
+        return node;
+    const cloned = Array.isArray(node)
+        ? node.map(item => cloneNodeTree(item))
+        : { ...node };
+    if (!Array.isArray(cloned)) {
+        for (const [key, value] of Object.entries(cloned)) {
+            if (Array.isArray(value))
+                cloned[key] = value.map(item => cloneNodeTree(item));
+        }
+    }
+    return cloned;
+}

package/dist/i18n/useSafeI18n.d.ts

@@ -0,0 +1,5 @@
+export declare function setDefaultI18nMap(map: Record<string, string>): void;
+export declare function useSafeI18n(): {
+    t(key: string): string;
+};
+//# sourceMappingURL=useSafeI18n.d.ts.map

package/dist/i18n/useSafeI18n.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSafeI18n.d.ts","sourceRoot":"","sources":["../../src/i18n/useSafeI18n.ts"],"names":[],"mappings":"AAiCA,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,QAE5D;AAED,wBAAgB,WAAW;WAEhB,MAAM;EAIhB"}

package/dist/i18n/useSafeI18n.js

@@ -0,0 +1,42 @@
+function humanizeKey(key) {
+    const suffix = key.split('.').pop() || key;
+    return suffix
+        .replace(/[_-]/g, ' ')
+        .replace(/([A-Z])/g, ' $1')
+        .replace(/\s+/g, ' ')
+        .replace(/\b\w/g, char => char.toUpperCase())
+        .trim();
+}
+const defaultMap = {
+    'common.copy': 'Copy',
+    'common.copied': 'Copied',
+    'common.decrease': 'Decrease',
+    'common.reset': 'Reset',
+    'common.increase': 'Increase',
+    'common.expand': 'Expand',
+    'common.collapse': 'Collapse',
+    'common.preview': 'Preview',
+    'common.source': 'Source',
+    'common.export': 'Export',
+    'common.open': 'Open',
+    'common.close': 'Close',
+    'common.zoomIn': 'Zoom in',
+    'common.zoomOut': 'Zoom out',
+    'common.resetZoom': 'Reset zoom',
+    'artifacts.htmlPreviewTitle': 'HTML Preview',
+    'artifacts.svgPreviewTitle': 'SVG Preview',
+    'image.preview': 'Preview image',
+    'image.loadError': 'Image failed to load',
+    'image.loading': 'Loading image...',
+};
+export function setDefaultI18nMap(map) {
+    Object.assign(defaultMap, map);
+}
+export function useSafeI18n() {
+    return {
+        t(key) {
+            var _a;
+            return (_a = defaultMap[key]) !== null && _a !== void 0 ? _a : humanizeKey(key);
+        },
+    };
+}