@r2digisolutions/components 0.1.7 → 0.2.0

package/dist/utils/blogDocument.js

@@ -0,0 +1,220 @@
+/**
+ * Blog document model: parse/serialize + optional component registry.
+ */
+const registry = new Map();
+function uid(prefix = 'b') {
+    return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+}
+export function emptyBlogDocument(title = '') {
+    return { version: 1, title, blocks: [] };
+}
+export function defaultDataForType(type) {
+    switch (type) {
+        case 'heading':
+            return { level: 2, text: 'Heading', align: 'left' };
+        case 'paragraph':
+            return { text: '', align: 'left', lead: false, muted: false };
+        case 'image':
+            return {
+                src: '',
+                alt: '',
+                caption: '',
+                align: 'center',
+                width: 'content',
+                rounded: true,
+                shadow: false
+            };
+        case 'code':
+            return {
+                code: '',
+                language: 'typescript',
+                filename: '',
+                showLineNumbers: false,
+                highlightLines: ''
+            };
+        case 'callout':
+            return { tone: 'info', title: '', text: '', collapsible: false };
+        case 'quote':
+            return { text: '', cite: '', role: '', align: 'left' };
+        case 'list':
+            return { ordered: false, items: [''], tight: false, start: 1 };
+        case 'divider':
+            return { style: 'solid', label: '', spacing: 'md' };
+        case 'markdown':
+            return { source: '' };
+        case 'video':
+            return {
+                src: '',
+                poster: '',
+                caption: '',
+                controls: true,
+                autoplay: false,
+                loop: false,
+                muted: false,
+                align: 'center',
+                width: 'content'
+            };
+        case 'embed':
+            return { url: '', title: '', aspectRatio: '16:9', caption: '' };
+        case 'gallery':
+            return {
+                images: [{ src: '', alt: '' }],
+                columns: 3,
+                gap: 'md',
+                rounded: true
+            };
+        case 'table':
+            return {
+                headers: ['Column A', 'Column B'],
+                rows: [
+                    ['', ''],
+                    ['', '']
+                ],
+                striped: true,
+                compact: false,
+                caption: ''
+            };
+        case 'cta':
+            return {
+                label: 'Get started',
+                href: '#',
+                variant: 'primary',
+                align: 'center',
+                subtitle: '',
+                openInNewTab: false
+            };
+        case 'spacer':
+            return { size: 'md' };
+        case 'html':
+            return { html: '' };
+        case 'component':
+            return { componentId: '', props: {} };
+        default:
+            return {};
+    }
+}
+export function createBlock(type, data) {
+    return {
+        id: uid(),
+        type,
+        data: { ...defaultDataForType(type), ...data }
+    };
+}
+export function createComponentBlock(componentId, props) {
+    const reg = registry.get(componentId);
+    return createBlock('component', {
+        componentId,
+        props: { ...(reg?.defaultProps ?? {}), ...(props ?? {}) }
+    });
+}
+export function serializeBlogDocument(doc) {
+    return JSON.stringify(doc, null, 2);
+}
+export function parseBlogDocument(raw) {
+    if (typeof raw !== 'string') {
+        return normalizeDocument(raw);
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return normalizeDocument(parsed);
+    }
+    catch {
+        return emptyBlogDocument();
+    }
+}
+function normalizeDocument(input) {
+    if (!input || typeof input !== 'object')
+        return emptyBlogDocument();
+    const obj = input;
+    const blocks = Array.isArray(obj.blocks)
+        ? obj.blocks
+            .filter((b) => !!b && typeof b === 'object' && 'type' in b && 'id' in b)
+            .map((b) => ({
+            id: String(b.id),
+            type: b.type,
+            data: {
+                ...defaultDataForType(b.type),
+                ...(b.data ?? {})
+            }
+        }))
+        : [];
+    const tags = Array.isArray(obj.tags)
+        ? obj.tags.filter((t) => typeof t === 'string')
+        : undefined;
+    return {
+        version: 1,
+        title: typeof obj.title === 'string' ? obj.title : '',
+        description: typeof obj.description === 'string' ? obj.description : undefined,
+        coverImage: typeof obj.coverImage === 'string' ? obj.coverImage : undefined,
+        author: typeof obj.author === 'string' ? obj.author : undefined,
+        tags,
+        publishedAt: typeof obj.publishedAt === 'string' ? obj.publishedAt : undefined,
+        blocks
+    };
+}
+export function registerBlogComponent(id, registration) {
+    registry.set(id, registration);
+}
+export function unregisterBlogComponent(id) {
+    registry.delete(id);
+}
+export function getBlogComponent(id) {
+    return registry.get(id);
+}
+export function listBlogComponents() {
+    return [...registry.entries()].map(([id, registration]) => ({ id, registration }));
+}
+export function clearBlogComponentRegistry() {
+    registry.clear();
+}
+export function blogWidthClass(width) {
+    switch (width) {
+        case 'full':
+            return 'w-full max-w-none';
+        case 'wide':
+            return 'w-full max-w-4xl mx-auto';
+        case 'narrow':
+            return 'w-full max-w-md mx-auto';
+        case 'content':
+        default:
+            return 'w-full max-w-3xl mx-auto';
+    }
+}
+export function blogAlignClass(align) {
+    if (align === 'center')
+        return 'text-center mx-auto';
+    if (align === 'right')
+        return 'text-right ml-auto';
+    return 'text-left';
+}
+export function blogAspectPadding(ratio) {
+    switch (ratio) {
+        case '4:3':
+            return '75%';
+        case '1:1':
+            return '100%';
+        case '9:16':
+            return '177.78%';
+        case '16:9':
+        default:
+            return '56.25%';
+    }
+}
+export const NATIVE_BLOCK_TYPES = [
+    { type: 'heading', label: 'Heading', group: 'Text' },
+    { type: 'paragraph', label: 'Paragraph', group: 'Text' },
+    { type: 'quote', label: 'Quote', group: 'Text' },
+    { type: 'list', label: 'List', group: 'Text' },
+    { type: 'markdown', label: 'Markdown', group: 'Text' },
+    { type: 'callout', label: 'Callout', group: 'Text' },
+    { type: 'code', label: 'Code', group: 'Media' },
+    { type: 'image', label: 'Image', group: 'Media' },
+    { type: 'video', label: 'Video', group: 'Media' },
+    { type: 'gallery', label: 'Gallery', group: 'Media' },
+    { type: 'embed', label: 'Embed', group: 'Media' },
+    { type: 'table', label: 'Table', group: 'Layout' },
+    { type: 'cta', label: 'Button / CTA', group: 'Layout' },
+    { type: 'divider', label: 'Divider', group: 'Layout' },
+    { type: 'spacer', label: 'Spacer', group: 'Layout' },
+    { type: 'html', label: 'HTML', group: 'Advanced' }
+];

