@textui/core 0.1.0

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

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

package/dist/core/resources.js

@@ -0,0 +1,321 @@
+import { toDisposable } from '../util/disposable.js';
+import { nameOf } from './syntax.js';
+function schemeOf(uri) {
+    const i = uri.indexOf(':');
+    return i === -1 ? 'file' : uri.slice(0, i);
+}
+function matchesGlob(name, pattern) {
+    if (pattern.startsWith('*.'))
+        return name.toLowerCase().endsWith(pattern.slice(1).toLowerCase());
+    return name.toLowerCase() === pattern.toLowerCase();
+}
+/**
+ * The resource model.
+ *
+ * A resource is anything addressable that something can be registered to
+ * display, edit or act on - a file, a record, a log stream, a service. The
+ * filesystem is one provider among several rather than the model itself, which
+ * is what lets an explorer browse services and files with the same component.
+ *
+ * Kinds form a hierarchy by dotted name: `file.markdown` specialises
+ * `file.text`, so a viewer registered for `file.text` still opens a markdown
+ * file when no more specific one exists.
+ */
+export class Resources {
+    deps;
+    kindDefs = new Map();
+    providers = new Map();
+    viewers = [];
+    editors = [];
+    actions = [];
+    constructor(deps) {
+        this.deps = deps;
+    }
+    registerKind(kind) {
+        this.kindDefs.set(kind.id, kind);
+        return toDisposable(() => this.kindDefs.delete(kind.id));
+    }
+    registerProvider(provider) {
+        this.providers.set(provider.scheme, provider);
+        return toDisposable(() => this.providers.delete(provider.scheme));
+    }
+    registerViewer(def) {
+        this.viewers.push(def);
+        return toDisposable(() => {
+            const i = this.viewers.indexOf(def);
+            if (i >= 0)
+                this.viewers.splice(i, 1);
+        });
+    }
+    registerEditor(def) {
+        this.editors.push(def);
+        return toDisposable(() => {
+            const i = this.editors.indexOf(def);
+            if (i >= 0)
+                this.editors.splice(i, 1);
+        });
+    }
+    registerAction(def) {
+        this.actions.push(def);
+        return toDisposable(() => {
+            const i = this.actions.indexOf(def);
+            if (i >= 0)
+                this.actions.splice(i, 1);
+        });
+    }
+    kinds() {
+        return [...this.kindDefs.values()];
+    }
+    /** Extension, then mime type, then an explicit `detect`. Best match wins. */
+    detectKind(uri, meta = { name: uri }) {
+        const name = meta.name || nameOf(uri) || uri;
+        const candidates = [];
+        for (const kind of this.kindDefs.values()) {
+            let score = kind.priority ?? 0;
+            let matched = false;
+            if (kind.extensions?.some((p) => matchesGlob(name, p))) {
+                score += 100;
+                matched = true;
+            }
+            if (meta.mimeType && kind.mimeTypes?.includes(meta.mimeType)) {
+                score += 80;
+                matched = true;
+            }
+            if (kind.detect?.(uri, meta)) {
+                score += 200;
+                matched = true;
+            }
+            // A more specific kind beats its parent on equal evidence.
+            if (matched) {
+                score += kind.id.split('.').length;
+                candidates.push({ id: kind.id, score });
+            }
+        }
+        if (candidates.length === 0)
+            return meta.mimeType ? 'file' : 'unknown';
+        candidates.sort((a, b) => b.score - a.score);
+        return candidates[0].id;
+    }
+    kindMatches(kind, ancestor) {
+        if (kind === ancestor)
+            return true;
+        if (kind.startsWith(ancestor + '.'))
+            return true;
+        let cursor = this.kindDefs.get(kind);
+        const seen = new Set();
+        while (cursor?.extends && !seen.has(cursor.id)) {
+            seen.add(cursor.id);
+            if (cursor.extends === ancestor)
+                return true;
+            cursor = this.kindDefs.get(cursor.extends);
+        }
+        return false;
+    }
+    provider(uri) {
+        const scheme = schemeOf(uri);
+        const provider = this.providers.get(scheme);
+        if (!provider) {
+            throw new Error(`[textui] no resource provider registered for "${scheme}:"`);
+        }
+        return provider;
+    }
+    async stat(uri) {
+        const resource = await this.provider(uri).stat(uri);
+        if (!resource)
+            return null;
+        // A provider may leave classification to the registry.
+        if (!resource.kind || resource.kind === 'unknown') {
+            return { ...resource, kind: this.detectKind(uri, resource.metadata) };
+        }
+        return resource;
+    }
+    async list(uri) {
+        const provider = this.provider(uri);
+        if (!provider.list)
+            return [];
+        const items = await provider.list(uri);
+        return items.map((r) => r.kind && r.kind !== 'unknown' ? r : { ...r, kind: this.detectKind(r.uri, r.metadata) });
+    }
+    async read(uri) {
+        const provider = this.provider(uri);
+        if (!provider.read)
+            throw new Error(`[textui] "${schemeOf(uri)}:" cannot be read`);
+        return provider.read(uri);
+    }
+    async write(uri, content) {
+        const provider = this.provider(uri);
+        if (!provider.write)
+            throw new Error(`[textui] "${schemeOf(uri)}:" is read-only`);
+        return provider.write(uri, content);
+    }
+    /**
+     * Destructive calls throw when the provider cannot serve them, the same way
+     * `write` does. A silent no-op is the failure mode worth designing against:
+     * a Delete that appears in the menu and removes nothing is worse than one
+     * that says it cannot.
+     *
+     * Whether to *offer* the action is a different question, answered before
+     * the call by `Resource.capabilities` - which is per resource rather than
+     * per provider, so a read-only mount, a file without permission and an
+     * inherently immutable resource are all the same shape. The throw is for
+     * the race that asking first cannot close: the remote goes away, the
+     * permission changes, between the offer and the call.
+     */
+    async delete(uri) {
+        const provider = this.provider(uri);
+        if (!provider.delete)
+            throw new Error(`[textui] "${schemeOf(uri)}:" cannot delete`);
+        return provider.delete(uri);
+    }
+    /**
+     * A rename is within one provider. Two schemes is a move between providers,
+     * which is a copy and a delete and belongs above a registry that dispatches
+     * on a single scheme by construction.
+     */
+    async rename(from, to) {
+        const scheme = schemeOf(from);
+        if (schemeOf(to) !== scheme) {
+            throw new Error(`[textui] cannot rename across schemes: "${scheme}:" to "${schemeOf(to)}:"`);
+        }
+        const provider = this.provider(from);
+        if (!provider.rename)
+            throw new Error(`[textui] "${scheme}:" cannot rename`);
+        return provider.rename(from, to);
+    }
+    /**
+     * Watching follows `list` rather than `write`: a provider that cannot watch
+     * gets a disposable that does nothing, because "I will never tell you about
+     * a change" is a truthful answer to an optional question. Making every
+     * caller guard a subscription would buy nothing.
+     */
+    watch(uri, fn) {
+        const provider = this.provider(uri);
+        return provider.watch?.(uri, fn) ?? toDisposable(() => { });
+    }
+    viewersFor(kind) {
+        const specific = this.viewers
+            .filter((v) => !v.fallback && v.kinds.some((k) => this.kindMatches(kind, k)))
+            .filter((v) => this.deps.when.evaluate(v.when))
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        const fallbacks = this.viewers
+            .filter((v) => v.fallback)
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+        return [...specific, ...fallbacks];
+    }
+    editorsFor(kind) {
+        return this.editors
+            .filter((e) => e.kinds.some((k) => this.kindMatches(kind, k)))
+            .filter((e) => this.deps.when.evaluate(e.when))
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    }
+    /**
+     * Every way of showing this kind, best first.
+     *
+     * Three registries answer the same question - an editor, a viewer and a
+     * component that declared `opens` are all "a component that can put this on
+     * screen" - and a panel offering "open with" wants one list. Saving is a
+     * property of the renderer here rather than the registry it came from, which
+     * is what lets `file.markdown` list an editor, a rendered view and plain
+     * text together and lets the panel pick between them.
+     */
+    /**
+     * What a resource looks like in a list.
+     *
+     * Asked of the *renderer* first, because the thing that knows what a
+     * markdown file is is the thing that opens markdown files - so a viewer an
+     * extension brought names and colours its own kind without anything here
+     * learning what it is. Then the kind, walking up `extends`, since
+     * `file.markdown` inheriting Text's icon is better than inheriting nothing.
+     *
+     * Answers nothing rather than a default: what a nameless file looks like is
+     * the caller's vocabulary, because which glyphs a terminal can draw is known
+     * where the terminal is and not here.
+     */
+    appearanceOf(resource) {
+        for (const renderer of this.renderersFor(resource.kind)) {
+            if (renderer.icon !== undefined || renderer.tone !== undefined) {
+                return {
+                    ...(renderer.icon !== undefined ? { icon: renderer.icon } : {}),
+                    ...(renderer.tone !== undefined ? { tone: renderer.tone } : {}),
+                };
+            }
+        }
+        const byId = new Map(this.kinds().map((k) => [k.id, k]));
+        // Bounded by the number of kinds: a cycle in `extends` is a bad
+        // registration and must not be an infinite loop in a list row.
+        const seen = new Set();
+        let kind = byId.get(resource.kind);
+        while (kind && !seen.has(kind.id)) {
+            seen.add(kind.id);
+            if (kind.icon !== undefined || kind.tone !== undefined) {
+                return {
+                    ...(kind.icon !== undefined ? { icon: kind.icon } : {}),
+                    ...(kind.tone !== undefined ? { tone: kind.tone } : {}),
+                };
+            }
+            kind = kind.extends === undefined ? undefined : byId.get(kind.extends);
+        }
+        return {};
+    }
+    renderersFor(kind) {
+        const seen = new Set();
+        const out = [];
+        const add = (def) => {
+            if (seen.has(def.id))
+                return;
+            seen.add(def.id);
+            out.push(def);
+        };
+        for (const e of this.editorsFor(kind))
+            add({ ...e, saves: true });
+        for (const v of this.viewersFor(kind))
+            add({ ...v, saves: false });
+        for (const c of this.deps.components.findOpeners(kind)) {
+            add({
+                id: c.component,
+                title: c.opens?.title ?? c.component,
+                kinds: c.opens?.resourceKinds ?? [],
+                component: c.component,
+                ...(c.opens?.icon !== undefined ? { icon: c.opens.icon } : {}),
+                ...(c.opens?.priority !== undefined ? { priority: c.opens.priority } : {}),
+                saves: c.opens?.mode === 'edit',
+            });
+        }
+        return out.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    }
+    actionsFor(kind, slot) {
+        return this.actions
+            .filter((a) => a.kinds.some((k) => this.kindMatches(kind, k) || k === '*'))
+            .filter((a) => !slot || (a.slots ?? ['context']).includes(slot))
+            .filter((a) => this.deps.when.evaluate(a.when))
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+    }
+    /**
+     * The node that displays this resource. An explicit `viewerId` wins; then a
+     * registered editor when edit was asked for; then the best viewer; then a
+     * component that declared `opens` for this kind; then nothing.
+     */
+    nodeFor(resource, options = {}) {
+        const props = { resource, uri: resource.uri };
+        if (options.viewerId) {
+            const chosen = this.viewers.find((v) => v.id === options.viewerId) ??
+                this.editors.find((e) => e.id === options.viewerId);
+            return chosen ? { component: chosen.component, ...props } : null;
+        }
+        if (options.mode === 'edit') {
+            const editor = this.editorsFor(resource.kind)[0];
+            if (editor)
+                return { component: editor.component, ...props };
+        }
+        const viewer = this.viewersFor(resource.kind)[0];
+        if (viewer)
+            return { component: viewer.component, ...props };
+        const opener = this.deps.components.findOpeners(resource.kind)[0];
+        if (opener)
+            return { component: opener.component, ...props };
+        return null;
+    }
+}
+export function createResources(deps) {
+    return new Resources(deps);
+}

