vintage-frames 0.19.1 → 0.20.0

package/dist/shell/storage.js

@@ -1,41 +0,0 @@
-//#region src/shell/storage.ts
-var e = "items", t = (e) => new Promise((t, n) => {
-	e.onsuccess = () => t(e.result), e.onerror = () => n(e.error ?? /* @__PURE__ */ Error("IndexedDB request failed"));
-});
-function n(t, n, r) {
-	return new Promise((i, a) => {
-		let o = n == null ? indexedDB.open(t) : indexedDB.open(t, n);
-		o.onupgradeneeded = () => {
-			o.result.objectStoreNames.contains(e) || o.result.createObjectStore(e, { keyPath: "id" });
-		}, o.onsuccess = () => {
-			let e = o.result;
-			e.onversionchange = () => {
-				r(), e.close();
-			}, i(e);
-		}, o.onerror = () => a(o.error ?? /* @__PURE__ */ Error("IndexedDB open failed")), o.onblocked = () => {
-			console.warn(`vintage-frames/shell: waiting for another tab to let go of the "${t}" database`);
-		};
-	});
-}
-async function r(t, r) {
-	let i = await n(t, void 0, r);
-	if (!i.objectStoreNames.contains(e)) {
-		let e = i.version + 1;
-		i.close(), i = await n(t, e, r);
-	}
-	return i;
-}
-function i(n) {
-	let i = null, a = () => typeof indexedDB > "u" ? Promise.reject(/* @__PURE__ */ Error("IndexedDB is unavailable")) : (i ??= r(n, () => {
-		i = null;
-	}).catch((e) => {
-		throw i = null, e;
-	}), i), o = async (n, r) => t(r((await a()).transaction(e, n).objectStore(e)));
-	return {
-		list: () => o("readonly", (e) => e.getAll()),
-		put: (e) => o("readwrite", (t) => t.put(e)),
-		remove: (e) => o("readwrite", (t) => t.delete(e))
-	};
-}
-//#endregion
-export { i as indexedDbStorage };

package/dist/shell/version.d.ts

@@ -1,2 +0,0 @@
-/** The kit's version, as published: package.json's `version`. `npm version` rewrites it (the `version` script). */
-export declare const VERSION = "0.19.1";

package/dist/shell/version.js

@@ -1,4 +0,0 @@
-//#region src/shell/version.ts
-var e = "0.19.1";
-//#endregion
-export { e as VERSION };

package/dist/shell/windows.d.ts