package/dist/utils/blueprintRuntime.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Lightweight Blueprint graph simulator — follows exec wires, resolves data pins
+ * (literals + pure nodes), and emits Print String lines. Not a full UE VM.
+ */
+import { type BlueprintDocument, type BlueprintVariable } from './nodeGraph.js';
+export type BlueprintLogLevel = 'system' | 'print' | 'warn' | 'error';
+export interface BlueprintLogEntry {
+    id: string;
+    level: BlueprintLogLevel;
+    text: string;
+    nodeId?: string;
+    at: number;
+}
+export interface SimulateBlueprintOptions {
+    /** Entry node type (default: event_begin). */
+    entryType?: string;
+    signal?: AbortSignal;
+    onLog?: (entry: BlueprintLogEntry) => void;
+    /** Multiplier for Delay durations (1 = real seconds). */
+    timeScale?: number;
+    /** Cap Delay wait in ms (default 10_000). */
+    maxDelayMs?: number;
+}
+export interface SimulateBlueprintResult {
+    logs: BlueprintLogEntry[];
+    /** Final variable values after Sets. */
+    variables: BlueprintVariable[];
+    aborted: boolean;
+}
+/**
+ * Run the graph from Event BeginPlay (or `entryType`).
+ * Print String lines use level `print`; flow uses `system`.
+ */
+export declare function simulateBlueprint(doc: BlueprintDocument, opts?: SimulateBlueprintOptions): Promise<SimulateBlueprintResult>;

package/dist/utils/blueprintRuntime.js

