vintage-frames 0.19.1 → 0.20.0

package/dist/shell/shell.d.ts

@@ -1,177 +0,0 @@
-/**
- * The shell: applications over one desktop.
- *
- * - The menu bar holds the system menu — the page's own first menu, the
- *   Apple menu — then the front application's menus, then the clock in the
- *   bar's `end` slot. Each application's menus are parsed once and the same
- *   nodes come back each time it is front, so items keep their state. A menu
- *   off the bar has no key equivalents, so only the front application's fire.
- *   The bar's label is the front application's name.
- * - The system menu is the page's own items, then what Apple Menu Items
- *   holds, by name, following the folder as it changes. Choosing an entry
- *   opens its item as a double-click would. No application adds to it.
- * - While an application's held dialog is open, the bar shows that
- *   application's name and menus instead; nothing else changes.
- * - Each application's `init(ctx)` gets the desktop, the window manager, its
- *   own menus, dialogs and window markup, the other applications' actions
- *   (read at the call), the catalog when a Finder runs, the site's services,
- *   `ask()`, `gate()`, `onFront()` and `onDispose()`. Everything it sets up
- *   comes down through `onDispose()`, and its dialogs with it, so a hot
- *   reload starts clean. The shell composes no UI of its own.
- * - A window showing a catalog item follows it: its title follows a rename,
- *   and it closes when the item is removed.
- * - The boot waits for the desktop and its menu bar to render, reads the
- *   catalog, seeds it once, reopens the last session's windows deepest
- *   first and the active one last, opens what Startup Items holds, then
- *   starts saving.
- */
-import { VfWindow } from '../index.js';
-import type { VfDesktop, VfDialog, VfMenu, VfMenuItem, VfModalDialog, VfViewportBox } from '../index.js';
-import type { Catalog, CatalogStorage, Item, SystemFolders, Volumes } from './catalog.js';
-import type { WindowManager } from './windows.js';
-import type { ShellState } from './state.js';
-/** A kind of catalog item an application registers: how it looks and opens. */
-export interface KindDefinition {
-    /** Its 32×32 art: one URL, or one per item. */
-    art: string | ((item: Item) => string);
-    /** Open the item, its window out of `from` (its icon's box). */
-    open(item: Item, from: VfViewportBox | null): void;
-    /** Renameable in place. Default true. */
-    editable?: boolean;
-    /** Bytes, for Empty Trash's alert. */
-    size?(item: Item): number;
-    /** Copy `from`'s payload to `to` when the Finder copies the item. */
-    copy?(from: Item, to: Item): void | Promise<void>;
-    /** Empty Trash removed the item: drop its payload. */
-    onRemove?(item: Item): void | Promise<void>;
-    /** Make an item of a pasted or dropped file in `parent`; resolves whether it did. */
-    claim?(file: Blob, parent: string | null): Promise<boolean>;
-    /** The item on the system clipboard, as a file. */
-    export?(item: Item): Promise<Blob | null>;
-}
-/** The catalog a Finder brings: where it is stored, its volumes, its System Folder and its seed. */
-export interface CatalogSetup {
-    storage: CatalogStorage | null;
-    volumes?: Volumes;
-    /** The System Folder, named; its folders drive the Apple menu and what opens at startup. */
-    system?: SystemFolders;
-    /** Run once per storage, to store the site's defaults. */
-    seed?: (catalog: Catalog) => void | Promise<void>;
-}
-/** One application. */
-export interface AppDefinition<Actions = unknown> {
-    id: string;
-    /** The bar's accessible name while it is front. */
-    name: string;
-    /** Its 32×32 art, for the Finder's icon of it. */
-    icon?: string;
-    /** A fragment of `vf-menu` elements, each with a `data-menu` name. */
-    menus?: string;
-    /**
-     * A fragment of dialogs, each with a `data-dialog` name: a `vf-dialog`, or
-     * an element that renders one inside itself. Held under the application.
-     */
-    dialogs?: string;
-    /**
-     * A fragment of windows, each with a `data-window` name, kept inert:
-     * `ctx.window(name)` makes a fresh copy of one on each call.
-     */
-    windows?: string;
-    /** The catalog kinds it opens. */
-    kinds?: Record<string, KindDefinition>;
-    /** The Finder's: the catalog every application shares. */
-    catalog?: CatalogSetup;
-    /**
-     * Set everything up and return what other applications may call. An
-     * application that reopens windows across a reload — or opens from an
-     * icon — provides `open({ item, from })`.
-     */
-    init(ctx: AppContext): Actions | void;
-}
-/** What an application's `init` gets. */
-export interface AppContext {
-    readonly desktop: VfDesktop;
-    readonly windows: WindowManager;
-    /** Its own menus, parsed from `menus`. */
-    readonly menus: VfMenu[];
-    /** Every application's actions by id, read at the call. */
-    readonly apps: Record<string, any>;
-    /** The catalog, when a Finder runs; read before the boot has refreshed it, it lists the kept containers alone. */
-    readonly catalog: Catalog | null;
-    /** The site's own services. */
-    readonly services: Record<string, any>;
-    /** The saved session, or null. */
-    readonly state: ShellState | null;
-    /** Every kind the applications register, the shell's `app` and `alias` kinds included, in registration order. */
-    readonly kinds: ReadonlyMap<string, KindDefinition>;
-    /** A kind's definition, or undefined. */
-    kind(kind: string): KindDefinition | undefined;
-    /** The application definition with `id`. */
-    app(id: string): AppDefinition | undefined;
-    /** One of its menus by `data-menu`; throws when the markup drifts. */
-    menu(name: string): VfMenu;
-    /** One of its menu items by `value`; throws when the markup drifts. */
-    item(value: string): VfMenuItem;
-    /** Every pick from its menus — never while a modal is open. */
-    onMenu(fn: (value: string, item: VfMenuItem) => void): void;
-    /** One of its dialogs by `data-dialog`; throws when the markup drifts. */
-    dialog<T extends HTMLElement = VfDialog>(name: string): T;
-    /**
-     * A fresh copy of one of its windows by `data-window`, upgraded and not yet
-     * appended: `open({ create: () => ctx.window('viewer') })`. Throws when the
-     * markup drifts.
-     */
-    window<T extends HTMLElement = VfWindow>(name: string): T;
-    /** Hold a dialog it made in code: appended to the desktop, held under it, removed with it. Returns it. */
-    hold<T extends Element>(dialog: T): T;
-    /** Let a dialog it holds go, and remove it. */
-    release(dialog: Element): void;
-    /**
-     * Show a dialog it holds, and resolve its `returnValue`: the value of the
-     * button that submitted it, or null when it closed without one. Throws for
-     * a dialog it doesn't hold.
-     */
-    ask(dialog: VfModalDialog): Promise<string | null>;
-    /** Keep `item` disabled while `test` is false: re-run on every press, key, selection change and activation. */
-    gate(item: VfMenuItem, test: () => boolean): void;
-    /** Whether a text field has keyboard focus, read through shadow roots at the call. */
-    typing(): boolean;
-    /** Whether a modal dialog is open. */
-    modalOpen(): boolean;
-    /** Follow whether this application is front; called at once with the current state. */
-    onFront(fn: (front: boolean) => void): void;
-    /** A listener torn down with the application. */
-    on(target: EventTarget, type: string, fn: (e: Event) => void, options?: boolean | AddEventListenerOptions): void;
-    /** Run `fn` when the shell is disposed. */
-    onDispose(fn: () => void): void;
-}
-/** Declare an application, with its actions' type. */
-export declare function defineApp<Actions>(definition: AppDefinition<Actions>): AppDefinition<Actions>;
-export interface ShellOptions {
-    /** The applications; the first with a `catalog` is the Finder. */
-    apps: AppDefinition<any>[];
-    /** The application front while no window is active. Default the Finder, else the first. */
-    defaultApp?: string;
-    /** `'viewport'` sizes the desktop to the viewport on every resize and scale change. */
-    fit?: 'viewport' | false;
-    /** Where the session is saved; null keeps nothing, so a reload resets. */
-    state?: ShellState | null;
-    /** The site's own services, handed to every application. */
-    services?: Record<string, unknown>;
-    /** The clock in the menu bar's `end` slot. Default true. */
-    clock?: boolean;
-    /** Open what Startup Items holds once the session is back. Default true; false skips it for this boot. */
-    startup?: boolean;
-}
-/** A running shell. */
-export interface Shell {
-    readonly desktop: VfDesktop;
-    readonly windows: WindowManager;
-    readonly catalog: Catalog | null;
-    readonly apps: Record<string, any>;
-    /** Settles once the boot has read the catalog and reopened the session. */
-    readonly ready: Promise<void>;
-    dispose(): void;
-}
-/** Start the shell over `desktop`. The page has imported `vintage-frames` first. */
-export declare function createShell(desktop: VfDesktop, options: ShellOptions): Shell;

