@textui/core 0.1.0

package/dist/core/store.js

@@ -0,0 +1,593 @@
+import { toDisposable } from '../util/disposable.js';
+import { ancestorKeys, hasWildcard, isDescendantKey, matchKey, pathKey, PathError, } from '../util/paths.js';
+/**
+ * The store is one tree, and it is the only place state lives. A component
+ * that keeps a copy in its own state has created a second answer to a question
+ * the store already answers.
+ */
+export class Store {
+    root = {};
+    subs = new Set();
+    computedByKey = new Map();
+    computedDeps = new Map();
+    providers = new Map();
+    schemas = new Map();
+    persistence = new Set();
+    persistTimers = new Map();
+    batchDepth = 0;
+    pending = new Map();
+    disposed = false;
+    /** Thrown-away errors from listeners would hide bugs; collect and report. */
+    onError = (err, context) => {
+        console.error(`[textui/store] ${context}`, err);
+    };
+    // ---------------------------------------------------------------- reading
+    get(path) {
+        const key = pathKey(path);
+        this.touchProvider(key);
+        return this.readKey(key);
+    }
+    read(path, fallback) {
+        const v = this.get(path);
+        return v === undefined ? fallback : v;
+    }
+    has(path) {
+        return this.readKey(pathKey(path)) !== undefined;
+    }
+    readKey(key) {
+        if (key === '')
+            return this.root;
+        const segs = key.split('/');
+        let node = this.root;
+        for (const seg of segs) {
+            if (node === null || node === undefined)
+                return undefined;
+            if (Array.isArray(node)) {
+                const i = Number(seg);
+                if (!Number.isInteger(i))
+                    return undefined;
+                node = node[i];
+                continue;
+            }
+            if (typeof node !== 'object')
+                return undefined;
+            node = node[seg];
+        }
+        return node;
+    }
+    // ---------------------------------------------------------------- writing
+    set(path, value) {
+        if (hasWildcard(path)) {
+            throw new PathError('wildcards are legal in subscriptions only', path);
+        }
+        const key = pathKey(path);
+        this.writeKey(key, value);
+    }
+    update(path, fn) {
+        this.set(path, fn(this.get(path)));
+    }
+    patch(path, partial) {
+        const current = this.get(path);
+        const base = current && typeof current === 'object' && !Array.isArray(current) ? current : {};
+        this.set(path, { ...base, ...partial });
+    }
+    patchMany(entries) {
+        this.batch(() => {
+            for (const [path, value] of Object.entries(entries)) {
+                this.set(path, value);
+            }
+        });
+    }
+    delete(path) {
+        const key = pathKey(path);
+        const segs = key.split('/');
+        const last = segs.pop();
+        const parent = segs.length === 0 ? this.root : this.readKey(segs.join('/'));
+        if (parent === null || typeof parent !== 'object')
+            return;
+        const previous = parent[last];
+        if (previous === undefined && !(last in parent))
+            return;
+        if (Array.isArray(parent))
+            parent.splice(Number(last), 1);
+        else
+            delete parent[last];
+        this.enqueue({ path: `$/${key}`, value: undefined, previous });
+        this.flushIfIdle();
+    }
+    writeKey(key, value) {
+        if (this.disposed)
+            return;
+        if (key === '')
+            throw new PathError('cannot write the store root', '$/');
+        const schema = this.schemas.get(key);
+        if (schema) {
+            const problem = schema.validate(value);
+            if (problem)
+                throw new PathError(`schema rejected value (${problem})`, `$/${key}`);
+        }
+        const segs = key.split('/');
+        const last = segs.pop();
+        let node = this.root;
+        for (const seg of segs) {
+            let next = node[seg];
+            if (next === null || typeof next !== 'object') {
+                next = {};
+                node[seg] = next;
+            }
+            node = next;
+        }
+        const previous = node[last];
+        if (previous === value)
+            return;
+        node[last] = value;
+        this.enqueue({ path: `$/${key}`, value, previous });
+        this.flushIfIdle();
+    }
+    // --------------------------------------------------------------- batching
+    batch(fn) {
+        this.batchDepth++;
+        try {
+            return fn();
+        }
+        finally {
+            this.batchDepth--;
+            this.flushIfIdle();
+        }
+    }
+    enqueue(change) {
+        const key = pathKey(change.path);
+        const existing = this.pending.get(key);
+        // Keep the oldest `previous` so a batch reports one net change.
+        this.pending.set(key, existing ? { ...change, previous: existing.previous } : change);
+    }
+    flushIfIdle() {
+        if (this.batchDepth > 0 || this.pending.size === 0)
+            return;
+        // Recomputing may enqueue more; drain until quiet, with a runaway guard.
+        let rounds = 0;
+        while (this.pending.size > 0) {
+            if (++rounds > 50) {
+                this.onError(new Error('computed paths did not settle after 50 rounds'), 'flush');
+                this.pending.clear();
+                return;
+            }
+            const changes = [...this.pending.values()];
+            this.pending.clear();
+            this.batchDepth++;
+            try {
+                for (const change of changes)
+                    this.recomputeDependents(pathKey(change.path));
+            }
+            finally {
+                this.batchDepth--;
+            }
+            for (const change of changes)
+                this.notify(change);
+            for (const change of changes)
+                this.schedulePersist(pathKey(change.path));
+        }
+    }
+    notify(change) {
+        const key = pathKey(change.path);
+        for (const sub of [...this.subs]) {
+            if (!this.subMatches(sub, key))
+                continue;
+            try {
+                sub.fn(this.readKey(sub.wildcard ? key : sub.key), change);
+            }
+            catch (err) {
+                this.onError(err, `subscriber of $/${sub.key}`);
+            }
+        }
+    }
+    subMatches(sub, changedKey) {
+        if (sub.wildcard)
+            return matchKey(changedKey, sub.key, sub.subtree);
+        if (sub.key === changedKey)
+            return true;
+        // A write below an exact subscription still changes that object's contents.
+        if (isDescendantKey(changedKey, sub.key))
+            return true;
+        // A write above it may have replaced the subtree the subscriber reads.
+        if (isDescendantKey(sub.key, changedKey))
+            return true;
+        return sub.subtree && ancestorKeys(changedKey).includes(sub.key);
+    }
+    // ---------------------------------------------------------- subscriptions
+    subscribe(path, fn, options = {}) {
+        const key = pathKey(path);
+        const sub = {
+            key,
+            subtree: options.subtree ?? false,
+            wildcard: hasWildcard(key),
+            fn,
+        };
+        this.subs.add(sub);
+        this.touchProvider(key);
+        if (options.immediate) {
+            try {
+                const value = this.readKey(key);
+                fn(value, { path, value, previous: undefined });
+            }
+            catch (err) {
+                this.onError(err, `immediate subscriber of ${path}`);
+            }
+        }
+        return toDisposable(() => {
+            this.subs.delete(sub);
+            this.maybeUnloadProvider(key);
+        });
+    }
+    subscriberCount(scope) {
+        let n = 0;
+        for (const sub of this.subs) {
+            if (sub.key === scope || sub.key.startsWith(scope + '/'))
+                n++;
+        }
+        return n;
+    }
+    clearScope(scope) {
+        const key = pathKey(scope.startsWith('$/') ? scope : `$/${scope}`);
+        const previous = this.readKey(key);
+        if (previous === undefined)
+            return;
+        const segs = key.split('/');
+        const last = segs.pop();
+        const parent = segs.length === 0 ? this.root : this.readKey(segs.join('/'));
+        if (parent && typeof parent === 'object') {
+            delete parent[last];
+        }
+        this.enqueue({ path: `$/${key}`, value: undefined, previous });
+        this.flushIfIdle();
+    }
+    // -------------------------------------------------------------- computed
+    computed(path, def) {
+        const key = pathKey(path);
+        const deps = def.from.map((p) => pathKey(p));
+        const select = typeof def.select === 'string'
+            ? compileSelect(def.select, def.from)
+            : def.select;
+        const entry = {
+            key,
+            deps,
+            compute: () => {
+                const values = {};
+                for (let i = 0; i < def.from.length; i++) {
+                    const p = def.from[i];
+                    values[p] = this.readKey(deps[i]);
+                }
+                return select(values);
+            },
+        };
+        this.computedByKey.set(key, entry);
+        for (const dep of deps) {
+            let set = this.computedDeps.get(dep);
+            if (!set) {
+                set = new Set();
+                this.computedDeps.set(dep, set);
+            }
+            set.add(key);
+        }
+        this.recompute(entry);
+        return toDisposable(() => {
+            this.computedByKey.delete(key);
+            for (const dep of deps)
+                this.computedDeps.get(dep)?.delete(key);
+        });
+    }
+    recompute(entry) {
+        try {
+            this.writeKey(entry.key, entry.compute());
+        }
+        catch (err) {
+            this.onError(err, `computed $/${entry.key}`);
+        }
+    }
+    recomputeDependents(changedKey) {
+        for (const [dep, keys] of this.computedDeps) {
+            const affected = dep === changedKey ||
+                isDescendantKey(changedKey, dep) ||
+                isDescendantKey(dep, changedKey);
+            if (!affected)
+                continue;
+            for (const key of keys) {
+                const entry = this.computedByKey.get(key);
+                if (entry)
+                    this.recompute(entry);
+            }
+        }
+    }
+    // ------------------------------------------------------------ collections
+    collection(path) {
+        const read = () => {
+            const v = this.get(path);
+            return Array.isArray(v) ? v : [];
+        };
+        const write = (items) => this.set(path, items);
+        return {
+            all: () => read(),
+            at: (index) => read()[index],
+            find: (pred) => read().find(pred),
+            append: (...items) => write([...read(), ...items]),
+            prepend: (...items) => write([...items, ...read()]),
+            insertAt: (index, ...items) => {
+                const next = read();
+                next.splice(index, 0, ...items);
+                write(next);
+            },
+            removeAt: (index) => {
+                const next = read();
+                if (index < 0 || index >= next.length)
+                    return;
+                next.splice(index, 1);
+                write(next);
+            },
+            remove: (pred) => {
+                const items = read();
+                const kept = items.filter((item, i) => !pred(item, i));
+                const removed = items.length - kept.length;
+                if (removed > 0)
+                    write(kept);
+                return removed;
+            },
+            update: (pred, patch) => {
+                const items = read();
+                let changed = 0;
+                const next = items.map((item, i) => {
+                    if (!pred(item, i))
+                        return item;
+                    changed++;
+                    return typeof patch === 'function'
+                        ? patch(item)
+                        : { ...item, ...patch };
+                });
+                if (changed > 0)
+                    write(next);
+                return changed;
+            },
+            replace: (items) => write([...items]),
+            filter: (pred) => read().filter(pred),
+            clear: () => write([]),
+            cap: (n) => {
+                const items = read();
+                if (items.length > n)
+                    write(items.slice(items.length - n));
+            },
+            get length() {
+                return read().length;
+            },
+        };
+    }
+    // -------------------------------------------------------------- providers
+    registerDataProvider(def) {
+        const key = pathKey(def.namespace.startsWith('$/') ? def.namespace : `$/${def.namespace}`);
+        const entry = { def, loaded: false, loading: null, unloadTimer: null };
+        this.providers.set(key, entry);
+        if (def.load === 'eager')
+            void this.loadProvider(key);
+        return toDisposable(() => {
+            if (entry.unloadTimer)
+                clearTimeout(entry.unloadTimer);
+            void def.provider.unload?.(this);
+            this.providers.delete(key);
+        });
+    }
+    listDataProviders() {
+        return [...this.providers.values()].map((e) => e.def);
+    }
+    /** A read or subscribe below a provider's namespace is what loads it. */
+    touchProvider(key) {
+        for (const [ns, entry] of this.providers) {
+            if (key !== ns && !isDescendantKey(key, ns))
+                continue;
+            if (entry.unloadTimer) {
+                clearTimeout(entry.unloadTimer);
+                entry.unloadTimer = null;
+            }
+            if (!entry.loaded && !entry.loading)
+                void this.loadProvider(ns);
+        }
+    }
+    async loadProvider(ns) {
+        const entry = this.providers.get(ns);
+        if (!entry || entry.loaded || entry.loading)
+            return;
+        const run = (async () => {
+            try {
+                await entry.def.provider.load(this);
+                entry.loaded = true;
+            }
+            catch (err) {
+                this.onError(err, `data provider ${entry.def.namespace}`);
+            }
+            finally {
+                entry.loading = null;
+            }
+        })();
+        entry.loading = run;
+        await run;
+    }
+    maybeUnloadProvider(key) {
+        for (const [ns, entry] of this.providers) {
+            if (key !== ns && !isDescendantKey(key, ns))
+                continue;
+            const { unloadAfter } = entry.def;
+            if (!unloadAfter || !entry.loaded)
+                continue;
+            if (this.subscriberCount(ns) > 0)
+                continue;
+            if (entry.unloadTimer)
+                clearTimeout(entry.unloadTimer);
+            entry.unloadTimer = setTimeout(() => {
+                entry.unloadTimer = null;
+                if (this.subscriberCount(ns) > 0)
+                    return;
+                void entry.def.provider.unload?.(this);
+                entry.loaded = false;
+            }, unloadAfter);
+            entry.unloadTimer.unref?.();
+        }
+    }
+    // ---------------------------------------------------- schemas, persistence
+    registerSchema(schema) {
+        const key = pathKey(schema.path);
+        this.schemas.set(key, schema);
+        if (schema.initial !== undefined && this.readKey(key) === undefined) {
+            this.writeKey(key, schema.initial);
+        }
+        return toDisposable(() => this.schemas.delete(key));
+    }
+    registerPersistence(adapter) {
+        this.persistence.add(adapter);
+        return toDisposable(() => {
+            const timer = this.persistTimers.get(adapter.id);
+            if (timer)
+                clearTimeout(timer);
+            this.persistTimers.delete(adapter.id);
+            this.persistence.delete(adapter);
+        });
+    }
+    async hydrate() {
+        for (const adapter of this.persistence) {
+            try {
+                const entries = await adapter.read();
+                this.batch(() => {
+                    for (const [path, value] of Object.entries(entries)) {
+                        this.set((path.startsWith('$/') ? path : `$/${path}`), value);
+                    }
+                });
+            }
+            catch (err) {
+                this.onError(err, `persistence adapter ${adapter.id}`);
+            }
+        }
+    }
+    schedulePersist(changedKey) {
+        for (const adapter of this.persistence) {
+            const owns = adapter.paths.some((p) => {
+                const key = adapterKey(p);
+                return p.endsWith('/')
+                    ? changedKey === key || isDescendantKey(changedKey, key)
+                    : changedKey === key;
+            });
+            if (!owns)
+                continue;
+            const existing = this.persistTimers.get(adapter.id);
+            if (existing)
+                clearTimeout(existing);
+            const timer = setTimeout(() => {
+                this.persistTimers.delete(adapter.id);
+                const entries = {};
+                for (const p of adapter.paths) {
+                    const key = adapterKey(p);
+                    entries[`$/${key}`] = this.readKey(key);
+                }
+                try {
+                    void adapter.write(entries);
+                }
+                catch (err) {
+                    this.onError(err, `persistence adapter ${adapter.id}`);
+                }
+            }, adapter.debounceMs ?? 250);
+            timer.unref?.();
+            this.persistTimers.set(adapter.id, timer);
+        }
+    }
+    // --------------------------------------------------------------- snapshot
+    snapshot(scope) {
+        if (!scope)
+            return structuredClone(this.root);
+        const key = pathKey(scope.startsWith('$/') ? scope : `$/${scope}`);
+        const value = this.readKey(key);
+        return value === undefined ? {} : structuredClone({ [key]: value });
+    }
+    restore(snapshot) {
+        this.batch(() => {
+            for (const [key, value] of Object.entries(snapshot)) {
+                this.set(`$/${pathKey(key.startsWith('$/') ? key : `$/${key}`)}`, value);
+            }
+        });
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        for (const timer of this.persistTimers.values())
+            clearTimeout(timer);
+        this.persistTimers.clear();
+        for (const entry of this.providers.values()) {
+            if (entry.unloadTimer)
+                clearTimeout(entry.unloadTimer);
+            try {
+                void entry.def.provider.unload?.(this);
+            }
+            catch {
+                /* teardown is best effort */
+            }
+        }
+        this.providers.clear();
+        this.subs.clear();
+        this.computedByKey.clear();
+        this.computedDeps.clear();
+        this.root = {};
+    }
+}
+/**
+ * A computed defined as data. Deliberately tiny: `sum`, `count`, `length`,
+ * `first`, `join`, or a path reference. Anything more is a function.
+ */
+function compileSelect(expr, from) {
+    const [op, arg] = expr.split(':');
+    const pick = (values) => values[arg ?? from[0]];
+    switch (op) {
+        case 'length':
+        case 'count':
+            return (v) => {
+                const x = pick(v);
+                return Array.isArray(x) ? x.length : x == null ? 0 : Object.keys(x).length;
+            };
+        case 'sum':
+            return (v) => {
+                const x = pick(v);
+                return Array.isArray(x) ? x.reduce((a, b) => a + Number(b || 0), 0) : 0;
+            };
+        case 'first':
+            return (v) => {
+                const x = pick(v);
+                return Array.isArray(x) ? x[0] : undefined;
+            };
+        case 'last':
+            return (v) => {
+                const x = pick(v);
+                return Array.isArray(x) ? x[x.length - 1] : undefined;
+            };
+        case 'not':
+            return (v) => !pick(v);
+        case 'join':
+            return (v) => {
+                const x = pick(v);
+                return Array.isArray(x) ? x.join(arg ?? ', ') : '';
+            };
+        case 'concat':
+            return (v) => from.map((p) => String(v[p] ?? '')).join('');
+        default:
+            // A bare path reference: `$/a/b`.
+            return (v) => v[expr];
+    }
+}
+export function createStore() {
+    return new Store();
+}
+/**
+ * The key an adapter's path stands for.
+ *
+ * A trailing slash means "and everything under it", so it has to come off
+ * before the path is turned into a key: `segments` keeps the empty piece it
+ * leaves behind, so `$/a/b/` became the key `a/b/` and matched neither `a/b`
+ * nor anything below it. Every subtree adapter ever registered was inert.
+ */
+function adapterKey(path) {
+    const bare = path.endsWith('/') ? path.slice(0, -1) : path;
+    return pathKey(bare.startsWith('$/') ? bare : `$/${bare}`);
+}