@@ -0,0 +1,289 @@
+/**
+ * Lightweight Blueprint graph simulator — follows exec wires, resolves data pins
+ * (literals + pure nodes), and emits Print String lines. Not a full UE VM.
+ */
+import { defaultValueForPinType, isExecPort } from './nodeGraph.js';
+function logId() {
+    return `log-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+}
+function pushLog(logs, onLog, level, text, nodeId) {
+    const entry = { id: logId(), level, text, nodeId, at: Date.now() };
+    logs.push(entry);
+    onLog?.(entry);
+    return entry;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted) {
+        const err = new Error('aborted');
+        err.name = 'AbortError';
+        throw err;
+    }
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+            return;
+        }
+        const t = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(t);
+            reject(Object.assign(new Error('aborted'), { name: 'AbortError' }));
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function findPort(node, handle, side) {
+    const list = side === 'input' ? (node.inputs ?? []) : (node.outputs ?? []);
+    if (!handle)
+        return list[0];
+    return list.find((p) => p.id === handle);
+}
+function outgoing(edges, nodeId, sourceHandle) {
+    return edges.find((e) => e.source === nodeId &&
+        (sourceHandle == null || e.sourceHandle === sourceHandle || (!e.sourceHandle && !sourceHandle)));
+}
+function incomingDataEdge(edges, nodeId, targetHandle) {
+    return edges.find((e) => e.target === nodeId && e.targetHandle === targetHandle);
+}
+function stripLiteralQuotes(raw) {
+    const t = raw.trim();
+    if ((t.startsWith('"') && t.endsWith('"')) ||
+        (t.startsWith("'") && t.endsWith("'"))) {
+        return t.slice(1, -1);
+    }
+    return t;
+}
+function coerceBool(v) {
+    if (typeof v === 'boolean')
+        return v;
+    if (typeof v === 'number')
+        return v !== 0;
+    if (typeof v === 'string') {
+        const s = v.trim().toLowerCase();
+        if (s === 'true' || s === '1' || s === 'yes')
+            return true;
+        if (s === 'false' || s === '0' || s === 'no' || s === '')
+            return false;
+        return Boolean(s);
+    }
+    return Boolean(v);
+}
+function coerceNumber(v, fallback = 0) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string') {
+        const n = parseFloat(v);
+        return Number.isFinite(n) ? n : fallback;
+    }
+    return fallback;
+}
+function coerceString(v) {
+    if (v == null)
+        return '';
+    return String(v);
+}
+function initVars(variables) {
+    const map = new Map();
+    for (const v of variables ?? []) {
+        map.set(v.id, v.defaultValue !== undefined ? v.defaultValue : defaultValueForPinType(v.dataType));
+    }
+    return map;
+}
+function varsToArray(variables, state) {
+    return (variables ?? []).map((v) => ({
+        ...v,
+        defaultValue: state.has(v.id) ? state.get(v.id) : v.defaultValue
+    }));
+}
+/**
+ * Resolve a data output of a (usually pure) node.
+ */
+function evaluateNodeOutput(doc, node, outputId, vars, stack) {
+    if (stack.has(node.id))
+        return undefined;
+    stack.add(node.id);
+    try {
+        switch (node.type) {
+            case 'var_get': {
+                const vid = String(node.data?.variableId ?? '');
+                return vars.has(vid) ? vars.get(vid) : undefined;
+            }
+            case 'make_string': {
+                const label = String(node.data?.label ?? '');
+                return stripLiteralQuotes(label);
+            }
+            case 'var_set': {
+                const vid = String(node.data?.variableId ?? '');
+                return vars.has(vid) ? vars.get(vid) : undefined;
+            }
+            case 'event_tick': {
+                if (outputId === 'delta')
+                    return 0.016;
+                return undefined;
+            }
+            default: {
+                const out = findPort(node, outputId, 'output');
+                if (out && !isExecPort(out) && out.value !== undefined)
+                    return out.value;
+                return undefined;
+            }
+        }
+    }
+    finally {
+        stack.delete(node.id);
+    }
+}
+function resolveInputValue(doc, node, port, vars, stack) {
+    const edge = incomingDataEdge(doc.edges, node.id, port.id);
+    if (edge) {
+        const src = doc.nodes.find((n) => n.id === edge.source);
+        if (!src)
+            return port.value ?? defaultForPort(port);
+        return evaluateNodeOutput(doc, src, edge.sourceHandle, vars, stack);
+    }
+    if (port.value !== undefined)
+        return port.value;
+    return defaultForPort(port);
+}
+function defaultForPort(port) {
+    const dt = (port.dataType ?? 'any');
+    return defaultValueForPinType(dt);
+}
+async function followExec(doc, fromNodeId, fromHandle, ctx) {
+    throwIfAborted(ctx.signal);
+    const edge = outgoing(doc.edges, fromNodeId, fromHandle);
+    if (!edge)
+        return;
+    const node = doc.nodes.find((n) => n.id === edge.target);
+    if (!node)
+        return;
+    await executeNode(doc, node, ctx);
+}
+async function executeNode(doc, node, ctx) {
+    throwIfAborted(ctx.signal);
+    const stack = new Set();
+    const label = String(node.data?.label ?? node.type);
+    switch (node.type) {
+        case 'event_begin':
+        case 'event_tick':
+        case 'trigger': {
+            pushLog(ctx.logs, ctx.onLog, 'system', `→ ${label}`, node.id);
+            await followExec(doc, node.id, 'exec', ctx);
+            return;
+        }
+        case 'branch': {
+            const condPort = findPort(node, 'condition', 'input');
+            const cond = condPort
+                ? coerceBool(resolveInputValue(doc, node, condPort, ctx.vars, stack))
+                : false;
+            pushLog(ctx.logs, ctx.onLog, 'system', `Branch → ${cond ? 'True' : 'False'}`, node.id);
+            await followExec(doc, node.id, cond ? 'true' : 'false', ctx);
+            return;
+        }
+        case 'print_string': {
+            const strPort = findPort(node, 'in_string', 'input');
+            const durPort = findPort(node, 'duration', 'input');
+            const text = strPort
+                ? coerceString(resolveInputValue(doc, node, strPort, ctx.vars, stack))
+                : '';
+            const duration = durPort
+                ? coerceNumber(resolveInputValue(doc, node, durPort, ctx.vars, stack), 2)
+                : 2;
+            pushLog(ctx.logs, ctx.onLog, 'print', text.length ? text : '(empty string)', node.id);
+            if (duration > 0) {
+                pushLog(ctx.logs, ctx.onLog, 'system', `Print duration ${duration}s (display only)`, node.id);
+            }
+            await followExec(doc, node.id, 'exec', ctx);
+            return;
+        }
+        case 'delay_bp':
+        case 'delay': {
+            const durPort = findPort(node, 'duration', 'input');
+            const seconds = durPort
+                ? coerceNumber(resolveInputValue(doc, node, durPort, ctx.vars, stack), 0)
+                : 0;
+            const ms = Math.min(ctx.maxDelayMs, Math.max(0, seconds * 1000 * ctx.timeScale));
+            pushLog(ctx.logs, ctx.onLog, 'system', `Delay ${seconds}s…`, node.id);
+            await sleep(ms, ctx.signal);
+            throwIfAborted(ctx.signal);
+            pushLog(ctx.logs, ctx.onLog, 'system', 'Delay completed', node.id);
+            await followExec(doc, node.id, 'completed', ctx);
+            return;
+        }
+        case 'var_set': {
+            const vid = String(node.data?.variableId ?? '');
+            const valuePort = findPort(node, 'value', 'input');
+            const next = valuePort
+                ? resolveInputValue(doc, node, valuePort, ctx.vars, stack)
+                : undefined;
+            if (vid)
+                ctx.vars.set(vid, next);
+            const name = String(node.data?.variableName ?? vid);
+            pushLog(ctx.logs, ctx.onLog, 'system', `Set ${name} = ${String(next)}`, node.id);
+            await followExec(doc, node.id, 'exec', ctx);
+            return;
+        }
+        case 'return_node': {
+            pushLog(ctx.logs, ctx.onLog, 'system', 'Return', node.id);
+            return;
+        }
+        case 'action':
+        case 'construction_add': {
+            pushLog(ctx.logs, ctx.onLog, 'system', `Run ${label}`, node.id);
+            await followExec(doc, node.id, 'exec', ctx);
+            return;
+        }
+        default: {
+            // Generic: if it has an exec out named exec / Then, follow it.
+            const execOut = (node.outputs ?? []).find((p) => isExecPort(p) && p.id === 'exec') ??
+                (node.outputs ?? []).find((p) => isExecPort(p));
+            pushLog(ctx.logs, ctx.onLog, 'warn', `Unhandled node type "${node.type}"`, node.id);
+            if (execOut)
+                await followExec(doc, node.id, execOut.id, ctx);
+        }
+    }
+}
+/**
+ * Run the graph from Event BeginPlay (or `entryType`).
+ * Print String lines use level `print`; flow uses `system`.
+ */
+export async function simulateBlueprint(doc, opts = {}) {
+    const logs = [];
+    const vars = initVars(doc.variables);
+    const entryType = opts.entryType ?? 'event_begin';
+    const timeScale = opts.timeScale ?? 1;
+    const maxDelayMs = opts.maxDelayMs ?? 10_000;
+    const entry = doc.graph.nodes.find((n) => n.type === entryType);
+    if (!entry) {
+        pushLog(logs, opts.onLog, 'error', `No entry node of type "${entryType}"`);
+        return { logs, variables: varsToArray(doc.variables, vars), aborted: false };
+    }
+    pushLog(logs, opts.onLog, 'system', '—— Simulate BeginPlay ——');
+    try {
+        await executeNode(doc.graph, entry, {
+            vars,
+            logs,
+            onLog: opts.onLog,
+            signal: opts.signal,
+            timeScale,
+            maxDelayMs,
+            variables: doc.variables
+        });
+        pushLog(logs, opts.onLog, 'system', '—— Finished ——');
+        return { logs, variables: varsToArray(doc.variables, vars), aborted: false };
+    }
+    catch (e) {
+        const aborted = e instanceof Error && e.name === 'AbortError';
+        if (aborted) {
+            pushLog(logs, opts.onLog, 'warn', '—— Stopped ——');
+        }
+        else {
+            pushLog(logs, opts.onLog, 'error', e instanceof Error ? e.message : 'Simulation failed');
+        }
+        return { logs, variables: varsToArray(doc.variables, vars), aborted };
+    }
+}