@textui/core 0.1.0

package/dist/core/surfaces.js

@@ -0,0 +1,237 @@
+import { toDisposable } from '../util/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 const SURFACE_NAMES = [
+    'header', 'rail', 'sidebar', 'aside', 'main', 'panel', 'status', 'overlay', 'notify',
+];
+/**
+ * How a surface arranges its mounts when nobody has said.
+ *
+ * Only the shipped names have an opinion. Anything else gets `single`, which
+ * shows the active mount and is the one answer that is never wrong - a surface
+ * the library has never heard of cannot be assumed to want tabs.
+ */
+const DEFAULT_LAYOUTS = {
+    header: 'bar',
+    rail: 'rail',
+    // One at a time, not stacked. A second panel arriving under the first
+    // halves both of them; a sidebar is a narrow column and the panels in it -
+    // a tree, a source control list, a search - each want the whole height.
+    // `activeKey` picks, and `single` falls back to the first mount.
+    sidebar: 'single',
+    aside: 'stack',
+    main: 'tabs',
+    panel: 'tabs',
+    status: 'bar',
+    overlay: 'floating',
+    notify: 'toast',
+};
+const FALLBACK_LAYOUT = 'single';
+function defaultLayout(surface) {
+    return DEFAULT_LAYOUTS[surface] ?? FALLBACK_LAYOUT;
+}
+function defaultState(surface) {
+    return { layout: defaultLayout(surface), activeKey: null, visible: true };
+}
+function statePath(surface) {
+    return `$/layout/surfaces/${surface}`;
+}
+function mountsPath(surface) {
+    return `$/layout/mounts/${surface}`;
+}
+/**
+ * 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 class Surfaces {
+    deps;
+    byKey = new Map();
+    /** Subscriptions to the paths a mount's `when` clause reads. */
+    conditions = new Map();
+    constructor(deps) {
+        this.deps = deps;
+        for (const surface of SURFACE_NAMES) {
+            if (this.deps.store.get(statePath(surface)) === undefined) {
+                this.deps.store.set(statePath(surface), defaultState(surface));
+            }
+        }
+    }
+    id(surface, key) {
+        return `${surface}/${key}`;
+    }
+    publish(surface) {
+        const list = this.mounts(surface).map((m) => ({
+            key: m.key,
+            display: m.display ?? {},
+            policy: m.policy ?? {},
+        }));
+        this.deps.store.set(mountsPath(surface), list);
+        this.deps.onChange();
+    }
+    open(mount) {
+        const id = this.id(mount.surface, mount.key);
+        this.byKey.set(id, mount);
+        // A conditional mount has to react to the paths its clause reads, or it
+        // stays hidden until something unrelated happens to redraw the surface.
+        this.watchCondition(id, mount);
+        const state = this.state(mount.surface);
+        if (state.activeKey === null || mount.policy?.transient) {
+            this.setState(mount.surface, { activeKey: mount.key });
+        }
+        this.publish(mount.surface);
+        return toDisposable(() => this.close(mount.surface, mount.key));
+    }
+    close(surface, key) {
+        const id = this.id(surface, key);
+        this.unwatchCondition(id);
+        if (!this.byKey.delete(id))
+            return;
+        const state = this.state(surface);
+        if (state.activeKey === key) {
+            const remaining = this.mounts(surface);
+            this.setState(surface, { activeKey: remaining[0]?.key ?? null });
+        }
+        this.publish(surface);
+    }
+    closeAll(surface) {
+        for (const mount of this.all(surface)) {
+            const id = this.id(surface, mount.key);
+            this.unwatchCondition(id);
+            this.byKey.delete(id);
+        }
+        this.setState(surface, { activeKey: null });
+        this.publish(surface);
+    }
+    get(surface, key) {
+        return this.byKey.get(this.id(surface, key));
+    }
+    watchCondition(id, mount) {
+        this.unwatchCondition(id);
+        if (!mount.when)
+            return;
+        const deps = this.deps.when.dependencies(mount.when);
+        if (deps.length === 0)
+            return;
+        this.conditions.set(id, deps.map((path) => this.deps.store.subscribe(path, () => this.publish(mount.surface))));
+    }
+    unwatchCondition(id) {
+        for (const sub of this.conditions.get(id) ?? [])
+            sub.dispose();
+        this.conditions.delete(id);
+    }
+    /** Every mount on a surface, conditional or not. */
+    all(surface) {
+        return [...this.byKey.values()]
+            .filter((m) => m.surface === surface)
+            .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    }
+    /** Mounts whose `when` clause passes, in order. */
+    mounts(surface) {
+        return [...this.byKey.values()]
+            .filter((m) => m.surface === surface && this.deps.when.evaluate(m.when))
+            .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    }
+    activate(surface, key) {
+        if (!this.byKey.has(this.id(surface, key)))
+            return;
+        this.setState(surface, { activeKey: key });
+    }
+    state(surface) {
+        return this.deps.store.get(statePath(surface)) ?? defaultState(surface);
+    }
+    setState(surface, patch) {
+        // A name nobody seeded is still a surface. Give it defaults on first use
+        // rather than patching a hole, or `visible` and `layout` arrive undefined
+        // and every reader has to guess what an unseeded surface meant.
+        if (this.deps.store.get(statePath(surface)) === undefined) {
+            this.deps.store.set(statePath(surface), defaultState(surface));
+        }
+        this.deps.store.patch(statePath(surface), patch);
+        this.deps.onChange();
+    }
+    /**
+     * 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.
+     */
+    async openResource(uri, options = {}) {
+        const resources = this.deps.resources();
+        const resource = await resources.stat(uri);
+        if (!resource)
+            return null;
+        const node = resources.nodeFor(resource, options);
+        if (!node)
+            return null;
+        return this.open({
+            surface: options.surface ?? 'main',
+            key: uri,
+            target: node,
+            display: { title: resource.metadata.name, icon: resource.kind },
+            policy: { closable: true },
+        });
+    }
+}
+export class Layouts {
+    defs = new Map();
+    register(def) {
+        this.defs.set(def.name, def);
+        return toDisposable(() => this.defs.delete(def.name));
+    }
+    get(name) {
+        return this.defs.get(name);
+    }
+    list(surface) {
+        const all = [...this.defs.values()];
+        return surface ? all.filter((d) => !d.surfaces || d.surfaces.includes(surface)) : all;
+    }
+}
+export class Shells {
+    defs = new Map();
+    register(def) {
+        this.defs.set(def.id, def);
+        return toDisposable(() => this.defs.delete(def.id));
+    }
+    get(id) {
+        return this.defs.get(id);
+    }
+    list() {
+        return [...this.defs.values()];
+    }
+    /** Shells that fit, largest minimum first - the richest one that works. */
+    suitable(width, height) {
+        return [...this.defs.values()]
+            .filter((s) => {
+            const min = s.minSize;
+            if (!min)
+                return true;
+            return (min.width ?? 0) <= width && (min.height ?? 0) <= height;
+        })
+            .sort((a, b) => {
+            const av = (a.minSize?.width ?? 0) + (a.minSize?.height ?? 0);
+            const bv = (b.minSize?.width ?? 0) + (b.minSize?.height ?? 0);
+            return bv - av;
+        });
+    }
+}
+export function createSurfaces(deps) {
+    return new Surfaces(deps);
+}
+export function createLayouts() {
+    return new Layouts();
+}
+export function createShells() {
+    return new Shells();
+}