package/dist/core/surfaces.d.ts

@@ -0,0 +1,81 @@
+import type { LayoutDefinition, LayoutRegistry, Mount, SurfaceName, SurfaceRegistry, SurfaceState } from '../types/surface.js';
+import type { ShellDefinition, ShellRegistry } from '../types/shell.js';
+import type { ReactiveStore } from '../types/store.js';
+import type { WhenEngine } from '../types/when.js';
+import type { ResourceRegistry } from '../types/resource.js';
+import type { Disposable } from '../types/disposable.js';
+/**
+ * The surfaces the shipped shells use.
+ *
+ * A convenience, not a constraint: it is what gets seeded at boot so the
+ * built-in shells have state to read. An application is free to mount onto a
+ * name that is not here, and nothing checks.
+ */
+export declare const SURFACE_NAMES: SurfaceName[];
+/**
+ * Surfaces, mounts and their state.
+ *
+ * A surface is whatever the application calls a region. The runtime keeps
+ * state per name and never validates one: mounting onto `lateral1` works
+ * exactly as well as mounting onto `sidebar`, and needs no registration. The
+ * shipped names are seeded at boot only so the shipped shells have something
+ * to read.
+ *
+ * Which layout a surface uses is store state rather than code, which is what
+ * makes it switchable at runtime and persistable per user.
+ */
+export declare class Surfaces implements SurfaceRegistry {
+    private deps;
+    private byKey;
+    /** Subscriptions to the paths a mount's `when` clause reads. */
+    private conditions;
+    constructor(deps: {
+        store: ReactiveStore;
+        when: WhenEngine;
+        resources(): ResourceRegistry;
+        onChange(): void;
+    });
+    private id;
+    private publish;
+    open(mount: Mount): Disposable;
+    close(surface: SurfaceName, key: string): void;
+    closeAll(surface: SurfaceName): void;
+    get(surface: SurfaceName, key: string): Mount | undefined;
+    private watchCondition;
+    private unwatchCondition;
+    /** Every mount on a surface, conditional or not. */
+    all(surface: SurfaceName): Mount[];
+    /** Mounts whose `when` clause passes, in order. */
+    mounts(surface: SurfaceName): Mount[];
+    activate(surface: SurfaceName, key: string): void;
+    state(surface: SurfaceName): SurfaceState;
+    setState(surface: SurfaceName, patch: Partial<SurfaceState>): void;
+    /**
+     * Resource-level open: ask the registry which viewer handles this kind, then
+     * mount it. The caller never names a component, which is what lets a new
+     * resource type arrive with its own viewer and work everywhere at once.
+     */
+    openResource(uri: string, options?: {
+        surface?: SurfaceName;
+        viewerId?: string;
+        mode?: 'view' | 'edit';
+    }): Promise<Disposable | null>;
+}
+export declare class Layouts implements LayoutRegistry {
+    private defs;
+    register(def: LayoutDefinition): Disposable;
+    get(name: string): LayoutDefinition | undefined;
+    list(surface?: SurfaceName): LayoutDefinition[];
+}
+export declare class Shells implements ShellRegistry {
+    private defs;
+    register(def: ShellDefinition): Disposable;
+    get(id: string): ShellDefinition | undefined;
+    list(): ShellDefinition[];
+    /** Shells that fit, largest minimum first - the richest one that works. */
+    suitable(width: number, height: number): ShellDefinition[];
+}
+export declare function createSurfaces(deps: ConstructorParameters<typeof Surfaces>[0]): Surfaces;
+export declare function createLayouts(): Layouts;
+export declare function createShells(): Shells;
+//# sourceMappingURL=surfaces.d.ts.map

package/dist/core/surfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surfaces.d.ts","sourceRoot":"","sources":["../../src/core/surfaces.ts"],"names":[],"mappings":"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"}