@softov/scena 0.1.2

package/dist/controls/when.js

@@ -0,0 +1,226 @@
+import { combineDisposables, disposableFrom } from '../core/disposable.js';
+function tokenize(input) {
+    const tokens = [];
+    let i = 0;
+    while (i < input.length) {
+        const ch = input[i];
+        if (ch === ' ' || ch === '\t' || ch === '\n') {
+            i++;
+            continue;
+        }
+        if (ch === '(' || ch === ')') {
+            tokens.push({ kind: 'op', value: ch });
+            i++;
+            continue;
+        }
+        if (ch === '!' && input[i + 1] === '=') {
+            tokens.push({ kind: 'op', value: '!=' });
+            i += 2;
+            continue;
+        }
+        if (ch === '=' && input[i + 1] === '=') {
+            tokens.push({ kind: 'op', value: '==' });
+            i += 2;
+            continue;
+        }
+        if (ch === '&' && input[i + 1] === '&') {
+            tokens.push({ kind: 'op', value: '&&' });
+            i += 2;
+            continue;
+        }
+        if (ch === '|' && input[i + 1] === '|') {
+            tokens.push({ kind: 'op', value: '||' });
+            i += 2;
+            continue;
+        }
+        if (ch === '!') {
+            tokens.push({ kind: 'op', value: '!' });
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            const quote = ch;
+            let j = i + 1;
+            let value = '';
+            while (j < input.length && input[j] !== quote) {
+                if (input[j] === '\\') {
+                    value += input[j + 1] ?? '';
+                    j += 2;
+                }
+                else {
+                    value += input[j];
+                    j++;
+                }
+            }
+            tokens.push({ kind: 'string', value });
+            i = j + 1;
+            continue;
+        }
+        // Number / identifier / path. Path can include `:` and `.`.
+        let j = i;
+        while (j < input.length &&
+            !' \t\n()!=&|"\''.includes(input[j])) {
+            j++;
+        }
+        const word = input.slice(i, j);
+        if (/^-?\d+(\.\d+)?$/.test(word)) {
+            tokens.push({ kind: 'number', value: Number(word) });
+        }
+        else if (word === 'true')
+            tokens.push({ kind: 'bool', value: true });
+        else if (word === 'false')
+            tokens.push({ kind: 'bool', value: false });
+        else if (word === 'null')
+            tokens.push({ kind: 'null' });
+        else
+            tokens.push({ kind: 'path', value: word });
+        i = j;
+    }
+    return tokens;
+}
+function parse(tokens) {
+    let pos = 0;
+    function peek() {
+        return tokens[pos];
+    }
+    function consume() {
+        return tokens[pos++];
+    }
+    function parseExpression() {
+        return parseOr();
+    }
+    function parseOr() {
+        let left = parseAnd();
+        while (peek()?.kind === 'op' && peek().value === '||') {
+            consume();
+            left = { kind: 'or', left, right: parseAnd() };
+        }
+        return left;
+    }
+    function parseAnd() {
+        let left = parseNot();
+        while (peek()?.kind === 'op' && peek().value === '&&') {
+            consume();
+            left = { kind: 'and', left, right: parseNot() };
+        }
+        return left;
+    }
+    function parseNot() {
+        if (peek()?.kind === 'op' && peek().value === '!') {
+            consume();
+            return { kind: 'not', expr: parseNot() };
+        }
+        return parseAtom();
+    }
+    function parseAtom() {
+        const t = consume();
+        if (t.kind === 'op' && t.value === '(') {
+            const inner = parseExpression();
+            const close = consume();
+            if (!(close.kind === 'op' && close.value === ')')) {
+                throw new Error('when DSL: expected ")"');
+            }
+            return inner;
+        }
+        if (t.kind === 'string')
+            return { kind: 'literal', value: t.value };
+        if (t.kind === 'number')
+            return { kind: 'literal', value: t.value };
+        if (t.kind === 'bool')
+            return { kind: 'literal', value: t.value };
+        if (t.kind === 'null')
+            return { kind: 'literal', value: null };
+        if (t.kind === 'path') {
+            const left = { kind: 'path', value: t.value };
+            const next = peek();
+            if (next?.kind === 'op' && (next.value === '==' || next.value === '!=')) {
+                consume();
+                const right = parseAtom();
+                return { kind: next.value === '==' ? 'eq' : 'neq', left, right };
+            }
+            return left;
+        }
+        throw new Error(`when DSL: unexpected token ${JSON.stringify(t)}`);
+    }
+    return parseExpression();
+}
+function compile(input) {
+    return parse(tokenize(input));
+}
+function pathsOf(ast, out) {
+    switch (ast.kind) {
+        case 'literal':
+            return;
+        case 'path':
+            out.add(ast.value);
+            return;
+        case 'eq':
+        case 'neq':
+        case 'and':
+        case 'or':
+            pathsOf(ast.left, out);
+            pathsOf(ast.right, out);
+            return;
+        case 'not':
+            pathsOf(ast.expr, out);
+            return;
+    }
+}
+export function createWhenEngine(deps) {
+    const { store } = deps;
+    const cache = new Map();
+    function astFor(clause) {
+        let ast = cache.get(clause);
+        if (!ast) {
+            ast = compile(clause);
+            cache.set(clause, ast);
+        }
+        return ast;
+    }
+    function evalAst(ast, ctx) {
+        switch (ast.kind) {
+            case 'literal':
+                return ast.value;
+            case 'path':
+                return ctx?.[ast.value] ?? store.get(ast.value);
+            case 'eq':
+                return evalAst(ast.left, ctx) === evalAst(ast.right, ctx);
+            case 'neq':
+                return evalAst(ast.left, ctx) !== evalAst(ast.right, ctx);
+            case 'and':
+                return Boolean(evalAst(ast.left, ctx)) && Boolean(evalAst(ast.right, ctx));
+            case 'or':
+                return Boolean(evalAst(ast.left, ctx)) || Boolean(evalAst(ast.right, ctx));
+            case 'not':
+                return !evalAst(ast.expr, ctx);
+        }
+    }
+    function evaluate(clause, ctx) {
+        if (typeof clause === 'function')
+            return clause(ctx ?? {});
+        return Boolean(evalAst(astFor(clause), ctx));
+    }
+    function dependencies(clause) {
+        if (typeof clause === 'function')
+            return [];
+        const set = new Set();
+        pathsOf(astFor(clause), set);
+        return [...set];
+    }
+    function watch(clause, fn) {
+        let last = evaluate(clause);
+        fn(last);
+        const deps = dependencies(clause);
+        if (deps.length === 0)
+            return disposableFrom(() => { });
+        const subs = deps.map((p) => store.subscribe(p, () => {
+            const next = evaluate(clause);
+            if (next !== last) {
+                last = next;
+                fn(next);
+            }
+        }));
+        return combineDisposables(...subs);
+    }
+    return { evaluate, watch, dependencies };
+}