package/dist/core/syntax.d.ts

@@ -0,0 +1,49 @@
+import type { HighlighterDefinition, SyntaxQuery, SyntaxRegistry, SyntaxSpan, SyntaxToken } from '../types/syntax.js';
+import type { Disposable } from '../types/disposable.js';
+/**
+ * The highlighter registry.
+ *
+ * Late binding, like every other registry here: a file whose kind has no
+ * highlighter is shown uncoloured rather than refused, and registering one
+ * later colours every viewer already on screen.
+ */
+/**
+ * The last segment of a URI, without a query or a fragment.
+ *
+ * Exported because three places wanted it and each had written its own: the
+ * highlighter matching a glob, the resource registry naming a resource, and a
+ * viewer saying which file it is showing.
+ */
+export declare function nameOf(uri: string): string;
+/** One plain token per line: what an unhighlighted document looks like. */
+export declare function plainTokens(text: string): SyntaxToken[][];
+/**
+ * Split scored spans into per-line tokens.
+ *
+ * Highlighters are far easier to write as a single scan over the source than
+ * as a line-aware state machine, so they score offsets and this does the
+ * splitting - including the newlines inside a multi-line string, which is the
+ * part a hand-written splitter always gets wrong.
+ */
+export declare function tokensFromSpans(text: string, spans: SyntaxSpan[]): SyntaxToken[][];
+/** Build a highlighter from a function that scores spans. */
+export declare function spanHighlighter(def: Omit<HighlighterDefinition, 'tokenize'> & {
+    scan(text: string): SyntaxSpan[];
+}): HighlighterDefinition;
+export declare class Syntax implements SyntaxRegistry {
+    private deps;
+    private defs;
+    constructor(deps?: {
+        /** True when `kind` is `ancestor` or specialises it. */
+        kindMatches(kind: string, ancestor: string): boolean;
+        onError?(err: unknown, context: string): void;
+    });
+    register(def: HighlighterDefinition): Disposable;
+    unregister(id: string): void;
+    get(id: string): HighlighterDefinition | undefined;
+    list(): HighlighterDefinition[];
+    find(query: SyntaxQuery): HighlighterDefinition | undefined;
+    tokenize(text: string, query?: SyntaxQuery): SyntaxToken[][];
+}
+export declare function createSyntax(deps?: ConstructorParameters<typeof Syntax>[0]): Syntax;
+//# sourceMappingURL=syntax.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"syntax.d.ts","sourceRoot":"","sources":["../../src/core/syntax.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EAAE,WAAW,EAAE,cAAc,EAAe,UAAU,EAC3E,WAAW,EACZ,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD;;;;;;GAMG;AAEH;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG1C;AASD,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,EAAE,CAEzD;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,GAAG,WAAW,EAAE,EAAE,CAiDlF;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,CAC7B,GAAG,EAAE,IAAI,CAAC,qBAAqB,EAAE,UAAU,CAAC,GAAG;IAAE,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,CAAA;CAAE,GAClF,qBAAqB,CAGvB;AAED,qBAAa,MAAO,YAAW,cAAc;IAIzC,OAAO,CAAC,IAAI;IAHd,OAAO,CAAC,IAAI,CAA4C;gBAG9C,IAAI,GAAE;QACZ,wDAAwD;QACxD,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;QACrD,OAAO,CAAC,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;KACU;IAG5D,QAAQ,CAAC,GAAG,EAAE,qBAAqB,GAAG,UAAU;IAOhD,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAI5B,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;IAIlD,IAAI,IAAI,qBAAqB,EAAE;IAI/B,IAAI,CAAC,KAAK,EAAE,WAAW,GAAG,qBAAqB,GAAG,SAAS;IAgC3D,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,GAAE,WAAgB,GAAG,WAAW,EAAE,EAAE;CA2BjE;AAED,wBAAgB,YAAY,CAAC,IAAI,CAAC,EAAE,qBAAqB,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAEnF"}

