@softov/scena 0.1.2

package/dist/core/binding-resolver.js

@@ -0,0 +1,106 @@
+import { isAction, isDataBinding, isFunctionCall, } from '../types/component-graph.js';
+import { combineDisposables, disposableFrom } from './disposable.js';
+import { parsePath } from './path-resolver.js';
+export function createBindingResolver(deps) {
+    const { store } = deps;
+    function compilePath(path) {
+        const parsed = parsePath(path);
+        if (!parsed.absolute) {
+            // Relative paths can't be compiled without a data context; consumers that
+            // need them go through dynamic-resolver.readPath instead. Return a path
+            // form with the literal segments so subscribers at least see the shape.
+            return {
+                kind: 'path',
+                scope: '',
+                segments: parsed.segments,
+                wildcard: parsed.segments.includes('*'),
+                raw: path,
+            };
+        }
+        const scope = (parsed.segments[0] ?? '');
+        return {
+            kind: 'path',
+            scope,
+            segments: parsed.segments,
+            wildcard: parsed.segments.includes('*'),
+            raw: path,
+        };
+    }
+    function compileFunctionCall(fc) {
+        const argBindings = {};
+        for (const [k, v] of Object.entries(fc.args ?? {})) {
+            argBindings[k] = compile(v);
+        }
+        return {
+            kind: 'functionCall',
+            call: fc.call,
+            argBindings,
+            callableFrom: fc.callableFrom,
+            returnType: fc.returnType,
+        };
+    }
+    function compileAction(action) {
+        if ('functionCall' in action) {
+            return compileFunctionCall(action.functionCall);
+        }
+        const ev = action.event;
+        const contextBindings = ev.context
+            ? Object.fromEntries(Object.entries(ev.context).map(([k, v]) => [k, compile(v)]))
+            : undefined;
+        return {
+            kind: 'event',
+            name: ev.name,
+            contextBindings,
+            wantResponse: ev.wantResponse,
+            responsePath: ev.responsePath,
+        };
+    }
+    function compile(prop) {
+        if (prop === null || typeof prop !== 'object') {
+            return { kind: 'literal', value: prop };
+        }
+        if (isDataBinding(prop)) {
+            return compilePath(prop.path);
+        }
+        if (isFunctionCall(prop)) {
+            return compileFunctionCall(prop);
+        }
+        if (isAction(prop)) {
+            return compileAction(prop);
+        }
+        return { kind: 'literal', value: prop };
+    }
+    function resolve(binding) {
+        switch (binding.kind) {
+            case 'literal':
+                return binding.value;
+            case 'path':
+                if (binding.wildcard)
+                    return {};
+                return store.get(binding.raw);
+            case 'functionCall':
+            case 'event':
+                // Handlers; resolved by dynamic-resolver at click time.
+                return binding;
+        }
+    }
+    function watch(binding, fn) {
+        switch (binding.kind) {
+            case 'literal':
+                return disposableFrom(() => { });
+            case 'path':
+                return store.subscribe(binding.raw, fn);
+            case 'functionCall': {
+                const subs = Object.values(binding.argBindings).map((b) => watch(b, () => fn(binding)));
+                return combineDisposables(...subs);
+            }
+            case 'event': {
+                if (!binding.contextBindings)
+                    return disposableFrom(() => { });
+                const subs = Object.values(binding.contextBindings).map((b) => watch(b, () => fn(binding)));
+                return combineDisposables(...subs);
+            }
+        }
+    }
+    return { compile, watch, resolve };
+}

package/dist/core/component-graph.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentNode } from '../types/component-graph.js';
+export declare function walk(node: ComponentNode, visit: (node: ComponentNode, parent: ComponentNode | null) => void): void;
+export declare function clone(node: ComponentNode): ComponentNode;
+export declare function addIds(node: ComponentNode): ComponentNode;
+export declare function findById(node: ComponentNode, id: string): ComponentNode | null;
+export declare function stripMeta(node: ComponentNode): ComponentNode;

package/dist/core/component-graph.js