package/dist/converters/a2ui-v0.10.d.ts

@@ -0,0 +1,23 @@
+import type { Converter } from '../types/converter-registry.js';
+export interface A2uiComponentSpec {
+    id: string;
+    component: string;
+    [k: string]: unknown;
+    properties?: Record<string, unknown>;
+    child?: string;
+    children?: string | string[] | {
+        path: string;
+        componentId: string;
+    } | unknown;
+}
+export interface A2uiCreateSurface {
+    components: Record<string, A2uiComponentSpec>;
+    root: string;
+    dataModel?: Record<string, unknown>;
+}
+export interface A2uiConverterInput {
+    schema: 'a2ui/v0.10';
+    surfaceId: string;
+    payload: A2uiCreateSurface;
+}
+export declare const a2uiV010Converter: Converter;

package/dist/converters/a2ui-v0.10.js

@@ -0,0 +1,136 @@
+export const a2uiV010Converter = {
+    id: 'a2ui-v0.10',
+    accepts: { header: 'schema', value: 'a2ui/v0.10' },
+    translate(input) {
+        const env = input;
+        return translateNode(env.payload.root, env);
+    },
+};
+const RESERVED_TOP_LEVEL = new Set(['id', 'component', 'properties', 'child', 'children']);
+function translateNode(id, env) {
+    const spec = env.payload.components[id];
+    if (!spec) {
+        return {
+            id,
+            component: 'MissingComponent',
+            reason: `a2ui component id "${id}" not found`,
+        };
+    }
+    const node = {
+        id,
+        component: spec.component,
+        $meta: {
+            origin: { format: 'a2ui', version: '0.10', sourceNodeId: id },
+        },
+    };
+    // 1) Spec-first: every top-level key (except the structural ones) is a prop.
+    for (const [k, v] of Object.entries(spec)) {
+        if (RESERVED_TOP_LEVEL.has(k))
+            continue;
+        node[k] = translateValue(v);
+    }
+    // 2) Backward compat: nested `properties` object.
+    if (spec.properties && typeof spec.properties === 'object') {
+        for (const [k, v] of Object.entries(spec.properties)) {
+            node[k] = translateValue(v);
+        }
+    }
+    // 3) Singular child id reference.
+    if (typeof spec.child === 'string') {
+        node.child = translateNode(spec.child, env);
+    }
+    // 4) Children — id list, single id, dynamic { path, componentId }, or inline.
+    if (spec.children !== undefined) {
+        node.children = translateChildren(spec.children, env);
+    }
+    return node;
+}
+function translateChildren(v, env) {
+    if (typeof v === 'string') {
+        // single id — wrap in array
+        return [translateNode(v, env)];
+    }
+    if (Array.isArray(v)) {
+        // string[] = id list (typical); fall back to translateValue for anything else
+        if (v.every((x) => typeof x === 'string')) {
+            return v.map((cid) => translateNode(cid, env));
+        }
+        return v.map(translateValue);
+    }
+    if (v && typeof v === 'object') {
+        const obj = v;
+        if (typeof obj.componentId === 'string' && typeof obj.path === 'string') {
+            // DynamicChildList → runtime form needs `{ template, path }`.
+            const template = translateNode(obj.componentId, env);
+            const list = {
+                template,
+                path: relativePath(obj.path),
+            };
+            return list;
+        }
+        if (obj.template && typeof obj.path === 'string') {
+            return {
+                template: obj.template,
+                path: relativePath(obj.path),
+            };
+        }
+    }
+    return translateValue(v);
+}
+function translateValue(v) {
+    if (v === null || typeof v !== 'object')
+        return v;
+    const obj = v;
+    // Old wrapper form: { dataBinding: { path: '...' } }
+    if ('dataBinding' in obj) {
+        const binding = obj.dataBinding;
+        return { path: relativePath(binding.path) };
+    }
+    // Spec-first DataBinding: { path: '<str>' } directly, often relative ('title').
+    // We normalize bare segments to '/title'. Excluded shapes (component/template/
+    // componentId) are handled higher up — here we just guard against false hits.
+    if (typeof obj.path === 'string' &&
+        !('component' in obj) &&
+        !('template' in obj) &&
+        !('componentId' in obj) &&
+        !('call' in obj) &&
+        !('event' in obj) &&
+        !('functionCall' in obj)) {
+        return { path: relativePath(obj.path) };
+    }
+    if ('action' in obj) {
+        const action = obj.action;
+        if (action.type === 'event') {
+            return {
+                event: {
+                    name: action.name,
+                    context: action.context,
+                },
+            };
+        }
+        if (action.type === 'functionCall') {
+            return {
+                functionCall: {
+                    call: action.name,
+                    args: action.args,
+                    callableFrom: action.callableFrom === 'clientOnly' ? 'clientOnly' : undefined,
+                },
+            };
+        }
+    }
+    if (Array.isArray(v)) {
+        return v.map(translateValue);
+    }
+    const out = {};
+    for (const [k, inner] of Object.entries(obj)) {
+        out[k] = translateValue(inner);
+    }
+    return out;
+}
+// Paths like `flightNumber` or `users.0.name` → `/flightNumber` / `/users/0/name`.
+// Absolute (`$/`) and relative (`/`) paths pass through unchanged.
+function relativePath(p) {
+    if (p.startsWith('$/') || p.startsWith('/'))
+        return p;
+    return '/' + p.replace(/\./g, '/');
+}