package/dist/core/services.d.ts

@@ -0,0 +1,21 @@
+import type { ServiceContainer, ServiceKey } from '../types/services.js';
+import type { Disposable } from '../types/disposable.js';
+/**
+ * A typed lookup table, not a dependency-injection container. No lifecycles,
+ * no scoping rules, no auto-wiring - a child falls back to its parent and that
+ * is the whole of it.
+ */
+export declare class Services implements ServiceContainer {
+    private parent;
+    private values;
+    private factories;
+    constructor(parent?: ServiceContainer | null);
+    provide<T>(key: ServiceKey<T>, value: T): Disposable;
+    provideLazy<T>(key: ServiceKey<T>, factory: () => T): Disposable;
+    get<T>(key: ServiceKey<T>): T | undefined;
+    require<T>(key: ServiceKey<T>): T;
+    has<T>(key: ServiceKey<T>): boolean;
+    child(): ServiceContainer;
+}
+export declare function createServices(parent?: ServiceContainer): Services;
+//# sourceMappingURL=services.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../../src/core/services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD;;;;GAIG;AACH,qBAAa,QAAS,YAAW,gBAAgB;IAInC,OAAO,CAAC,MAAM;IAH1B,OAAO,CAAC,MAAM,CAA8B;IAC5C,OAAO,CAAC,SAAS,CAAoC;gBAEjC,MAAM,GAAE,gBAAgB,GAAG,IAAW;IAE1D,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,UAAU;IAepD,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,GAAG,UAAU;IAQhE,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS;IAWzC,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC;IAQjC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO;IAInC,KAAK,IAAI,gBAAgB;CAG1B;AAED,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,gBAAgB,GAAG,QAAQ,CAElE"}