@@ -0,0 +1,77 @@
+import { isComponentNode } from '../types/component-graph.js';
+// Recursive tree walk. Visits the root, then every nested ComponentNode found
+// anywhere in its prop values (single child, child array, or deeper nesting).
+export function walk(node, visit) {
+    visit(node, null);
+    walkChildren(node);
+    function walkChildren(current) {
+        for (const [k, v] of Object.entries(current)) {
+            if (k === 'id' || k === 'component' || k === '$meta')
+                continue;
+            walkValue(v, current);
+        }
+    }
+    function walkValue(v, parent) {
+        if (v === null || typeof v !== 'object')
+            return;
+        if (isComponentNode(v)) {
+            visit(v, parent);
+            walkChildren(v);
+            return;
+        }
+        if (Array.isArray(v)) {
+            for (const item of v)
+                walkValue(item, parent);
+            return;
+        }
+        // Plain object — recurse into its values (children inside { template } etc).
+        for (const inner of Object.values(v)) {
+            walkValue(inner, parent);
+        }
+    }
+}
+export function clone(node) {
+    return JSON.parse(JSON.stringify(node));
+}
+let idCounter = 0;
+function nextId() {
+    idCounter += 1;
+    return `n_${Date.now().toString(36)}_${idCounter.toString(36)}`;
+}
+export function addIds(node) {
+    const out = clone(node);
+    walk(out, (n) => {
+        if (!n.id)
+            n.id = nextId();
+    });
+    return out;
+}
+export function findById(node, id) {
+    let found = null;
+    walk(node, (n) => {
+        if (found)
+            return;
+        if (n.id === id)
+            found = n;
+    });
+    return found;
+}
+// Deep-clones the node with every `$meta` key removed. Use this before
+// serializing a node back to a sender: `$meta` annotates origin/editor data
+// that the sender never sent and should never receive.
+export function stripMeta(node) {
+    return stripValue(node);
+}
+function stripValue(v) {
+    if (v === null || typeof v !== 'object')
+        return v;
+    if (Array.isArray(v))
+        return v.map(stripValue);
+    const out = {};
+    for (const [k, inner] of Object.entries(v)) {
+        if (k === '$meta')
+            continue;
+        out[k] = stripValue(inner);
+    }
+    return out;
+}

package/dist/core/component-registry.d.ts

@@ -0,0 +1,7 @@
+import type { EventBus } from '../types/events.js';
+import type { ComponentRegistry } from '../types/component-registry.js';
+interface Deps {
+    events: EventBus;
+}
+export declare function createComponentRegistry(deps: Deps): ComponentRegistry;
+export {};

package/dist/core/component-registry.js

@@ -0,0 +1,87 @@
+import { disposableFrom } from './disposable.js';
+export function createComponentRegistry(deps) {
+    const { events } = deps;
+    const defs = new Map();
+    const pendingResolves = new Map();
+    function announce() {
+        events.emit('scena:registry:changed', { registry: 'components' });
+    }
+    return {
+        register(def) {
+            defs.set(def.component, def);
+            const waiters = pendingResolves.get(def.component);
+            if (waiters) {
+                pendingResolves.delete(def.component);
+                const resolved = {
+                    component: def.component,
+                    renderer: def.renderer,
+                    definition: def,
+                };
+                for (const w of waiters)
+                    w(resolved);
+            }
+            announce();
+            return disposableFrom(() => {
+                if (defs.get(def.component) === def) {
+                    defs.delete(def.component);
+                    announce();
+                }
+            });
+        },
+        unregister(component) {
+            if (defs.delete(component))
+                announce();
+        },
+        get(component) {
+            return defs.get(component);
+        },
+        list() {
+            return [...defs.values()];
+        },
+        findOpeners(resourceKind) {
+            const out = [];
+            for (const def of defs.values()) {
+                const opens = def.opens;
+                if (!opens)
+                    continue;
+                const kinds = opens.resourceKinds;
+                if (kinds && !kinds.includes(resourceKind))
+                    continue;
+                out.push(def);
+            }
+            out.sort((a, b) => (b.opens?.priority ?? 0) - (a.opens?.priority ?? 0));
+            return out;
+        },
+        pending() {
+            return [...pendingResolves.keys()];
+        },
+        resolve(component, options) {
+            const def = defs.get(component);
+            if (def) {
+                return Promise.resolve({ component, renderer: def.renderer, definition: def });
+            }
+            return new Promise((resolve, reject) => {
+                let waiters = pendingResolves.get(component);
+                if (!waiters) {
+                    waiters = [];
+                    pendingResolves.set(component, waiters);
+                }
+                waiters.push(resolve);
+                const timeoutMs = options?.timeoutMs;
+                if (typeof timeoutMs === 'number') {
+                    setTimeout(() => {
+                        const list = pendingResolves.get(component);
+                        if (!list)
+                            return;
+                        const idx = list.indexOf(resolve);
+                        if (idx >= 0)
+                            list.splice(idx, 1);
+                        if (list.length === 0)
+                            pendingResolves.delete(component);
+                        reject(new Error(`Component "${component}" not registered within ${timeoutMs}ms`));
+                    }, timeoutMs);
+                }
+            });
+        },
+    };
+}