package/dist/converters/index.d.ts

@@ -0,0 +1 @@
+export { a2uiV010Converter, type A2uiCreateSurface, type A2uiComponentSpec, type A2uiConverterInput, } from './a2ui-v0.10.js';

package/dist/converters/index.js

@@ -0,0 +1 @@
+export { a2uiV010Converter, } from './a2ui-v0.10.js';

package/dist/core/backends/modus-backend.d.ts

@@ -0,0 +1,13 @@
+import type { ScopeBackend } from '../../types/scope-backend.js';
+export type ModusClass = 'xsmall' | 'small' | 'medium' | 'large';
+export interface ModusBreakpoints {
+    small: number;
+    medium: number;
+    large: number;
+}
+export declare const DEFAULT_MODUS_BREAKPOINTS: ModusBreakpoints;
+export interface ModusBackendOptions {
+    scope?: string;
+    breakpoints?: Partial<ModusBreakpoints>;
+}
+export declare function createModusBackend(opts?: ModusBackendOptions): ScopeBackend;

package/dist/core/backends/modus-backend.js

@@ -0,0 +1,115 @@
+export const DEFAULT_MODUS_BREAKPOINTS = {
+    small: 640,
+    medium: 1024,
+    large: 1440,
+};
+const KEYS = [
+    'class',
+    'width',
+    'height',
+    'compact',
+    'large',
+    'portrait',
+    'coarse',
+];
+function classify(width, bp) {
+    if (width >= bp.large)
+        return 'large';
+    if (width >= bp.medium)
+        return 'medium';
+    if (width >= bp.small)
+        return 'small';
+    return 'xsmall';
+}
+// Used when there is no DOM (SSR, node test runners). A fixed desktop-ish
+// reading is the honest default: it renders the full shell, which degrades
+// visibly rather than silently hiding surfaces on a server render.
+function staticSnapshot(bp) {
+    const width = bp.medium;
+    return {
+        class: classify(width, bp),
+        width,
+        height: 768,
+        compact: false,
+        large: false,
+        portrait: false,
+        coarse: false,
+    };
+}
+function readSnapshot(bp) {
+    const width = window.innerWidth;
+    const height = window.innerHeight;
+    const cls = classify(width, bp);
+    return {
+        class: cls,
+        width,
+        height,
+        compact: cls === 'xsmall' || cls === 'small',
+        large: cls === 'large',
+        portrait: height > width,
+        coarse: window.matchMedia('(pointer: coarse)').matches,
+    };
+}
+export function createModusBackend(opts = {}) {
+    const scope = opts.scope ?? 'modus';
+    const bp = { ...DEFAULT_MODUS_BREAKPOINTS, ...opts.breakpoints };
+    const hasDom = typeof window !== 'undefined' && typeof window.matchMedia === 'function';
+    let snapshot = hasDom ? readSnapshot(bp) : staticSnapshot(bp);
+    // Only keys that have actually been read are re-emitted, so a shell that
+    // binds `class` alone stays quiet through a resize that changes `width`
+    // every frame.
+    const accessed = new Set();
+    return {
+        get(segments) {
+            if (segments.length !== 1)
+                return { hasValue: false, value: undefined };
+            const key = segments[0];
+            if (!KEYS.includes(key)) {
+                return { hasValue: false, value: undefined };
+            }
+            accessed.add(key);
+            return { hasValue: true, value: snapshot[key] };
+        },
+        set() {
+            /* derived from the environment; not writable through the store */
+        },
+        delete() { },
+        clear() { },
+        attach(emit) {
+            if (!hasDom)
+                return { dispose: () => { } };
+            let frame = null;
+            function recompute() {
+                const next = readSnapshot(bp);
+                const prev = snapshot;
+                snapshot = next;
+                for (const key of accessed) {
+                    if (prev[key] !== next[key]) {
+                        emit(`$/${scope}/${key}`, next[key]);
+                    }
+                }
+            }
+            // resize fires per frame during a drag; coalesce so subscribers see at
+            // most one notification per frame, and none at all when nothing changed.
+            function onResize() {
+                if (frame !== null)
+                    return;
+                frame = requestAnimationFrame(() => {
+                    frame = null;
+                    recompute();
+                });
+            }
+            const pointer = window.matchMedia('(pointer: coarse)');
+            window.addEventListener('resize', onResize);
+            pointer.addEventListener('change', recompute);
+            return {
+                dispose() {
+                    if (frame !== null)
+                        cancelAnimationFrame(frame);
+                    window.removeEventListener('resize', onResize);
+                    pointer.removeEventListener('change', recompute);
+                },
+            };
+        },
+    };
+}

