quilt-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 niko-dellic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# quilt-core
+
+Framework-independent layout JSON, validation, commands, and subscriptions. No DOM or React dependency. MIT licensed; ships ESM, TypeScript declarations, and sources for editor navigation.
+
+## Install
+
+```sh
+npm install quilt-core
+```
+
+Use ESM imports. For local development archives, see [packaging instructions](https://github.com/niko-dellic/quilt/blob/main/docs/packaging.md).
+
+## Use
+
+```ts
+import { createLayout, LayoutStore, validate } from 'quilt-core';
+
+const store = new LayoutStore(
+  createLayout({
+    pane: { id: 'notes', type: 'notes', title: 'Notes' },
+  }),
+);
+const unsubscribe = store.subscribe(({ action, layout }) => {
+  console.log(action, JSON.stringify(layout));
+});
+store.split('main', 'horizontal', { id: 'preview', type: 'preview', title: 'Preview' });
+console.log(validate(store.export())); // []
+unsubscribe();
+store.dispose();
+```
+
+`createLayout()` returns a fresh empty layout. `createLayout({ pane, groupId })` returns a validated clone, activates the supplied pane, and defaults `groupId` to `main`. It preserves IDs and throws `LayoutError` for invalid input. `parseLayout` validates complete JSON; `validate` returns issues without throwing for invalid layout input.
+
+Use ESM imports. Development and verification use Node 24; browser use requires modern JavaScript support including `structuredClone`. This package needs no stylesheet or host element. The `quilt-dom` DOM adapter and `quilt-react` binding provide views. Application data and persistence remain application-owned.
+
+See [API documentation](https://github.com/niko-dellic/quilt/blob/main/docs/api.md) and [migration notes](https://github.com/niko-dellic/quilt/blob/main/docs/migration.md).

package/dist/controller.d.ts

@@ -0,0 +1,66 @@
+import type { AutoCollapse, LayoutStoreOptions, JoinOptions, Axis, Capability, Change, CommandOptions, Group, Layout, Pane, WindowPlacement } from './types.js';
+export declare class LayoutStore {
+    private state;
+    private initial;
+    private listeners;
+    private errors;
+    private disposed;
+    private serial;
+    private closedTabs;
+    private notifying;
+    private pending;
+    private autoCollapse;
+    constructor(input: unknown, options?: LayoutStoreOptions);
+    /** Stable immutable snapshot, suitable for useSyncExternalStore. */
+    getSnapshot: () => Layout;
+    export(): Layout;
+    subscribe: (listener: (event: Change) => void) => (() => void);
+    onError(listener: (error: unknown) => void): () => void;
+    private alive;
+    private report;
+    private commit;
+    private group;
+    private pane;
+    private permit;
+    private id;
+    private replace;
+    private detach;
+    getAutoCollapse(): AutoCollapse;
+    setAutoCollapse(mode: AutoCollapse): void;
+    private tidy;
+    can(paneId: string, capability: Capability): boolean;
+    load(input: unknown): void;
+    reset(): void;
+    setTabDisplay(groupId: string, display: Group['tabDisplay']): void;
+    setTabPlacement(groupId: string, placement: Group['tabPlacement']): void;
+    activate(groupId: string, paneId: string): void;
+    resize(splitId: string, ratio: number, options?: CommandOptions): void;
+    /** Atomically update coupled split ratios without intermediate layouts. */
+    resizeMany(ratios: Record<string, number>, options?: CommandOptions): void;
+    maximize(groupId: string | null): void;
+    add(pane: Pane, groupId: string, options?: CommandOptions): void;
+    updatePane(pane: Pane): void;
+    split(groupId: string, axis: Axis, pane: Pane | null, options?: CommandOptions & {
+        before?: boolean;
+        ratio?: number;
+    }): string;
+    /** Cancel only an unfilled region; never roll back edits made elsewhere. */
+    removeEmptyGroup(groupId: string): void;
+    /** Move to a tab group or to a new split at an edge. */
+    move(paneId: string, groupId: string, position?: 'tab' | 'left' | 'right' | 'top' | 'bottom', index?: number, options?: CommandOptions): void;
+    /** Join the sibling region at this split, retaining its content as tabs. */
+    join(groupId: string, options?: CommandOptions): void;
+    /** Close all docked tabs and remove their region in one atomic command. */
+    closeGroup(groupId: string, options?: CommandOptions): void;
+    /** Join a contiguous row/column range into the receiver, including both endpoints. */
+    joinRegions(receiverId: string, otherId: string, options?: JoinOptions): void;
+    close(paneId: string, options?: CommandOptions): void;
+    canRestoreClosedTab(): boolean;
+    /** Restore the latest closed tab without undoing unrelated layout changes. */
+    restoreClosedTab(): void;
+    private dockPane;
+    popout(paneId: string, placement?: WindowPlacement, options?: CommandOptions): void;
+    returnPane(paneId: string): void;
+    dispose(): void;
+}
+//# sourceMappingURL=controller.d.ts.map

package/dist/controller.d.ts.map

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

package/dist/controller.js

@@ -0,0 +1,526 @@
+import { joinRange } from './join.js';
+import { findNode, findParent, groups, paneIds, parseLayout, validate } from './model.js';
+import { LayoutError } from './types.js';
+const freeze = (value) => {
+    if (value && typeof value === 'object') {
+        Object.freeze(value);
+        Object.values(value).forEach(freeze);
+    }
+    return value;
+};
+function problem(message) {
+    throw new LayoutError([{ path: 'command', message }]);
+}
+export class LayoutStore {
+    state;
+    initial;
+    listeners = new Set();
+    errors = new Set();
+    disposed = false;
+    serial = 0;
+    closedTabs = [];
+    notifying = false;
+    pending = [];
+    autoCollapse = 'disabled';
+    constructor(input, options = {}) {
+        this.setAutoCollapse(options.autoCollapse ?? 'disabled');
+        this.state = freeze(parseLayout(input));
+        this.initial = this.export();
+    }
+    /** Stable immutable snapshot, suitable for useSyncExternalStore. */
+    getSnapshot = () => this.state;
+    export() {
+        return structuredClone(this.state);
+    }
+    subscribe = (listener) => {
+        this.alive();
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    };
+    onError(listener) {
+        this.errors.add(listener);
+        return () => {
+            this.errors.delete(listener);
+        };
+    }
+    alive() {
+        if (this.disposed)
+            problem('Store has been disposed');
+    }
+    report(error) {
+        for (const listener of this.errors) {
+            try {
+                listener(error);
+            }
+            catch {
+                /* A reporting callback cannot invalidate a committed layout. */
+            }
+        }
+    }
+    commit(action, mutate) {
+        this.alive();
+        let next;
+        try {
+            next = this.export();
+            mutate(next);
+            next = parseLayout(next);
+        }
+        catch (error) {
+            this.report(error);
+            throw error;
+        }
+        // Update session history only after validation, before notifying subscribers.
+        if (action === 'load')
+            this.closedTabs = [];
+        if (action === 'close' || action === 'closeGroup') {
+            for (const pane of Object.values(this.state.panes)) {
+                if (Object.hasOwn(next.panes, pane.id))
+                    continue;
+                const group = groups(this.state.root).find((g) => g.panes.includes(pane.id));
+                const detached = this.state.popouts.find((p) => p.paneId === pane.id);
+                this.closedTabs.push({
+                    pane: structuredClone(pane),
+                    groupId: group?.id ?? detached.groupId,
+                    index: group ? group.panes.indexOf(pane.id) : detached.index,
+                });
+            }
+            this.closedTabs = this.closedTabs.slice(-50);
+        }
+        if (action === 'restoreClosedTab') {
+            this.closedTabs = this.closedTabs.filter((entry) => !Object.hasOwn(next.panes, entry.pane.id));
+        }
+        this.state = freeze(next);
+        this.pending.push({ action, layout: this.state });
+        if (this.notifying)
+            return;
+        this.notifying = true;
+        try {
+            while (this.pending.length) {
+                const event = this.pending.shift();
+                for (const listener of [...this.listeners]) {
+                    if (!this.listeners.has(listener))
+                        continue;
+                    try {
+                        listener(event);
+                    }
+                    catch (error) {
+                        this.report(error);
+                    }
+                }
+            }
+        }
+        finally {
+            this.notifying = false;
+        }
+    }
+    group(draft, id) {
+        const n = findNode(draft.root, id);
+        if (n?.kind !== 'group')
+            problem('Group not found: ' + id);
+        return n;
+    }
+    pane(draft, id) {
+        if (!Object.hasOwn(draft.panes, id))
+            problem('Pane not found: ' + id);
+        return draft.panes[id];
+    }
+    permit(draft, ids, cap, options) {
+        for (const id of ids)
+            if (options.source === 'user' && this.pane(draft, id).capabilities?.[cap] === false)
+                problem(`${cap} is disabled for ${id}`);
+    }
+    id(draft) {
+        let id;
+        do {
+            id = `layout-${++this.serial}`;
+        } while (findNode(draft.root, id));
+        return id;
+    }
+    replace(draft, old, next) {
+        const parent = findParent(draft.root, old.id);
+        if (parent)
+            parent.children[parent.children[0].id === old.id ? 0 : 1] = next;
+        else
+            draft.root = next;
+    }
+    detach(draft, id) {
+        const g = groups(draft.root).find((n) => n.panes.includes(id));
+        if (!g)
+            problem('Pane is not docked: ' + id);
+        const at = g.panes.indexOf(id);
+        g.panes.splice(at, 1);
+        if (g.active === id)
+            g.active = g.panes[Math.min(at, g.panes.length - 1)] ?? null;
+        return g;
+    }
+    getAutoCollapse() {
+        return this.autoCollapse;
+    }
+    setAutoCollapse(mode) {
+        this.alive();
+        if (!['enabled', 'protected', 'disabled'].includes(mode))
+            problem('Invalid autoCollapse mode');
+        this.autoCollapse = mode;
+    }
+    tidy(draft, source, popout = false) {
+        if (source &&
+            !source.panes.length &&
+            this.autoCollapse !== 'disabled' &&
+            (!popout || this.autoCollapse === 'enabled')) {
+            const parent = findParent(draft.root, source.id);
+            if (parent)
+                this.replace(draft, parent, parent.children[parent.children[0].id === source.id ? 1 : 0]);
+        }
+        if (draft.maximized && !findNode(draft.root, draft.maximized))
+            draft.maximized = null;
+    }
+    can(paneId, capability) {
+        return (Boolean(this.state.panes[paneId]) &&
+            this.state.panes[paneId].capabilities?.[capability] !== false);
+    }
+    load(input) {
+        this.commit('load', (draft) => {
+            const next = parseLayout(input);
+            for (const key of Object.keys(draft))
+                Reflect.deleteProperty(draft, key);
+            Object.assign(draft, next);
+        });
+    }
+    reset() {
+        this.load(this.initial);
+    }
+    setTabDisplay(groupId, display) {
+        this.commit('setTabDisplay', (draft) => {
+            const group = findNode(draft.root, groupId);
+            if (!group || group.kind !== 'group')
+                problem('Expected a group id');
+            if (display === undefined)
+                delete group.tabDisplay;
+            else
+                group.tabDisplay = display;
+        });
+    }
+    setTabPlacement(groupId, placement) {
+        this.commit('setTabPlacement', (draft) => {
+            const group = findNode(draft.root, groupId);
+            if (!group || group.kind !== 'group')
+                problem('Expected a group id');
+            if (placement === undefined)
+                delete group.tabPlacement;
+            else
+                group.tabPlacement = placement;
+        });
+    }
+    activate(groupId, paneId) {
+        this.commit('activate', (d) => {
+            const g = this.group(d, groupId);
+            if (!g.panes.includes(paneId))
+                problem('Tab does not belong to group');
+            g.active = paneId;
+        });
+    }
+    resize(splitId, ratio, options = {}) {
+        this.commit('resize', (d) => {
+            const n = findNode(d.root, splitId);
+            if (n?.kind !== 'split')
+                problem('Split not found');
+            this.permit(d, paneIds(n), 'resize', options);
+            n.ratio = ratio;
+        });
+    }
+    /** Atomically update coupled split ratios without intermediate layouts. */
+    resizeMany(ratios, options = {}) {
+        this.commit('resize', (d) => {
+            for (const [id, ratio] of Object.entries(ratios)) {
+                const node = findNode(d.root, id);
+                if (node?.kind !== 'split')
+                    problem('Split not found');
+                this.permit(d, paneIds(node), 'resize', options);
+                node.ratio = ratio;
+            }
+        });
+    }
+    maximize(groupId) {
+        this.commit('maximize', (d) => {
+            if (groupId)
+                this.group(d, groupId);
+            d.maximized = groupId;
+        });
+    }
+    add(pane, groupId, options = {}) {
+        this.commit('add', (d) => {
+            const g = this.group(d, groupId);
+            this.permit(d, g.panes, 'move', options);
+            if (Object.hasOwn(d.panes, pane.id))
+                problem('Pane id already exists');
+            Object.defineProperty(d.panes, pane.id, {
+                value: structuredClone(pane),
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+            g.panes.push(pane.id);
+            g.active = pane.id;
+        });
+    }
+    updatePane(pane) {
+        this.commit('updatePane', (d) => {
+            this.pane(d, pane.id);
+            d.panes[pane.id] = structuredClone(pane);
+        });
+    }
+    split(groupId, axis, pane, options = {}) {
+        let created = '';
+        this.commit('split', (d) => {
+            const g = this.group(d, groupId);
+            this.permit(d, g.panes, 'split', options);
+            if (pane) {
+                if (Object.hasOwn(d.panes, pane.id))
+                    problem('Pane id already exists');
+                Object.defineProperty(d.panes, pane.id, {
+                    value: structuredClone(pane),
+                    enumerable: true,
+                    writable: true,
+                    configurable: true,
+                });
+            }
+            const group = {
+                kind: 'group',
+                id: this.id(d),
+                panes: pane ? [pane.id] : [],
+                active: pane?.id ?? null,
+            };
+            created = group.id;
+            this.replace(d, g, {
+                kind: 'split',
+                id: this.id(d),
+                axis,
+                ratio: options.ratio ?? 0.5,
+                children: options.before ? [group, g] : [g, group],
+            });
+        });
+        return created;
+    }
+    /** Cancel only an unfilled region; never roll back edits made elsewhere. */
+    removeEmptyGroup(groupId) {
+        const existing = findNode(this.state.root, groupId);
+        if (existing?.kind !== 'group' ||
+            existing.panes.length ||
+            !findParent(this.state.root, groupId))
+            return;
+        this.commit('removeEmptyGroup', (d) => {
+            if (d.maximized === groupId)
+                d.maximized = null;
+            const parent = findParent(d.root, groupId);
+            this.replace(d, parent, parent.children[parent.children[0].id === groupId ? 1 : 0]);
+        });
+    }
+    /** Move to a tab group or to a new split at an edge. */
+    move(paneId, groupId, position = 'tab', index, options = {}) {
+        this.commit('move', (d) => {
+            const target = this.group(d, groupId);
+            const source = groups(d.root).find((g) => g.panes.includes(paneId));
+            if (!source)
+                problem('Return a popped-out pane before moving it');
+            this.permit(d, [paneId, ...target.panes], 'move', options);
+            if (position !== 'tab')
+                this.permit(d, target.panes, 'split', options);
+            if (source === target && target.panes.length === 1)
+                return;
+            this.detach(d, paneId);
+            if (position === 'tab') {
+                target.panes.splice(Math.max(0, Math.min(index ?? target.panes.length, target.panes.length)), 0, paneId);
+                target.active = paneId;
+            }
+            else {
+                const g = { kind: 'group', id: this.id(d), panes: [paneId], active: paneId };
+                const before = position === 'left' || position === 'top';
+                this.replace(d, target, {
+                    kind: 'split',
+                    id: this.id(d),
+                    axis: position === 'left' || position === 'right' ? 'horizontal' : 'vertical',
+                    ratio: 0.5,
+                    children: before ? [g, target] : [target, g],
+                });
+            }
+            this.tidy(d, source);
+        });
+    }
+    /** Join the sibling region at this split, retaining its content as tabs. */
+    join(groupId, options = {}) {
+        this.commit('join', (d) => {
+            const g = this.group(d, groupId), parent = findParent(d.root, groupId);
+            if (!parent)
+                return;
+            this.permit(d, paneIds(parent), 'join', options);
+            g.panes = paneIds(parent);
+            g.active ??= g.panes[0] ?? null;
+            this.replace(d, parent, g);
+            this.tidy(d);
+        });
+    }
+    /** Close all docked tabs and remove their region in one atomic command. */
+    closeGroup(groupId, options = {}) {
+        this.commit('closeGroup', (d) => {
+            const group = this.group(d, groupId);
+            this.permit(d, group.panes, 'close', options);
+            for (const id of group.panes)
+                delete d.panes[id];
+            group.panes = [];
+            group.active = null;
+            if (d.maximized === groupId)
+                d.maximized = null;
+            const parent = findParent(d.root, groupId);
+            if (parent)
+                this.replace(d, parent, parent.children[parent.children[0].id === groupId ? 1 : 0]);
+        });
+    }
+    /** Join a contiguous row/column range into the receiver, including both endpoints. */
+    joinRegions(receiverId, otherId, options = {}) {
+        this.commit('join', (d) => {
+            const receiver = this.group(d, receiverId);
+            const range = joinRange(d.root, receiverId, otherId);
+            if (!range)
+                problem('Join requires contiguous regions in one row or column');
+            const { row, regions, boundaries, start, end, selected } = range;
+            const panes = selected.flatMap((g) => g.panes);
+            this.permit(d, panes, 'join', options);
+            let sizes = range.weights;
+            let gaps = boundaries.map(() => 0);
+            if (options.extents) {
+                const extent = (node) => {
+                    const value = options.extents[node.id];
+                    if (value === undefined || !Number.isFinite(value) || value <= 0)
+                        problem('Join extents must include a positive finite size for every node in the row');
+                    return value;
+                };
+                sizes = regions.map(extent);
+                gaps = boundaries.map((split) => {
+                    const gap = extent(split) - extent(split.children[0]) - extent(split.children[1]);
+                    if (gap < -0.5)
+                        problem('Join extents must describe a non-overlapping row');
+                    return Math.max(0, gap);
+                });
+            }
+            receiver.panes = panes;
+            receiver.active ??= panes[0] ?? null;
+            const combined = sizes.slice(start, end + 1).reduce((a, b) => a + b, 0) +
+                gaps.slice(start, end).reduce((a, b) => a + b, 0);
+            const remaining = [...regions.slice(0, start), receiver, ...regions.slice(end + 1)];
+            const lengths = [...sizes.slice(0, start), combined, ...sizes.slice(end + 1)];
+            const dividers = [...boundaries.slice(0, start), ...boundaries.slice(end)];
+            const remainingGaps = [...gaps.slice(0, start), ...gaps.slice(end)];
+            // Reuse the surviving boundary IDs and their settings. Removed boundaries alone disappear.
+            let replacement = remaining[remaining.length - 1];
+            let length = lengths[lengths.length - 1];
+            for (let i = remaining.length - 2; i >= 0; i--) {
+                const first = lengths[i];
+                replacement = {
+                    ...dividers[i],
+                    ratio: first / (first + length),
+                    children: [remaining[i], replacement],
+                };
+                length += first + remainingGaps[i];
+            }
+            this.replace(d, row, replacement);
+            if (selected.some((g) => g.id === d.maximized))
+                d.maximized = receiver.id;
+            this.tidy(d);
+        });
+    }
+    close(paneId, options = {}) {
+        this.commit('close', (d) => {
+            this.permit(d, [paneId], 'close', options);
+            this.pane(d, paneId);
+            let source;
+            if (d.popouts.some((p) => p.paneId === paneId))
+                d.popouts = d.popouts.filter((p) => p.paneId !== paneId);
+            else
+                source = this.detach(d, paneId);
+            delete d.panes[paneId];
+            this.tidy(d, source);
+        });
+    }
+    canRestoreClosedTab() {
+        return this.closedTabs.some((entry) => !Object.hasOwn(this.state.panes, entry.pane.id));
+    }
+    /** Restore the latest closed tab without undoing unrelated layout changes. */
+    restoreClosedTab() {
+        this.alive();
+        const entry = [...this.closedTabs]
+            .reverse()
+            .find((item) => !Object.hasOwn(this.state.panes, item.pane.id));
+        if (!entry)
+            return;
+        this.commit('restoreClosedTab', (d) => {
+            Object.defineProperty(d.panes, entry.pane.id, {
+                value: structuredClone(entry.pane),
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+            this.dockPane(d, entry.pane.id, entry.groupId, entry.index);
+        });
+    }
+    dockPane(d, paneId, groupId, index) {
+        const preferred = findNode(d.root, groupId);
+        d.maximized = null;
+        const candidates = [
+            ...(preferred?.kind === 'group' ? [preferred] : []),
+            ...groups(d.root).filter((g) => g.id !== groupId && g.panes.every((id) => d.panes[id].header !== false)),
+        ];
+        for (const target of candidates) {
+            const previousActive = target.active;
+            target.panes.splice(Math.min(index, target.panes.length), 0, paneId);
+            target.active = paneId;
+            if (!validate(d).length)
+                return;
+            target.panes.splice(target.panes.indexOf(paneId), 1);
+            target.active = previousActive;
+        }
+        const g = { kind: 'group', id: this.id(d), panes: [paneId], active: paneId };
+        d.root = {
+            kind: 'split',
+            id: this.id(d),
+            axis: 'horizontal',
+            ratio: 0.7,
+            children: [d.root, g],
+        };
+    }
+    popout(paneId, placement, options = {}) {
+        this.commit('popout', (d) => {
+            this.permit(d, [paneId], 'popout', options);
+            const group = groups(d.root).find((g) => g.panes.includes(paneId));
+            if (!group)
+                problem('Pane is not docked');
+            const entry = {
+                paneId,
+                groupId: group.id,
+                index: group.panes.indexOf(paneId),
+                ...(placement ? { placement } : {}),
+            };
+            this.detach(d, paneId);
+            d.popouts.push(entry);
+            this.tidy(d, group, true);
+        });
+    }
+    returnPane(paneId) {
+        this.commit('return', (d) => {
+            const entry = d.popouts.find((p) => p.paneId === paneId);
+            if (!entry)
+                return;
+            d.popouts = d.popouts.filter((p) => p.paneId !== paneId);
+            this.dockPane(d, paneId, entry.groupId, entry.index);
+        });
+    }
+    dispose() {
+        this.closedTabs = [];
+        this.listeners.clear();
+        this.errors.clear();
+        this.pending = [];
+        this.disposed = true;
+    }
+}
+//# sourceMappingURL=controller.js.map