package/dist/core/computed-dsl.d.ts

@@ -0,0 +1,2 @@
+export type SelectFn = (inputs: Record<string, unknown>) => unknown;
+export declare function compileSelect(select: string): SelectFn;

package/dist/core/computed-dsl.js

@@ -0,0 +1,267 @@
+// Compiles a computed `select` STRING into an evaluator over the computed's
+// `from` inputs. Implements the 00-DECISIONS whitelist — no general eval(), no
+// dependencies. Function `select`s bypass this file entirely.
+//
+// Grammar (one statement):
+//   countWhere(<expr>) | sumBy(<expr>) | filter(<expr>) | map(<expr>)
+//   | length(<expr>)   | <expr>
+//
+//   <expr>: identifiers (with `.` member access), number / string / true /
+//   false / null literals, `! - ` unary, `* /`, `+ -`, `== != < > <= >=`,
+//   `&& ||`, parentheses.
+//
+// Inputs object: { [fromPath]: value }. Collection functions (countWhere /
+// sumBy / filter / map) iterate the first ARRAY input (a wildcard `from`
+// expands to an array upstream); inside their <expr>, bare identifiers resolve
+// against the current item (its own props, plus `item` / `value` = the item).
+// `length` and bare <expr> resolve identifiers against the inputs, aliased by
+// each path's LAST segment and by positional `$0`, `$1`, … (and `value` =
+// first input).
+const COLLECTION_FNS = new Set(['countWhere', 'sumBy', 'filter', 'map']);
+export function compileSelect(select) {
+    const src = select.trim();
+    const fnMatch = /^([A-Za-z_$][\w$]*)\(([\s\S]*)\)$/.exec(src);
+    if (fnMatch && (COLLECTION_FNS.has(fnMatch[1]) || fnMatch[1] === 'length')) {
+        const fn = fnMatch[1];
+        const inner = parse(fnMatch[2]);
+        if (fn === 'length') {
+            return (inputs) => {
+                const v = evalNode(inner, inputsScope(inputs));
+                if (Array.isArray(v) || typeof v === 'string')
+                    return v.length;
+                if (v && typeof v === 'object')
+                    return Object.keys(v).length;
+                return 0;
+            };
+        }
+        return (inputs) => {
+            const coll = pickCollection(inputs);
+            switch (fn) {
+                case 'countWhere':
+                    return coll.reduce((n, item) => (truthy(evalNode(inner, itemScope(item))) ? n + 1 : n), 0);
+                case 'sumBy':
+                    return coll.reduce((s, item) => s + toNum(evalNode(inner, itemScope(item))), 0);
+                case 'filter':
+                    return coll.filter((item) => truthy(evalNode(inner, itemScope(item))));
+                case 'map':
+                    return coll.map((item) => evalNode(inner, itemScope(item)));
+                default:
+                    return undefined;
+            }
+        };
+    }
+    if (fnMatch) {
+        throw new Error(`computed: unknown select function "${fnMatch[1]}(…)"`);
+    }
+    const node = parse(src);
+    return (inputs) => evalNode(node, inputsScope(inputs));
+}
+// ── scopes ──────────────────────────────────────────────────────────────────
+function pickCollection(inputs) {
+    for (const v of Object.values(inputs))
+        if (Array.isArray(v))
+            return v;
+    return [];
+}
+function itemScope(item) {
+    if (item && typeof item === 'object') {
+        return { ...item, item, value: item };
+    }
+    return { item, value: item };
+}
+function lastSegment(path) {
+    const parts = path.split('/');
+    return parts[parts.length - 1] || path;
+}
+function inputsScope(inputs) {
+    const scope = {};
+    let i = 0;
+    for (const [path, value] of Object.entries(inputs)) {
+        scope[lastSegment(path)] = value;
+        scope[`$${i}`] = value;
+        if (i === 0)
+            scope.value = value;
+        i++;
+    }
+    return scope;
+}
+const OPS2 = ['==', '!=', '<=', '>=', '&&', '||'];
+const OPS1 = ['<', '>', '!', '+', '-', '*', '/', '(', ')', '.', ','];
+function tokenize(src) {
+    const out = [];
+    let i = 0;
+    while (i < src.length) {
+        const c = src[i];
+        if (c === ' ' || c === '\t' || c === '\n' || c === '\r') {
+            i++;
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            let j = i + 1;
+            let s = '';
+            while (j < src.length && src[j] !== c) {
+                s += src[j];
+                j++;
+            }
+            if (j >= src.length)
+                throw new Error(`computed: unterminated string in select`);
+            out.push({ t: 'str', v: s });
+            i = j + 1;
+            continue;
+        }
+        if (/[0-9]/.test(c) || (c === '.' && /[0-9]/.test(src[i + 1] ?? ''))) {
+            let j = i;
+            while (j < src.length && /[0-9.]/.test(src[j]))
+                j++;
+            out.push({ t: 'num', v: Number(src.slice(i, j)) });
+            i = j;
+            continue;
+        }
+        if (/[A-Za-z_$]/.test(c)) {
+            let j = i;
+            while (j < src.length && /[\w$]/.test(src[j]))
+                j++;
+            out.push({ t: 'id', v: src.slice(i, j) });
+            i = j;
+            continue;
+        }
+        const two = src.slice(i, i + 2);
+        if (OPS2.includes(two)) {
+            out.push({ t: 'op', v: two });
+            i += 2;
+            continue;
+        }
+        if (OPS1.includes(c)) {
+            out.push({ t: 'op', v: c });
+            i++;
+            continue;
+        }
+        throw new Error(`computed: unexpected character "${c}" in select`);
+    }
+    return out;
+}
+function parse(src) {
+    const toks = tokenize(src);
+    let pos = 0;
+    const peek = () => toks[pos];
+    const eat = (v) => {
+        const t = toks[pos];
+        if (!t)
+            throw new Error(`computed: unexpected end of select`);
+        if (v && !(t.t === 'op' && t.v === v))
+            throw new Error(`computed: expected "${v}"`);
+        pos++;
+        return t;
+    };
+    const isOp = (v) => { const t = peek(); return !!t && t.t === 'op' && t.v === v; };
+    function primary() {
+        const t = peek();
+        if (!t)
+            throw new Error(`computed: unexpected end of select`);
+        if (isOp('!') || isOp('-')) {
+            const op = eat().v;
+            return { k: 'unary', op, arg: primary() };
+        }
+        if (isOp('(')) {
+            eat('(');
+            const e = orExpr();
+            eat(')');
+            return member(e);
+        }
+        if (t.t === 'num') {
+            eat();
+            return { k: 'lit', v: t.v };
+        }
+        if (t.t === 'str') {
+            eat();
+            return { k: 'lit', v: t.v };
+        }
+        if (t.t === 'id') {
+            eat();
+            if (t.v === 'true')
+                return { k: 'lit', v: true };
+            if (t.v === 'false')
+                return { k: 'lit', v: false };
+            if (t.v === 'null')
+                return { k: 'lit', v: null };
+            return member({ k: 'id', v: t.v });
+        }
+        throw new Error(`computed: unexpected token in select`);
+    }
+    function member(base) {
+        let node = base;
+        while (isOp('.')) {
+            eat('.');
+            const id = eat();
+            if (id.t !== 'id')
+                throw new Error(`computed: expected property name after "."`);
+            node = { k: 'member', obj: node, prop: id.v };
+        }
+        return node;
+    }
+    function binLevel(next, ops) {
+        let left = next();
+        while (peek() && peek().t === 'op' && ops.includes(peek().v)) {
+            const op = eat().v;
+            left = { k: 'bin', op, l: left, r: next() };
+        }
+        return left;
+    }
+    const mul = () => binLevel(primary, ['*', '/']);
+    const add = () => binLevel(mul, ['+', '-']);
+    const cmp = () => binLevel(add, ['==', '!=', '<', '>', '<=', '>=']);
+    const and = () => binLevel(cmp, ['&&']);
+    const orExpr = () => binLevel(and, ['||']);
+    const result = orExpr();
+    if (pos !== toks.length)
+        throw new Error(`computed: trailing tokens in select`);
+    return result;
+}
+// ── evaluator ─────────────────────────────────────────────────────────────────
+function evalNode(n, scope) {
+    switch (n.k) {
+        case 'lit':
+            return n.v;
+        case 'id':
+            return scope[n.v];
+        case 'member': {
+            const o = evalNode(n.obj, scope);
+            if (o == null)
+                return undefined;
+            return o[n.prop];
+        }
+        case 'unary': {
+            const v = evalNode(n.arg, scope);
+            return n.op === '!' ? !truthy(v) : -toNum(v);
+        }
+        case 'bin': {
+            const l = evalNode(n.l, scope);
+            if (n.op === '&&')
+                return truthy(l) ? evalNode(n.r, scope) : l;
+            if (n.op === '||')
+                return truthy(l) ? l : evalNode(n.r, scope);
+            const r = evalNode(n.r, scope);
+            switch (n.op) {
+                case '==': return l === r;
+                case '!=': return l !== r;
+                case '<': return l < r;
+                case '>': return l > r;
+                case '<=': return l <= r;
+                case '>=': return l >= r;
+                case '+': return typeof l === 'string' || typeof r === 'string'
+                    ? String(l) + String(r)
+                    : toNum(l) + toNum(r);
+                case '-': return toNum(l) - toNum(r);
+                case '*': return toNum(l) * toNum(r);
+                case '/': return toNum(l) / toNum(r);
+                default: return undefined;
+            }
+        }
+    }
+}
+function truthy(v) {
+    return !!v;
+}
+function toNum(v) {
+    return typeof v === 'number' ? v : Number(v);
+}