package/dist/shell/shell.js

@@ -1,277 +0,0 @@
-import { onScaleChange as e } from "../scale.js";
-import { VfWindow as t } from "../components/vf-window.js";
-import "../index.js";
-import { ALIAS_KIND as n, appIdOf as r, appleMenuOf as i, createCatalog as a, resolve as o, startupItemsOf as s } from "./catalog.js";
-import { createWindowManager as c, deepActiveElement as l, desktopRendered as u } from "./windows.js";
-import { openWindowsOf as d } from "./state.js";
-import { startClock as f } from "./clock.js";
-//#region src/shell/shell.ts
-function p(e) {
-	return e;
-}
-var m = (e) => e instanceof HTMLInputElement || e instanceof HTMLTextAreaElement || e?.isContentEditable === !0;
-function h(p, h) {
-	let g = h.apps, _ = g.find((e) => e.catalog), v = h.defaultApp ?? _?.id ?? g[0]?.id ?? "", y = h.state ?? null, b = h.services ?? {}, x = [], S = p.querySelector(":scope > vf-menu-bar");
-	if (!S) throw Error("vintage-frames/shell: the desktop has no vf-menu-bar");
-	let C = S.querySelector(":scope > vf-menu");
-	if (!C) throw Error("vintage-frames/shell: the menu bar has no system menu");
-	S.shortcuts = !0;
-	let w = y?.saved?.pattern;
-	w && (p.pattern = w);
-	let T = null;
-	if (h.fit === "viewport") {
-		let t = () => {
-			let e = {
-				width: p.width,
-				height: p.height
-			};
-			p.fitWithin(document.documentElement.clientWidth, document.documentElement.clientHeight), T?.resized(e);
-		};
-		t(), window.addEventListener("resize", t);
-		let n = e(t);
-		x.push(() => {
-			window.removeEventListener("resize", t), n();
-		});
-	}
-	let E = c(p, {
-		defaultApp: v,
-		savedPin: (e) => y?.pin(e) ?? null
-	});
-	T = E;
-	let D = (e) => {
-		e.target === p && p.clearActive();
-	};
-	p.addEventListener("pointerdown", D), x.push(() => p.removeEventListener("pointerdown", D));
-	let O = {}, k = (e, t = null) => O[_?.id ?? ""]?.open?.({
-		item: e,
-		from: t
-	}), A = /* @__PURE__ */ new Map();
-	A.set("app", {
-		art: (e) => g.find((t) => t.id === r(e))?.icon ?? "",
-		open: (e, t) => void O[r(e) ?? ""]?.open?.({ from: t }),
-		editable: !1
-	}), A.set(n, {
-		art: (e) => {
-			let t = j && o(j.get(), e.id), n = t && A.get(t.kind);
-			return !t || !n ? "" : typeof n.art == "function" ? n.art(t) : n.art;
-		},
-		open: (e, t) => void k(e.id, t)
-	});
-	for (let e of g) for (let [t, n] of Object.entries(e.kinds ?? {})) A.set(t, n);
-	let j = _?.catalog ? a({
-		storage: _.catalog.storage,
-		volumes: _.catalog.volumes,
-		system: _.catalog.system,
-		listed: (e) => A.has(e),
-		hooks: (e) => A.get(e)
-	}) : null, M = () => !!document.querySelector("vf-dialog[open]"), N = () => m(l()), P = /* @__PURE__ */ new Map(), F = () => {
-		for (let [e, t] of P) {
-			let n = !t();
-			e.disabled !== n && (e.disabled = n);
-		}
-	};
-	document.addEventListener("pointerdown", F, !0), document.addEventListener("keydown", F, !0), p.addEventListener("vf-select", F), p.addEventListener("vf-activate", F), x.push(() => document.removeEventListener("pointerdown", F, !0), () => document.removeEventListener("keydown", F, !0), () => p.removeEventListener("vf-select", F), () => p.removeEventListener("vf-activate", F), E.onWindows(F), E.onLayout(F)), j && x.push(j.subscribe(F));
-	let I = (e) => {
-		if (!e) return [];
-		let t = document.createElement("div");
-		t.innerHTML = e, customElements.upgrade(t);
-		let n = [...t.children].filter((e) => e instanceof HTMLElement);
-		for (let e of n) e.remove();
-		return n;
-	}, L = g.map((e) => ({
-		def: e,
-		menus: I(e.menus).filter((e) => e.localName === "vf-menu"),
-		dialogs: I(e.dialogs).filter((e) => e.dataset.dialog != null),
-		windows: (() => {
-			let t = document.createElement("template");
-			return t.innerHTML = e.windows ?? "", t.content;
-		})()
-	})), R = [];
-	for (let { def: e, menus: t, dialogs: n, windows: r } of L) {
-		let i = [], a = `vintage-frames/shell (${e.id})`, o = /* @__PURE__ */ new Set();
-		for (let t of n) E.holdDialog(t, { app: e.id }), o.add(t);
-		i.push(() => {
-			for (let e of o) E.releaseDialog(e), e.remove();
-			o.clear();
-		});
-		let s = {
-			desktop: p,
-			windows: E,
-			menus: t,
-			apps: O,
-			catalog: j,
-			services: b,
-			state: y,
-			kinds: A,
-			kind: (e) => A.get(e),
-			app: (e) => g.find((t) => t.id === e),
-			menu(e) {
-				let n = t.find((t) => t.dataset.menu === e);
-				if (!n) throw Error(`${a}: missing menu ${e}`);
-				return n;
-			},
-			item(e) {
-				for (let n of t) {
-					let t = n.querySelector(`vf-menu-item[value="${CSS.escape(e)}"]`);
-					if (t) return t;
-				}
-				throw Error(`${a}: missing menu item ${e}`);
-			},
-			onMenu(e) {
-				for (let n of t) s.on(n, "vf-menu-select", (t) => {
-					if (M()) return;
-					let { value: n, item: r } = t.detail;
-					e(n, r);
-				});
-			},
-			dialog(e) {
-				let t = n.find((t) => t.dataset.dialog === e);
-				if (!t) throw Error(`${a}: missing dialog ${e}`);
-				return t;
-			},
-			window(e) {
-				let t = [...r.children].find((t) => t.dataset.window === e);
-				if (!t) throw Error(`${a}: missing window ${e}`);
-				let n = document.importNode(t, !0);
-				return customElements.upgrade(n), n;
-			},
-			hold(t) {
-				return E.holdDialog(t, { app: e.id }), o.add(t), t;
-			},
-			release(e) {
-				o.delete(e) && (E.releaseDialog(e), e.remove());
-			},
-			ask(t) {
-				if (E.appOf(t) !== e.id) throw Error(`${a}: ask() takes a dialog the application holds`);
-				return new Promise((e) => {
-					let n = (r) => {
-						r.target === t && (t.removeEventListener("vf-close", n), e(r.detail.returnValue));
-					};
-					t.show(), t.addEventListener("vf-close", n);
-				});
-			},
-			gate(e, t) {
-				P.set(e, t), i.push(() => P.delete(e));
-				let n = !t();
-				e.disabled !== n && (e.disabled = n);
-			},
-			typing: N,
-			modalOpen: M,
-			onFront(t) {
-				t(E.front === e.id), i.push(E.onFront((n) => t(n === e.id)));
-			},
-			on(e, t, n, r) {
-				e.addEventListener(t, n, r), i.push(() => e.removeEventListener(t, n, r));
-			},
-			onDispose(e) {
-				i.push(e);
-			}
-		}, c = e.init(s);
-		c && (O[e.id] = c), R.push(() => {
-			for (let e of i.splice(0).reverse()) e();
-		});
-	}
-	let z = null, B = () => {
-		let e = E.asking ?? E.front, t = L.find((t) => t.def.id === e) ?? L.find((e) => e.def.id === v) ?? null;
-		if (!(!t || t === z)) {
-			if (z) for (let e of z.menus) e.remove();
-			C.after(...t.menus), S.label = t.def.name, z = t, F();
-		}
-	};
-	x.push(E.onFront(B), E.onDialogs(B)), B();
-	let V = /* @__PURE__ */ new Map(), H = [], U = "", W = (e) => e.map((e) => e.entries ? `${e.item.id}(${W(e.entries)})` : e.item.id).join(","), G = (e) => e.flatMap((e) => [e.item, ...e.entries ? G(e.entries) : []]), K = (e, t) => {
-		for (let { item: n, entries: r } of e) {
-			let e = document.createElement("vf-menu-item");
-			if (e.setAttribute("value", n.id), e.append(n.name), t.append(e), V.set(e, n.id), H.push(e), r) {
-				let t = document.createElement("vf-menu");
-				t.slot = "submenu", e.append(t), K(r, t);
-			}
-		}
-	}, q = () => {
-		let e = j ? i(j.get()) : [], t = W(e);
-		if (t === U) {
-			G(e).forEach((e, t) => {
-				let n = H[t];
-				n.labelText !== e.name && n.firstChild.replaceWith(e.name);
-			});
-			return;
-		}
-		for (let [e] of V) e.remove();
-		V.clear(), H = [], U = t, K(e, C);
-	}, J = (e) => {
-		let t = V.get(e.detail.item);
-		t != null && !M() && k(t);
-	};
-	if (C.addEventListener("vf-menu-select", J), x.push(() => {
-		C.removeEventListener("vf-menu-select", J);
-		for (let [e] of V) e.remove();
-		V.clear();
-	}), j && x.push(j.subscribe(q)), h.clock !== !1) {
-		let e = S.querySelector(":scope > [slot=\"end\"]"), t = !e;
-		e || (e = document.createElement("vf-label"), e.slot = "end", S.append(e));
-		let n = f(e);
-		x.push(() => {
-			n(), t && e.remove();
-		});
-	}
-	let Y = /* @__PURE__ */ new WeakSet(), X = () => {
-		if (j) for (let e of p.stackingOrder) {
-			if (!(e instanceof t)) continue;
-			let n = E.itemOf(e);
-			if (n == null) continue;
-			let r = j.item(n);
-			r ? (Y.add(e), e.heading !== r.name && (e.heading = r.name)) : Y.has(e) && j.get().available && E.close(e, { to: null });
-		}
-	};
-	return j && x.push(j.subscribe(X), E.onWindows(X)), y?.hold(), {
-		desktop: p,
-		windows: E,
-		catalog: j,
-		apps: O,
-		ready: (async () => {
-			try {
-				await u(p), j && (await j.refresh(), _?.catalog?.seed && await j.seed(_.catalog.seed));
-				for (let { item: e, app: t } of d(y?.saved ?? null)) await O[t]?.open?.({ item: e });
-				let e = y?.saved?.active;
-				if (e) {
-					let t = E.windowFor(e);
-					t && p.bringToFront(t);
-				}
-				if (j && h.startup !== !1) for (let e of s(j.get())) await k(e.id);
-			} finally {
-				if (y) {
-					let e = y.start(() => ({
-						windows: E.snapshot(),
-						active: E.itemOf(p.activeWindow),
-						pattern: p.pattern ?? null
-					}), (e) => {
-						let t = [
-							E.onLayout(e),
-							E.onWindows(e),
-							...j ? [j.subscribe(e)] : []
-						];
-						p.addEventListener("vf-activate", e);
-						let n = new MutationObserver(e);
-						return n.observe(p, {
-							attributes: !0,
-							attributeFilter: ["pattern"]
-						}), () => {
-							for (let e of t) e();
-							p.removeEventListener("vf-activate", e), n.disconnect();
-						};
-					});
-					x.push(e), y.release();
-				}
-			}
-		})(),
-		dispose() {
-			for (let e of R.splice(0).reverse()) e();
-			if (z) for (let e of z.menus) e.remove();
-			z = null;
-			for (let e of x.splice(0)) e();
-			E.dispose(), j?.dispose();
-		}
-	};
-}
-//#endregion
-export { h as createShell, p as defineApp };