package/dist/core/backends/storage-backend.d.ts

@@ -0,0 +1,7 @@
+import type { ScopeBackend } from '../../types/scope-backend.js';
+export interface BackendStorage {
+    load(): Record<string, unknown> | null;
+    save(data: Record<string, unknown>): void;
+}
+export declare function createLocalStorageStorage(key: string): BackendStorage;
+export declare function createStorageBackend(scope: string, storage: BackendStorage): ScopeBackend;

package/dist/core/backends/storage-backend.js

@@ -0,0 +1,73 @@
+// localStorage-backed adapter (browser / dev). No-op outside a window.
+export function createLocalStorageStorage(key) {
+    return {
+        load() {
+            if (typeof window === 'undefined')
+                return null;
+            const raw = window.localStorage.getItem(key);
+            if (!raw)
+                return null;
+            try {
+                return JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+        },
+        save(data) {
+            if (typeof window === 'undefined')
+                return;
+            window.localStorage.setItem(key, JSON.stringify(data));
+        },
+    };
+}
+// A ScopeBackend that persists its scope's values through a BackendStorage.
+// Values live in an in-memory snapshot keyed by the segment-joined sub-path;
+// writes are coalesced to one save per microtask. attach() hydrates from
+// storage and emits each loaded path so live subscribers refresh.
+export function createStorageBackend(scope, storage) {
+    const data = {};
+    let saveScheduled = false;
+    const key = (segs) => segs.join('/');
+    const abs = (subKey) => `$/${scope}/${subKey}`;
+    function scheduleSave() {
+        if (saveScheduled)
+            return;
+        saveScheduled = true;
+        queueMicrotask(() => {
+            saveScheduled = false;
+            storage.save({ ...data });
+        });
+    }
+    return {
+        get(segs) {
+            const k = key(segs);
+            return Object.prototype.hasOwnProperty.call(data, k)
+                ? { hasValue: true, value: data[k] }
+                : { hasValue: false, value: undefined };
+        },
+        set(segs, value) {
+            data[key(segs)] = value;
+            scheduleSave();
+        },
+        delete(segs) {
+            delete data[key(segs)];
+            scheduleSave();
+        },
+        clear() {
+            for (const k of Object.keys(data))
+                delete data[k];
+            scheduleSave();
+        },
+        attach(emit) {
+            const loaded = storage.load();
+            if (loaded) {
+                for (const [k, v] of Object.entries(loaded)) {
+                    data[k] = v;
+                    emit(abs(k), v);
+                }
+            }
+            return { dispose() { } };
+        },
+    };
+}

package/dist/core/backends/yjs-backend.d.ts

@@ -0,0 +1,3 @@
+import type * as Y from 'yjs';
+import type { ScopeBackend } from '../../types/scope-backend.js';
+export declare function createYjsBackend(scope: string, doc: Y.Doc, mapName?: string): ScopeBackend;

package/dist/core/backends/yjs-backend.js

@@ -0,0 +1,44 @@
+// ScopeBackend backed by a Yjs Y.Map (flat sub-path key -> value). Stores that
+// share a Y.Doc (or synced docs) converge; external Yjs updates push through
+// attach()'s observer into the store's notification layer. Intended for $/page
+// (Tela collaboration) and node tests.
+//
+// `yjs` is imported TYPE-ONLY here, so the scena core carries no runtime
+// dependency on it — only callers that actually construct a backend (passing a
+// Y.Doc) need `yjs` installed.
+export function createYjsBackend(scope, doc, mapName = 'scena') {
+    const map = doc.getMap(mapName);
+    const key = (segs) => segs.join('/');
+    const abs = (k) => `$/${scope}/${k}`;
+    return {
+        get(segs) {
+            const k = key(segs);
+            return map.has(k)
+                ? { hasValue: true, value: map.get(k) }
+                : { hasValue: false, value: undefined };
+        },
+        set(segs, value) {
+            map.set(key(segs), value);
+        },
+        delete(segs) {
+            map.delete(key(segs));
+        },
+        clear() {
+            map.clear();
+        },
+        attach(emit) {
+            const observer = (event) => {
+                event.changes.keys.forEach((_change, k) => {
+                    emit(abs(k), map.has(k) ? map.get(k) : undefined);
+                });
+            };
+            map.observe(observer);
+            const disposable = {
+                dispose() {
+                    map.unobserve(observer);
+                },
+            };
+            return disposable;
+        },
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { BindingResolver } from '../types/binding-resolver.js';
+import type { ReactiveStore } from '../types/reactive-store.js';
+interface Deps {
+    store: ReactiveStore;
+}
+export declare function createBindingResolver(deps: Deps): BindingResolver;
+export {};