package/dist/core/converter-registry.d.ts

@@ -0,0 +1,2 @@
+import type { ConverterRegistry } from '../types/converter-registry.js';
+export declare function createConverterRegistry(): ConverterRegistry;

package/dist/core/converter-registry.js

@@ -0,0 +1,37 @@
+import { disposableFrom } from './disposable.js';
+export function createConverterRegistry() {
+    const converters = new Map();
+    function inputMatches(matcher, input) {
+        if (typeof matcher === 'function')
+            return matcher(input);
+        if (!input || typeof input !== 'object')
+            return false;
+        const value = input[matcher.header];
+        if (matcher.value === undefined)
+            return value !== undefined;
+        return value === matcher.value;
+    }
+    return {
+        register(t) {
+            converters.set(t.id, t);
+            return disposableFrom(() => {
+                if (converters.get(t.id) === t)
+                    converters.delete(t.id);
+            });
+        },
+        unregister(id) {
+            converters.delete(id);
+        },
+        list() {
+            return [...converters.values()];
+        },
+        translate(input) {
+            for (const t of converters.values()) {
+                if (inputMatches(t.accepts, input)) {
+                    return t.translate(input);
+                }
+            }
+            throw new Error('No registered converter accepts this input');
+        },
+    };
+}

package/dist/core/disposable.d.ts