package/dist/core/services.js

@@ -0,0 +1,63 @@
+import { toDisposable } from '../util/disposable.js';
+/**
+ * A typed lookup table, not a dependency-injection container. No lifecycles,
+ * no scoping rules, no auto-wiring - a child falls back to its parent and that
+ * is the whole of it.
+ */
+export class Services {
+    parent;
+    values = new Map();
+    factories = new Map();
+    constructor(parent = null) {
+        this.parent = parent;
+    }
+    provide(key, value) {
+        this.values.set(key.id, value);
+        return toDisposable(() => {
+            // Only if nothing has replaced it since.
+            //
+            // Two providers for one key overlap whenever one mounts before the other
+            // unmounts - which is the ordinary case for anything provided by the
+            // *focused* control, since focus arrives at the new one before it leaves
+            // the old. Deleting unconditionally took the live provider out along
+            // with the stale one, and left the key answering `undefined` while
+            // something was still very much providing it.
+            if (this.values.get(key.id) === value)
+                this.values.delete(key.id);
+        });
+    }
+    provideLazy(key, factory) {
+        this.factories.set(key.id, factory);
+        return toDisposable(() => {
+            this.factories.delete(key.id);
+            this.values.delete(key.id);
+        });
+    }
+    get(key) {
+        if (this.values.has(key.id))
+            return this.values.get(key.id);
+        const factory = this.factories.get(key.id);
+        if (factory) {
+            const value = factory();
+            this.values.set(key.id, value);
+            return value;
+        }
+        return this.parent?.get(key);
+    }
+    require(key) {
+        const value = this.get(key);
+        if (value === undefined) {
+            throw new Error(`[textui] no service provided for "${key.id}"`);
+        }
+        return value;
+    }
+    has(key) {
+        return this.values.has(key.id) || this.factories.has(key.id) || (this.parent?.has(key) ?? false);
+    }
+    child() {
+        return new Services(this);
+    }
+}
+export function createServices(parent) {
+    return new Services(parent ?? null);
+}