package/dist/shell/state.d.ts

@@ -1,88 +0,0 @@
-/**
- * The saved session: one versioned localStorage key holding each window's
- * box as a nine-slice pin and its depth, the active window's item, the
- * desktop pattern, and the site's own keys.
- *
- * - A window entry with a depth (`z`) was open at the write. One without is a
- *   box alone — a palette, or a window closed this session — which a reload
- *   never reopens and an open() still lands in.
- * - Writes wait a moment and are held until the boot has reopened the
- *   session: a write while windows are still reopening would drop the depth
- *   of the ones not reached yet. Hiding or leaving the page writes at once.
- * - `?fresh=1` neither reads nor writes.
- *
- * The parsing is pure, so it is tested under Node; the storage is the page's
- * localStorage, reached only when a state is made.
- */
-import type { Pin } from './geometry.js';
-/** One saved window. */
-export interface SavedWindow {
-    /** The application that owns it, which reopens it. */
-    app: string;
-    pin: Pin;
-    /** Its depth when saved, 0 the bottom; unset for a box alone. */
-    z?: number;
-}
-/** What the session holds. */
-export interface SavedSession {
-    v: number;
-    /** Windows by the item they show. */
-    windows: Record<string, SavedWindow>;
-    /** The active window's item, or null. */
-    active: string | null;
-    /** The desktop pattern, or null for the desktop's own. */
-    pattern: string | null;
-    /** The site's own keys. */
-    extra: Record<string, unknown>;
-}
-/**
- * A parsed blob as a session, its bad entries dropped, or null for anything
- * that isn't one of this version.
- */
-export declare function readSession(parsed: unknown): SavedSession | null;
-/** The windows that were open, deepest first: the order a boot reopens them in. */
-export declare function openWindowsOf(session: SavedSession | null): {
-    item: string;
-    app: string;
-    pin: Pin;
-}[];
-/** What the shell reports at a write: the windows it knows and the active one. */
-export interface SessionSnapshot {
-    windows: Record<string, SavedWindow>;
-    active: string | null;
-    pattern: string | null;
-}
-/**
- * The session to write: every window known before keeps its box and loses
- * its depth, and the snapshot's windows — the open ones with theirs — go
- * over them.
- */
-export declare function mergeSession(known: Record<string, SavedWindow>, snapshot: SessionSnapshot, extra: Record<string, unknown>): SavedSession;
-/** A saved session the shell reads at boot and writes as the desktop changes. */
-export interface ShellState {
-    /** The session read at boot, or null. */
-    readonly saved: SavedSession | null;
-    /** A saved window's pin, by item, or null. */
-    pin(item: string): Pin | null;
-    /** A site key's saved value, else its default. */
-    get<T = unknown>(key: string): T;
-    /** Set a site key and write at once, so an immediate reload still finds it. */
-    set(key: string, value: unknown): void;
-    /** Hold every write until {@link release}. */
-    hold(): void;
-    /** Release the hold and write what is on screen. */
-    release(): void;
-    /**
-     * Start writing: `snapshot` is read at each write, after `subscribe`'s
-     * signal settles. Returns the stop function.
-     */
-    start(snapshot: () => SessionSnapshot, subscribe: (fn: () => void) => () => void): () => void;
-}
-export interface LocalStorageStateOptions {
-    /** The site's own keys and their defaults: `{ greet: true, seeded: false }`. */
-    extra?: Record<string, unknown>;
-    /** Neither read nor write. Default: `?fresh=1` in the address. */
-    fresh?: boolean;
-}
-/** A session kept under one localStorage `key`. */
-export declare function localStorageState(key: string, options?: LocalStorageStateOptions): ShellState;