@@ -0,0 +1,3 @@
+import type { Disposable } from '../types/disposable.js';
+export declare function combineDisposables(...disposables: (Disposable | undefined)[]): Disposable;
+export declare function disposableFrom(fn: () => void): Disposable;

package/dist/core/disposable.js

@@ -0,0 +1,19 @@
+export function combineDisposables(...disposables) {
+    return {
+        dispose() {
+            for (const d of disposables) {
+                if (!d)
+                    continue;
+                try {
+                    d.dispose();
+                }
+                catch {
+                    // Swallow individual disposal errors so one failure doesn't strand others.
+                }
+            }
+        },
+    };
+}
+export function disposableFrom(fn) {
+    return { dispose: fn };
+}

package/dist/core/dynamic-resolver.d.ts

@@ -0,0 +1,12 @@
+import type { Action, BindingPath, DataBinding, DynamicBoolean, DynamicNumber, DynamicString, DynamicStringList, DynamicValue, FunctionCall, PropValue } from '../types/component-graph.js';
+import type { Scena } from '../types/scena.js';
+export declare function resolveDynamicValue(value: PropValue, dataContext: BindingPath | undefined, scena: Scena): unknown;
+export declare function resolveFunctionCall(fc: FunctionCall, dataContext: BindingPath | undefined, scena: Scena): unknown;
+export declare function resolveDynamicString(v: DynamicString, dataContext: BindingPath | undefined, scena: Scena): string;
+export declare function resolveDynamicNumber(v: DynamicNumber, dataContext: BindingPath | undefined, scena: Scena): number;
+export declare function resolveDynamicBoolean(v: DynamicBoolean, dataContext: BindingPath | undefined, scena: Scena): boolean;
+export declare function resolveDynamicStringList(v: DynamicStringList, dataContext: BindingPath | undefined, scena: Scena): string[];
+export declare function resolveAction(action: Action, dataContext: BindingPath | undefined, scena: Scena, mountKey: string | null): () => Promise<unknown>;
+export declare function writeDynamic(value: PropValue, dataContext: BindingPath | undefined, scena: Scena, next: unknown): void;
+export declare function isWritableDynamic(v: PropValue): v is DataBinding;
+export type { DynamicValue };