package/dist/core/syntax.js

@@ -0,0 +1,172 @@
+import { toDisposable } from '../util/disposable.js';
+/**
+ * The highlighter registry.
+ *
+ * Late binding, like every other registry here: a file whose kind has no
+ * highlighter is shown uncoloured rather than refused, and registering one
+ * later colours every viewer already on screen.
+ */
+/**
+ * The last segment of a URI, without a query or a fragment.
+ *
+ * Exported because three places wanted it and each had written its own: the
+ * highlighter matching a glob, the resource registry naming a resource, and a
+ * viewer saying which file it is showing.
+ */
+export function nameOf(uri) {
+    const clean = uri.split(/[?#]/)[0] ?? uri;
+    return clean.split('/').pop() ?? clean;
+}
+function matchesGlob(name, pattern) {
+    if (pattern.startsWith('*.')) {
+        return name.toLowerCase().endsWith(pattern.slice(1).toLowerCase());
+    }
+    return name.toLowerCase() === pattern.toLowerCase();
+}
+/** One plain token per line: what an unhighlighted document looks like. */
+export function plainTokens(text) {
+    return text.split('\n').map((line) => (line === '' ? [] : [{ text: line, scope: 'plain' }]));
+}
+/**
+ * Split scored spans into per-line tokens.
+ *
+ * Highlighters are far easier to write as a single scan over the source than
+ * as a line-aware state machine, so they score offsets and this does the
+ * splitting - including the newlines inside a multi-line string, which is the
+ * part a hand-written splitter always gets wrong.
+ */
+export function tokensFromSpans(text, spans) {
+    const ordered = [...spans].sort((a, b) => a.start - b.start);
+    const lines = text.split('\n');
+    const out = lines.map(() => []);
+    // Line index for every offset, computed once.
+    const lineStarts = [0];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '\n')
+            lineStarts.push(i + 1);
+    }
+    const lineAt = (offset) => {
+        let lo = 0;
+        let hi = lineStarts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (lineStarts[mid] <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo;
+    };
+    const push = (start, end, scope) => {
+        if (end <= start)
+            return;
+        let cursor = start;
+        while (cursor < end) {
+            const line = lineAt(cursor);
+            const lineEnd = lineStarts[line] + lines[line].length;
+            const stop = Math.min(end, lineEnd);
+            if (stop > cursor) {
+                out[line].push({ text: text.slice(cursor, stop), scope });
+            }
+            cursor = stop + 1; // step over the newline
+        }
+    };
+    let cursor = 0;
+    for (const span of ordered) {
+        // Overlaps are a bug in the highlighter, not a reason to lose text: the
+        // first span wins the shared cells and the rest of this one still lands.
+        const start = Math.max(cursor, span.start);
+        const end = Math.min(Math.max(start, span.end), text.length);
+        if (end <= cursor)
+            continue;
+        if (start > cursor)
+            push(cursor, start, 'plain');
+        push(start, end, span.scope);
+        cursor = end;
+    }
+    if (cursor < text.length)
+        push(cursor, text.length, 'plain');
+    return out;
+}
+/** Build a highlighter from a function that scores spans. */
+export function spanHighlighter(def) {
+    const { scan, ...rest } = def;
+    return { ...rest, tokenize: (text) => tokensFromSpans(text, scan(text)) };
+}
+export class Syntax {
+    deps;
+    defs = new Map();
+    constructor(deps = { kindMatches: (kind, ancestor) => kind === ancestor }) {
+        this.deps = deps;
+    }
+    register(def) {
+        this.defs.set(def.id, def);
+        return toDisposable(() => {
+            if (this.defs.get(def.id) === def)
+                this.defs.delete(def.id);
+        });
+    }
+    unregister(id) {
+        this.defs.delete(id);
+    }
+    get(id) {
+        return this.defs.get(id);
+    }
+    list() {
+        return [...this.defs.values()];
+    }
+    find(query) {
+        if (query.language) {
+            const named = this.defs.get(query.language);
+            if (named)
+                return named;
+        }
+        const name = query.uri ? nameOf(query.uri) : undefined;
+        let best;
+        let bestScore = -Infinity;
+        for (const def of this.defs.values()) {
+            let score = def.priority ?? 0;
+            let matched = false;
+            if (query.kind && def.kinds?.some((k) => this.deps.kindMatches(query.kind, k))) {
+                // A highlighter registered for the exact kind beats one registered
+                // for an ancestor of it.
+                matched = true;
+                score += def.kinds.includes(query.kind) ? 120 : 100;
+            }
+            if (name && def.extensions?.some((p) => matchesGlob(name, p))) {
+                matched = true;
+                score += 60;
+            }
+            if (matched && score > bestScore) {
+                best = def;
+                bestScore = score;
+            }
+        }
+        return best;
+    }
+    tokenize(text, query = {}) {
+        const def = this.find(query);
+        if (!def)
+            return plainTokens(text);
+        const lines = text.split('\n');
+        let result;
+        try {
+            result = def.tokenize(text);
+        }
+        catch (err) {
+            this.deps.onError?.(err, `highlighter "${def.id}"`);
+            return plainTokens(text);
+        }
+        // A highlighter that loses or invents a line would slide the whole file
+        // against its gutter. Uncoloured is wrong; misaligned is unreadable.
+        if (result.length !== lines.length) {
+            this.deps.onError?.(new Error(`[textui] highlighter "${def.id}" returned ${result.length} lines for ` +
+                `a ${lines.length}-line document`), 'syntax');
+            return plainTokens(text);
+        }
+        return result;
+    }
+}
+export function createSyntax(deps) {
+    return new Syntax(deps);
+}

package/dist/core/when.d.ts

@@ -0,0 +1,15 @@
+import type { ContextValue, WhenClause, WhenEngine } from '../types/when.js';
+import type { BindingPath } from '../types/graph.js';
+import type { ReactiveStore } from '../types/store.js';
+export declare class When implements WhenEngine {
+    private store;
+    private context;
+    private cache;
+    constructor(store: ReactiveStore);
+    evaluate(clause: WhenClause | undefined, extra?: Record<string, ContextValue>): boolean;
+    dependencies(clause: WhenClause): BindingPath[];
+    setContext(key: string, value: ContextValue): void;
+    getContext(key: string): ContextValue | undefined;
+}
+export declare function createWhen(store: ReactiveStore): When;
+//# sourceMappingURL=when.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"when.d.ts","sourceRoot":"","sources":["../../src/core/when.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AA0LvD,qBAAa,IAAK,YAAW,UAAU;IAIzB,OAAO,CAAC,KAAK;IAHzB,OAAO,CAAC,OAAO,CAAmC;IAClD,OAAO,CAAC,KAAK,CAA8B;gBAEvB,KAAK,EAAE,aAAa;IAExC,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,SAAS,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,OAAO;IAsBvF,YAAY,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,EAAE;IAU/C,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,IAAI;IAIlD,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;CAGlD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI,CAErD"}