package/dist/core/store.d.ts

@@ -0,0 +1,60 @@
+import type { ChangeRecord, CollectionOps, ComputedDefinition, DataProviderDefinition, PathSchema, PersistenceAdapter, ReactiveStore, ScopeName, SubscribeOptions } from '../types/store.js';
+import type { BindingPath } from '../types/graph.js';
+import type { Disposable } from '../types/disposable.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 declare class Store implements ReactiveStore {
+    private root;
+    private subs;
+    private computedByKey;
+    private computedDeps;
+    private providers;
+    private schemas;
+    private persistence;
+    private persistTimers;
+    private batchDepth;
+    private pending;
+    private disposed;
+    /** Thrown-away errors from listeners would hide bugs; collect and report. */
+    onError: (err: unknown, context: string) => void;
+    get<T = unknown>(path: BindingPath): T | undefined;
+    read<T>(path: BindingPath, fallback: T): T;
+    has(path: BindingPath): boolean;
+    private readKey;
+    set(path: BindingPath, value: unknown): void;
+    update<T = unknown>(path: BindingPath, fn: (current: T | undefined) => T): void;
+    patch(path: BindingPath, partial: Record<string, unknown>): void;
+    patchMany(entries: Record<string, unknown>): void;
+    delete(path: BindingPath): void;
+    private writeKey;
+    batch<T>(fn: () => T): T;
+    private enqueue;
+    private flushIfIdle;
+    private notify;
+    private subMatches;
+    subscribe(path: BindingPath, fn: (value: unknown, change: ChangeRecord) => void, options?: SubscribeOptions): Disposable;
+    subscriberCount(scope: ScopeName | string): number;
+    clearScope(scope: ScopeName | string): void;
+    computed<T = unknown>(path: BindingPath, def: ComputedDefinition<T>): Disposable;
+    private recompute;
+    private recomputeDependents;
+    collection<T = unknown>(path: BindingPath): CollectionOps<T>;
+    registerDataProvider(def: DataProviderDefinition): Disposable;
+    listDataProviders(): DataProviderDefinition[];
+    /** A read or subscribe below a provider's namespace is what loads it. */
+    private touchProvider;
+    private loadProvider;
+    private maybeUnloadProvider;
+    registerSchema(schema: PathSchema): Disposable;
+    registerPersistence(adapter: PersistenceAdapter): Disposable;
+    hydrate(): Promise<void>;
+    private schedulePersist;
+    snapshot(scope?: ScopeName | string): Record<string, unknown>;
+    restore(snapshot: Record<string, unknown>): void;
+    dispose(): void;
+}
+export declare function createStore(): Store;
+//# sourceMappingURL=store.d.ts.map

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

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