package/dist/shell/state.js

@@ -1,103 +0,0 @@
-import { isPin as e } from "./geometry.js";
-//#region src/shell/state.ts
-var t = 1, n = 400;
-function r(t) {
-	let n = t;
-	return !n || typeof n != "object" || typeof n.app != "string" || !n.app || !e(n.pin) ? null : Number.isInteger(n.z) ? {
-		app: n.app,
-		pin: n.pin,
-		z: n.z
-	} : {
-		app: n.app,
-		pin: n.pin
-	};
-}
-function i(e) {
-	let n = e;
-	if (!n || typeof n != "object" || n.v !== t) return null;
-	let i = {};
-	if (n.windows && typeof n.windows == "object") for (let [e, t] of Object.entries(n.windows)) {
-		let n = r(t);
-		n && (i[e] = n);
-	}
-	return {
-		v: t,
-		windows: i,
-		active: typeof n.active == "string" && n.active ? n.active : null,
-		pattern: typeof n.pattern == "string" && n.pattern.trim() ? n.pattern : null,
-		extra: n.extra && typeof n.extra == "object" && !Array.isArray(n.extra) ? { ...n.extra } : {}
-	};
-}
-function a(e) {
-	return Object.entries(e?.windows ?? {}).filter(([, e]) => e.z != null).sort(([, e], [, t]) => e.z - t.z).map(([e, t]) => ({
-		item: e,
-		app: t.app,
-		pin: t.pin
-	}));
-}
-function o(e, n, i) {
-	let a = {};
-	for (let [t, n] of Object.entries(e)) a[t] = {
-		app: n.app,
-		pin: n.pin
-	};
-	for (let [e, t] of Object.entries(n.windows)) {
-		let n = r(t);
-		n && (a[e] = n);
-	}
-	return {
-		v: t,
-		windows: a,
-		active: n.active,
-		pattern: n.pattern,
-		extra: { ...i }
-	};
-}
-function s(e, t = {}) {
-	let r = t.fresh ?? new URLSearchParams(location.search).get("fresh") === "1", i = t.extra ?? {}, a = r ? null : c(e), s = {
-		...i,
-		...a?.extra ?? {}
-	}, l = { ...a?.windows ?? {} }, u = !1, d = null, f = () => {
-		if (r || u || !d) return;
-		let t = o(l, d(), s);
-		l = t.windows;
-		try {
-			localStorage.setItem(e, JSON.stringify(t));
-		} catch {}
-	};
-	return {
-		saved: a,
-		pin: (e) => a?.windows[e]?.pin ?? null,
-		get: (e) => s[e],
-		set(e, t) {
-			s[e] = t, f();
-		},
-		hold() {
-			u = !0;
-		},
-		release() {
-			u = !1, f();
-		},
-		start(e, t) {
-			if (r) return () => {};
-			d = e;
-			let i = 0, a = () => {
-				clearTimeout(i), i = window.setTimeout(f, n);
-			}, o = () => {
-				document.visibilityState === "hidden" && f();
-			}, s = t(a);
-			return document.addEventListener("visibilitychange", o), window.addEventListener("pagehide", f), () => {
-				clearTimeout(i), s(), document.removeEventListener("visibilitychange", o), window.removeEventListener("pagehide", f), d = null;
-			};
-		}
-	};
-}
-function c(e) {
-	try {
-		return i(JSON.parse(localStorage.getItem(e) ?? "null"));
-	} catch {
-		return null;
-	}
-}
-//#endregion
-export { s as localStorageState, o as mergeSession, a as openWindowsOf, i as readSession };

package/dist/shell/storage.d.ts

@@ -1,14 +0,0 @@
-/**
- * Catalog storage that keeps: IndexedDB, one object store of item records
- * keyed by `id`.
- *
- * The database opens at the profile's own version, and one version up when
- * the store is missing — opening at a fixed version throws `VersionError` on
- * a profile already past it. It opens on first use; a failed open is retried
- * on the next call. Every call rejects on failure (a private window), and the
- * catalog then reports itself unavailable. A connection closes itself when
- * another tab upgrades the database, and the next call reopens.
- */
-import type { CatalogStorage } from './catalog.js';
-/** A catalog storage in the IndexedDB database `name`, which keeps it across reloads. */
-export declare function indexedDbStorage(name: string): CatalogStorage;