@@ -1,278 +0,0 @@
-/**
- * The window manager. Applications make their windows; the manager places
- * them, opens and closes them, follows the front application, carries them
- * through a raster resize and arranges them.
- *
- * - `adopt()` takes a window an application made and appended: its
- *   application, the item it shows, how to place it, its resize policy, and
- *   what its close box means. `open()` raises the window for an item if one
- *   is open, and otherwise makes, appends, adopts and places one, and shows
- *   it out of `from`. `close()` hides a window into `to` — by default its
- *   home box, which the Finder provides: the item's icon, or the
- *   application's — then releases and removes it.
- * - Placement, in order: this session's pin for the item, the saved pin,
- *   then the `place` policy — by default the first cascade slot no open
- *   window holds. The result is clamped into the desktop's window area.
- * - The front application is the active window's, or the default one while
- *   none is active. `beforeFront` runs before a change, `onFront` reports it.
- * - Palettes are an application's utility windows: shown while it is front
- *   and hidden otherwise, never closed or removed.
- * - Opening a window moves keyboard focus into it, and a new window's field
- *   marked `autoselect` opens with its text selected; closing the active one
- *   moves focus to the window that becomes active, else to the closed
- *   window's icon, else to the desktop's icons. Focus left behind in a
- *   window that is no longer active — a title-bar press moves none — goes
- *   to the active window too.
- * - `onWindows` reports a window opened or closed and a close's zoom rects
- *   landing, palettes aside; `isOpen()` and `hasWindows()` hold until they
- *   land, which is what the Finder's open ghost follows.
- * - The resize rule re-pins every window with the nine-slice pin, re-reads a
- *   resizable window's pin when its size changed, floors it at the window's
- *   own size limits and caps it to the window area, so growing back restores
- *   every place.
- * - The zoom box, for a window adopted with `zoom`: the window goes to its
- *   zoomed box and back to the box it had, kept as a pin; a zoomed window
- *   stays zoomed across a resize.
- * - Dialogs: `holdDialog()` holds an application's dialog under it, in the
- *   desktop. The manager follows each held dialog's `open` attribute, and
- *   `asking` is the application of the one opened last and still open.
- */
-import { VfWindow } from '../index.js';
-import type { VfCloseKeys, VfDesktop, VfViewportBox } from '../index.js';
-import type { Bands, Box, Pin, Policy, Size } from './geometry.js';
-/** A box to write, any edge optional. */
-export interface BoxInput {
-    left?: number;
-    top?: number;
-    width?: number;
-    height?: number;
-}
-/** A placement: a position, and a size where one is stated. */
-export interface Placed extends BoxInput {
-    left: number;
-    top: number;
-}
-/** How a window is placed: its box on the desktop's live window area. */
-export type PlacePolicy = (area: Box) => BoxInput & Point;
-type Point = {
-    left: number;
-    top: number;
-};
-/** What adopting a window declares. */
-export interface AdoptOptions {
-    /** The application shown while the window is active. */
-    app: string;
-    /** The item it shows: a catalog id, or an application's own key. */
-    item?: string | null;
-    /** Its placement on the live window area; adopt() and arrange() apply it. Unset, the owner places it. */
-    place?: PlacePolicy | null;
-    /** A saved pin to open at instead. */
-    pin?: Pin | null;
-    /** Its resize policy for the re-pin. Default: a resizable window floored at its size limits, else fixed. */
-    policy?: ((cur: Box) => Policy) | null;
-    /** A box held across a raster resize while the window is near it. */
-    keep?: ((area: Box) => Box) | null;
-    /**
-     * Its zoom box: the window's zoomed box on the window area, given its
-     * current box (to keep its top-left, say). Set, the manager runs the zoom
-     * box: it goes to this box and back to the box the user had, and a window
-     * at it stays zoomed across a raster resize.
-     */
-    zoom?: ((area: Box, box: Box) => BoxInput) | null;
-    /**
-     * A palette: shown while its application is front — and while the
-     * predicate holds, for one the application hides for its own reasons —
-     * and hidden otherwise. Never closed by the manager.
-     */
-    palette?: boolean | (() => boolean);
-    /**
-     * What the close box means. Unset, it closes the window. Set, the close box
-     * asks the application, which calls `close()` once it decides — after a
-     * Save prompt, say — or never. It gets the modifier keys held on the
-     * close box's click; a close from a menu or code holds none. A handler
-     * that decides later returns its promise, so `closeAll()` waits for it.
-     */
-    close?: CloseHandler | null;
-}
-/** A window's close handler: decides whether it closes, and calls `close()` if so. */
-export type CloseHandler = (win: VfWindow, keys: Partial<VfCloseKeys>) => void | Promise<void>;
-/** What opening a window for an item declares. */
-export interface OpenOptions extends Omit<AdoptOptions, 'pin' | 'palette'> {
-    /** Makes the window, not yet appended. */
-    create: () => VfWindow;
-    /** The box it opens out of, in viewport CSS px: an icon's `cellRect()`. */
-    from?: VfViewportBox | null;
-}
-/** An application's arrangement group, for windows it places itself. */
-export interface ArrangeGroup {
-    arrange(): void;
-    arranged(): boolean;
-}
-/**
- * The box a closing window shrinks into, in viewport CSS px: `item` is the
- * window's item, or null, and `app` its application. The Finder answers with
- * the item's icon, the nearest open folder around it, or the application's
- * icon.
- */
-export type HomeBox = (item: string | null, app: string) => VfViewportBox | null;
-/** Move the focus to the closed window's icon (`item` null: the desktop's first); resolves whether it moved. */
-export type FocusHome = (item: string | null, app: string | null) => boolean;
-export interface WindowManagerOptions {
-    /** The application front while no window is active. */
-    defaultApp: string;
-    /** A saved pin by item — the session the boot read. */
-    savedPin?: (item: string) => Pin | null;
-}
-/** Settles once the desktop and its menu bar have rendered, so `workArea` measures the bar. */
-export declare function desktopRendered(desktop: VfDesktop): Promise<void>;
-/** The innermost focused element, through open shadow roots. */
-export declare function deepActiveElement(): Element | null;
-/**
- * Move keyboard focus into `win`'s content once that content has rendered —
- * and then only if `when`, read at that point, still holds: to the first
- * descendant marked `autofocus` or `autoselect`, else to the first thing that
- * takes the focus. With `select`, a control marked `autoselect` has its text
- * selected too; the window manager passes it on a window's first open only,
- * so a caret placed in the window survives a return to it. An element whose
- * `tabindex` is negative is passed over: a roving cell parked off the tab
- * order, a disabled control. A kit host with no `tabindex` goes through,
- * since it hands the focus on inside itself. Resolves whether the focus
- * moved: a window with nothing focusable in its content keeps the focus where
- * it was.
- */
-export declare function focusInto(win: Element, { when, select }?: {
-    when?: () => boolean;
-    select?: boolean;
-}): Promise<boolean>;
-/** The window manager over a desktop. */
-export declare function createWindowManager(desktop: VfDesktop, options: WindowManagerOptions): {
-    /** The desktop's window area, system px. */
-    readonly area: Box;
-    /** The front application's id. */
-    readonly front: string;
-    /**
-     * Take a window an application made and appended (a slotted child of the
-     * desktop: the clamp reads its lattice). It opens at the saved `pin`, or
-     * at its `place`; without either the owner placed it.
-     */
-    adopt(win: VfWindow, opts: AdoptOptions): void;
-    /**
-     * Open the window for `item`: raise it if one is open, else make it,
-     * append it, adopt it and place it — this session's pin, then the saved
-     * one, then `place`, by default the first free cascade slot — and show it
-     * out of `from`. Keyboard focus moves into it, and a new window's field
-     * marked `autoselect` has its text selected. Returns the window.
-     */
-    open(opts: OpenOptions): VfWindow;
-    /**
-     * Close a window into `to` — by default its home box, the Finder's icon
-     * for it — then release and remove it. The item's box is remembered for
-     * the session. Resolves when the zoom rects have landed.
-     */
-    close(win: VfWindow, { to }?: {
-        to?: VfViewportBox | null;
-    }): Promise<boolean>;
-    /**
-     * The close box's route: the window's own close, given the modifier keys
-     * held, or a plain close. Resolves whether the window closed, once its
-     * close handler has settled.
-     */
-    requestClose(win: VfWindow, keys?: Partial<VfCloseKeys>): Promise<boolean>;
-    /**
-     * Ask each of an application's windows to close, front to back, palettes
-     * aside: a Quit. Resolves false at the first window still open once its
-     * handler has settled — a Cancel — and true when all have closed.
-     */
-    closeAll(app: string, keys?: Partial<VfCloseKeys>): Promise<boolean>;
-    /** The window showing `item`, or null. */
-    windowFor(item: string): VfWindow | null;
-    /** Every window of an application, back to front. */
-    windowsOf(app: string): VfWindow[];
-    /** A window's item, or null. */
-    itemOf(win: Element | null): string | null;
-    /** A window's or a held dialog's application, or null when the manager doesn't hold it. */
-    appOf(el: Element | null): string | null;
-    /**
-     * Hold an application's dialog: a `vf-dialog`, or an element that renders
-     * one inside itself. It is appended to the desktop unless it is already
-     * in it, and its `open` is followed from then on.
-     */
-    holdDialog(dialog: Element, { app }: {
-        app: string;
-    }): void;
-    /** Let a held dialog go. It stays where it is; the caller removes it. */
-    releaseDialog(dialog: Element): void;
-    /** An application's held dialogs. */
-    dialogsOf(app: string): Element[];
-    /** The application of the held dialog opened last and still open, or null. */
-    readonly asking: string | null;
-    /** Whether `win` is a palette. */
-    isPalette(win: Element | null): boolean;
-    /** Change the item a window shows: an untitled document's first save, say. */
-    setItem(win: VfWindow, item: string | null): void;
-    /** Whether a window shows `item`, or is still closing into its icon. */
-    isOpen(item: string): boolean;
-    /** Whether an application has a window open, palettes aside, or one still closing. */
-    hasWindows(app: string): boolean;
-    /** Re-read every palette's predicate: an application hid or showed one. */
-    palettesChanged(): void;
-    /** Write a box for a gesture the owner runs itself — its group's arrange, a zoom of its own. */
-    write(win: VfWindow, box: Placed): void;
-    /**
-     * The zoom box, for a window adopted with a `zoom`: away from its zoomed
-     * box, the window goes there, its box remembered; at it, the window goes
-     * back to that box, carried by its pin through any raster resize since,
-     * or to its `place` with none remembered. The zoom box's press runs it;
-     * so can a menu command.
-     */
-    zoom(win: VfWindow): void;
-    /** The box a placement would write, not written. */
-    clamped(win: VfWindow, box: BoxInput): Placed;
-    /** A window's `place` on the live area, clamped, or null. */
-    placed(win: VfWindow): Placed | null;
-    /** A window's pin on the current raster, for an owner that saves it. */
-    pinOf(win: VfWindow): Pin;
-    /** A pin on the live raster, clamped, under the window's policy or `policy`. */
-    fromPin(win: VfWindow, pin: Pin, policy?: Policy): Placed;
-    /** Widen the frame's bands, for an application whose windows dock along the edges. */
-    setFrameBands(next: Partial<Bands>): void;
-    /** Register an application's arrangement group. Returns the unregister. */
-    arrangeWith(app: string, group: ArrangeGroup): () => void;
-    /** View → Arrange Windows: every group's arrange, then every `place`. Nothing is raised. */
-    arrange(): void;
-    /** Whether every group is arranged and every shown window sits at its `place`. */
-    arranged(): boolean;
-    /**
-     * Carry every window from the `before` raster to the live one with the
-     * nine-slice pin, then tell the onRaster listeners. Nothing clamps a
-     * window's position, so growing back restores it.
-     */
-    resized(before: Size): void;
-    /** The windows' saved boxes: each open one with its depth, the palettes as boxes alone. */
-    snapshot(): Record<string, {
-        app: string;
-        pin: Pin;
-        z?: number;
-    }>;
-    /** This session's pin for an item whose window closed, or null. */
-    rememberedPin(item: string): Pin | null;
-    /** Notify layout of a change the owner made itself. */
-    layoutChanged(): void;
-    /** Set where a window closes into and where focus goes after it: the Finder's. */
-    setHome(box: HomeBox, focus: FocusHome): () => void;
-    /** The layout signal: any geometry write, drag, grow or arrange. Returns the unsubscribe. */
-    onLayout(fn: () => void): () => void;
-    /** A window opened or closed, or finished closing, palettes aside; a window's item changed. */
-    onWindows(fn: () => void): () => void;
-    /** A raster resize, after every window has re-pinned. */
-    onRaster(fn: (before: Size, after: Size) => void): () => void;
-    /** An activation, before the front application changes: `fn(win)`, the new active window or null. */
-    beforeFront(fn: (win: HTMLElement | null) => void): () => void;
-    /** The front application changed. */
-    onFront(fn: (app: string) => void): () => void;
-    /** A held dialog opened or closed, so `asking` may have changed. */
-    onDialogs(fn: () => void): () => void;
-    dispose(): void;
-};
-export type WindowManager = ReturnType<typeof createWindowManager>;
-export {};