vintage-frames 0.14.0 → 0.15.0

package/dist/shell/windows.d.ts

@@ -0,0 +1,234 @@
+/**
+ * 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; 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.
+ * - 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 { 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;
+    /**
+     * 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.
+     */
+    close?: ((win: VfWindow) => void) | null;
+}
+/** 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;
+}
+/** The innermost focused element, through open shadow roots. */
+export declare function deepActiveElement(): Element | null;
+/**
+ * Move keyboard focus to the first thing in `win`'s content that takes it,
+ * once that content has rendered — and then only if `when`, read at that
+ * point, still holds. Resolves whether it did: a window with nothing
+ * focusable in its content keeps the focus where it was.
+ */
+export declare function focusInto(win: Element, { when }?: {
+    when?: () => 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. 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, or a plain close. */
+    requestClose(win: VfWindow): void;
+    /** 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 — a zoom, its group's arrange. */
+    write(win: VfWindow, box: Placed): 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 {};

package/dist/shell/windows.js

@@ -0,0 +1,387 @@
+import { snapSys as e, systemPxQuantum as t } from "../scale.js";
+import { VfWindow as n } from "../components/vf-window.js";
+import "../index.js";
+import { cascadeFrom as r, cascadedBox as i, frameOf as a, nearBox as o, pinOf as s, pinTo as c, windowOrigin as l } from "./geometry.js";
+//#region src/shell/windows.ts
+var u = (e, t) => e.set(t, (e.get(t) ?? 0) + 1), d = (e, t) => {
+	let n = e.get(t) ?? 1;
+	n > 1 ? e.set(t, n - 1) : e.delete(t);
+}, f = (e, t, n) => Math.min(Math.max(e, t), n), p = (e) => ({
+	left: e.left ?? 0,
+	top: e.top ?? 0,
+	width: e.width ?? 0,
+	height: e.height ?? 0
+});
+function m() {
+	let e = document.activeElement;
+	for (; e?.shadowRoot?.activeElement;) e = e.shadowRoot.activeElement;
+	return e;
+}
+var h = (e) => {
+	let t = document.activeElement;
+	return !!t && (t === e || e.contains(t));
+};
+async function g(e, { when: t } = {}) {
+	let n = [...e.querySelectorAll("*")];
+	if (await Promise.all([e, ...n].map((e) => e.updateComplete)), !e.isConnected || t && !t()) return !1;
+	for (let t of n) if (!(t.closest("[hidden]") || !t.checkVisibility()) && !(t.tabIndex < 0 && !t.localName.startsWith("vf-")) && (t.focus({ preventScroll: !0 }), h(e))) return !0;
+	return !1;
+}
+function ee(m, ee) {
+	let { defaultApp: te, savedPin: ne = () => null } = ee, _ = [], v = (e, t, n) => {
+		e.addEventListener(t, n), _.push(() => e.removeEventListener(t, n));
+	}, y = () => ({
+		width: m.width,
+		height: m.height
+	}), b = () => m.windowArea, x = /* @__PURE__ */ new Map(), S = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new WeakMap(), D = {}, O = () => a(b().top, D), k = /* @__PURE__ */ new Set(), A = !1, j = () => {
+		if (!A) for (let e of [...k]) e();
+	}, M = /* @__PURE__ */ new Set(), N = () => {
+		for (let e of [...M]) e();
+	}, P = /* @__PURE__ */ new Set(), F = /* @__PURE__ */ new Set(), I = /* @__PURE__ */ new Set(), L = /* @__PURE__ */ new Set(), R = /* @__PURE__ */ new Map(), z = [], re = (e) => {
+		for (let t = e; t; t = t.parentElement) if (R.has(t)) return t;
+		return null;
+	}, B = (e) => e.isConnected && (e.matches("vf-dialog[open]") || !!e.querySelector("vf-dialog[open]")), V = () => {
+		let e = z.filter((e) => R.has(e) && B(e));
+		for (let t of R.keys()) !e.includes(t) && B(t) && e.push(t);
+		if (!(e.length === z.length && e.every((e, t) => e === z[t]))) {
+			z = e;
+			for (let e of [...L]) e();
+		}
+	}, H = () => null, U = () => !1;
+	function W(n, r) {
+		let i = b(), a = t(n), o = (e) => Math.floor(e / a) * a, s = Math.ceil(i.top / a) * a, c = i.left + i.width, l = i.top + i.height, { width: u, height: d } = r;
+		n.resizable && (u != null && Number.isFinite(u) && (u = Math.min(u, o(i.width))), d != null && Number.isFinite(d) && (d = Math.min(d, o(Math.max(0, l - s)))));
+		let p = u ?? n.width ?? 0, m = d ?? n.height ?? 0;
+		return {
+			left: f(e(r.left ?? i.left, n), i.left, Math.max(i.left, o(c - p))),
+			top: f(e(r.top ?? s, n), s, Math.max(s, o(l - m))),
+			width: u,
+			height: d
+		};
+	}
+	let G = (t, n) => {
+		t.left = e(n.left, t), t.top = e(n.top, t), n.width != null && Number.isFinite(n.width) && (t.width = n.width), n.height != null && Number.isFinite(n.height) && (t.height = n.height), E.delete(t);
+	}, K = (e) => {
+		let t = x.get(e)?.place;
+		return t ? W(e, t(b())) : null;
+	}, q = (e, t) => {
+		let n = x.get(e)?.policy;
+		if (n) return n(t);
+		if (!e.resizable) return { size: {
+			width: t.width,
+			height: t.height
+		} };
+		let { minWidth: r, minHeight: i } = e.sizeLimits;
+		return { min: {
+			width: r,
+			height: i
+		} };
+	}, J = (e, t, n = q(e, p(e))) => W(e, c(t, y(), O(), n)), ie = (e, t) => {
+		let n = p(e);
+		return [
+			"left",
+			"top",
+			"width",
+			"height"
+		].every((e) => {
+			let r = t[e];
+			return r == null || !Number.isFinite(r) || n[e] === r;
+		});
+	}, ae = (e) => {
+		let t = [...x].filter(([t, n]) => t !== e && !t.hidden && !n.palette).map(([e]) => p(e));
+		return r(l(b()), t).slot;
+	}, Y = te, X = (e) => e instanceof n && x.get(e)?.app || te;
+	function oe() {
+		let e = !1;
+		for (let [t, n] of x) {
+			if (!n.palette) continue;
+			let r = n.app === Y && n.palette();
+			t.hidden !== !r && (t.hidden = !r, r && m.bringToFront(t), e = !0);
+		}
+		e && j();
+	}
+	let se = (e) => {
+		let t = document.activeElement?.closest("vf-window");
+		!(t instanceof n) || t === e || !x.has(t) || x.get(t).palette || (e ? Z(e) : U(null, null));
+	}, Z = (e) => void g(e, { when: () => m.activeWindow === e }), ce = (e) => {
+		se(e);
+		for (let t of [...F]) t(e);
+		let t = X(e);
+		if (t !== Y) {
+			Y = t, oe();
+			for (let e of [...I]) e(Y);
+		}
+	};
+	v(m, "vf-activate", (e) => ce(e.detail.window)), v(m, "vf-close", (e) => {
+		let t = e.target;
+		t instanceof n && x.has(t) && $.requestClose(t);
+	});
+	let Q = 0, le = (e) => {
+		!(e.target instanceof n) || !x.has(e.target) || Q || (Q = window.setTimeout(() => {
+			Q = 0, j();
+		}, 0));
+	};
+	m.addEventListener("vf-placement-change", le), _.push(() => m.removeEventListener("vf-placement-change", le)), v(m, "vf-resize", (e) => {
+		e.detail?.commit && j();
+	});
+	let ue = (e) => {
+		let t = x.get(e);
+		t && (x.delete(e), E.delete(e), t.palette || N(), j());
+	}, de = (n, r, i, a) => {
+		let l = p(n), u = x.get(n);
+		if (u?.keep && o(l, u.keep(a))) {
+			G(n, W(n, u.keep(b())));
+			return;
+		}
+		let d = E.get(n), f = !!d && n.resizable && (d.width !== l.width || d.height !== l.height), m = !d || d.left !== l.left || d.top !== l.top || f || !d ? s(l, r, O()) : d.pin, h = c(m, i, O(), q(n, l));
+		if (n.left = e(h.left, n), n.top = e(h.top, n), n.resizable) {
+			let r = t(n), i = b(), a = Math.ceil(i.top / r) * r, o = Math.floor(i.width / r) * r, s = Math.floor(Math.max(0, i.top + i.height - a) / r) * r;
+			n.width = Math.min(e(h.width, n), o), n.height = Math.min(e(h.height, n), s);
+		}
+		E.set(n, {
+			pin: m,
+			...p(n)
+		});
+	}, $ = {
+		get area() {
+			return b();
+		},
+		get front() {
+			return Y;
+		},
+		adopt(e, t) {
+			let n = t.palette;
+			if (x.set(e, {
+				app: t.app,
+				item: t.item ?? null,
+				place: t.place ?? null,
+				policy: t.policy ?? null,
+				keep: t.keep ?? null,
+				palette: n ? n === !0 ? () => !0 : n : null,
+				close: t.close ?? null
+			}), t.pin) G(e, J(e, t.pin));
+			else {
+				let t = K(e);
+				t && G(e, t);
+			}
+			if (n) {
+				let t = x.get(e);
+				e.hidden = !(t.app === Y && t.palette());
+			}
+			m.activeWindow === e && ce(e), n || N(), j();
+		},
+		open(e) {
+			let t = e.item == null ? null : $.windowFor(e.item);
+			if (t) return m.bringToFront(t), Z(t), t;
+			let n = e.create(), r = {
+				width: n.width ?? 0,
+				height: n.height ?? 0
+			}, a = ae();
+			m.append(n);
+			let o = e.item ?? null;
+			return $.adopt(n, {
+				app: e.app,
+				item: o,
+				place: e.place ?? ((e) => i(e, r, l(e), a)),
+				pin: o == null ? null : C.get(o)?.pin ?? ne(o),
+				policy: e.policy ?? null,
+				keep: e.keep ?? null,
+				close: e.close ?? null
+			}), o != null && C.delete(o), m.bringToFront(n), e.from && n.show({ from: e.from }), Z(n), n;
+		},
+		close(e, { to: t } = {}) {
+			let n = x.get(e), r = n?.item ?? null, i = n?.app ?? null, a = t === void 0 ? i == null ? null : H(r, i) : t, o = m.activeWindow === e || h(e);
+			r != null && i != null && C.set(r, {
+				app: i,
+				pin: s(p(e), y(), O())
+			});
+			let c = e.hide({ to: a });
+			r != null && u(w, r), i != null && !n?.palette && u(T, i);
+			let l = () => {
+				r != null && d(w, r), i != null && !n?.palette && d(T, i), N();
+			};
+			return c.then(l, l), ue(e), e.remove(), o && queueMicrotask(() => {
+				let e = m.activeWindow;
+				e ? Z(e) : U(r, i) || U(null, null);
+			}), c;
+		},
+		requestClose(e) {
+			let t = x.get(e)?.close;
+			t ? t(e) : $.close(e);
+		},
+		windowFor(e) {
+			for (let [t, n] of x) if (n.item === e) return t;
+			return null;
+		},
+		windowsOf(e) {
+			return m.stackingOrder.filter((t) => t instanceof n && x.get(t)?.app === e);
+		},
+		itemOf(e) {
+			return e instanceof n ? x.get(e)?.item ?? null : null;
+		},
+		appOf(e) {
+			if (e instanceof n) return x.get(e)?.app ?? null;
+			let t = re(e);
+			return t ? R.get(t).app : null;
+		},
+		holdDialog(e, { app: t }) {
+			let n = R.get(e);
+			if (n) n.app = t;
+			else {
+				let n = new MutationObserver(V);
+				n.observe(e, {
+					attributes: !0,
+					attributeFilter: ["open"],
+					subtree: !0
+				}), R.set(e, {
+					app: t,
+					observer: n
+				});
+			}
+			m.contains(e) || m.append(e), V();
+		},
+		releaseDialog(e) {
+			let t = R.get(e);
+			t && (t.observer.disconnect(), R.delete(e), V());
+		},
+		dialogsOf(e) {
+			return [...R].filter(([, t]) => t.app === e).map(([e]) => e);
+		},
+		get asking() {
+			let e = z[z.length - 1];
+			return e ? R.get(e).app : null;
+		},
+		isPalette(e) {
+			return e instanceof n && !!x.get(e)?.palette;
+		},
+		setItem(e, t) {
+			let n = x.get(e);
+			!n || n.item === t || (n.item = t, N());
+		},
+		isOpen(e) {
+			return w.has(e) || $.windowFor(e) !== null;
+		},
+		hasWindows(e) {
+			if (T.has(e)) return !0;
+			for (let [, t] of x) if (t.app === e && !t.palette) return !0;
+			return !1;
+		},
+		palettesChanged() {
+			oe();
+		},
+		write(e, t) {
+			G(e, t), j();
+		},
+		clamped(e, t) {
+			return W(e, t);
+		},
+		placed(e) {
+			return K(e);
+		},
+		pinOf(e) {
+			return s(p(e), y(), O());
+		},
+		fromPin(e, t, n) {
+			return J(e, t, n);
+		},
+		setFrameBands(e) {
+			D = { ...e }, E = /* @__PURE__ */ new WeakMap();
+		},
+		arrangeWith(e, t) {
+			return S.set(e, t), j(), () => {
+				S.get(e) === t && S.delete(e), j();
+			};
+		},
+		arrange() {
+			A = !0;
+			try {
+				for (let e of S.values()) e.arrange();
+				for (let e of x.keys()) {
+					let t = K(e);
+					t && G(e, t);
+				}
+			} finally {
+				A = !1;
+			}
+			j();
+		},
+		arranged() {
+			for (let e of S.values()) if (!e.arranged()) return !1;
+			for (let e of x.keys()) {
+				let t = K(e);
+				if (t && !e.hidden && !ie(e, t)) return !1;
+			}
+			return !0;
+		},
+		resized(e) {
+			let t = y();
+			if (e.width === t.width && e.height === t.height) return;
+			let n = b(), r = {
+				left: n.left,
+				top: n.top,
+				width: e.width - n.left,
+				height: Math.max(0, e.height - n.top)
+			};
+			for (let n of x.keys()) de(n, e, t, r);
+			for (let n of [...P]) n(e, t);
+			j();
+		},
+		snapshot() {
+			let e = {};
+			for (let [t, n] of C) e[t] = { ...n };
+			let t = m.stackingOrder;
+			for (let [n, r] of x) {
+				if (r.item == null) continue;
+				let i = s(p(n), y(), O());
+				e[r.item] = r.palette ? {
+					app: r.app,
+					pin: i
+				} : {
+					app: r.app,
+					pin: i,
+					z: t.indexOf(n)
+				};
+			}
+			return e;
+		},
+		rememberedPin(e) {
+			return C.get(e)?.pin ?? null;
+		},
+		layoutChanged() {
+			j();
+		},
+		setHome(e, t) {
+			return H = e, U = t, () => {
+				H = () => null, U = () => !1;
+			};
+		},
+		onLayout(e) {
+			return k.add(e), () => void k.delete(e);
+		},
+		onWindows(e) {
+			return M.add(e), () => void M.delete(e);
+		},
+		onRaster(e) {
+			return P.add(e), () => void P.delete(e);
+		},
+		beforeFront(e) {
+			return F.add(e), () => void F.delete(e);
+		},
+		onFront(e) {
+			return I.add(e), () => void I.delete(e);
+		},
+		onDialogs(e) {
+			return L.add(e), () => void L.delete(e);
+		},
+		dispose() {
+			clearTimeout(Q);
+			for (let e of _) e();
+			k.clear(), M.clear(), P.clear(), F.clear(), I.clear(), L.clear();
+			for (let { observer: e } of R.values()) e.disconnect();
+			R.clear(), z = [], S.clear(), x.clear();
+		}
+	};
+	return Y = X(m.activeWindow), $;
+}
+//#endregion
+export { ee as createWindowManager, m as deepActiveElement, g as focusInto };

package/dist/text-control.d.ts

@@ -117,6 +117,12 @@ export declare class VfTextControlBase extends VfShadowRoleControl {
      * disabled default button means no submission at all, as in HTML; a form
      * with no submit button falls back to the bare call, also as in HTML.
      *
+     * One departure: a submit `vf-button variant="default"`, the button with
+     * the ring, is the default button when the form has one, ahead of the
+     * first in tree order. A Cancel/OK row puts Cancel first, and Return
+     * should press the button the ring marks — the one a modal's own Return
+     * rule presses (`VfModalDialog`).
+     *
      * Returns whether a form owner took the press — true even when a disabled
      * default button meant no submission, since HTML gave the press to the form
      * either way. The callers cancel the keydown on true, so a modal shell

package/dist/text-control.js

@@ -57,8 +57,8 @@ var l = class extends a {
 	requestImplicitSubmit() {
 		let e = this.internals.form;
 		if (!e) return !1;
-		let t = [...e.elements].find((e) => e instanceof HTMLButtonElement && e.type === "submit" || e instanceof HTMLInputElement && (e.type === "submit" || e.type === "image") || e.localName === "vf-button" && !e.href && e.type?.toLowerCase() === "submit");
-		return t ? (t.matches(":disabled") || t.click(), !0) : (e.requestSubmit(), !0);
+		let t = [...e.elements].filter((e) => e instanceof HTMLButtonElement && e.type === "submit" || e instanceof HTMLInputElement && (e.type === "submit" || e.type === "image") || e.localName === "vf-button" && !e.href && e.type?.toLowerCase() === "submit"), n = t.find((e) => e.localName === "vf-button" && e.variant === "default") ?? t[0];
+		return n ? (n.matches(":disabled") || n.click(), !0) : (e.requestSubmit(), !0);
 	}
 	emitValue(t, n = { value: this.value }) {
 		e(this, t, n);

package/dist/window-chrome.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A window's chrome as numbers: the insets between its outer box and the
+ * region its content lays out in, and the floor its grow box stops at.
+ *
+ * A page sizing a window to its content, or content to its window, needs the
+ * chrome between the two — a folder window's field sized to the scrolled
+ * plane, a palette sized to hold its cells exactly. Restating `1 + 18 + 20 +
+ * 15 + 1` in the page was the alternative, with a note to re-derive it if
+ * the kit's chrome ever changed.
+ */
+/** The grow box's default floors, in system px: a window smaller than this can't be worked. */
+export declare const WINDOW_MIN_WIDTH = 80;
+export declare const WINDOW_MIN_HEIGHT = 54;
+/** The declared options that decide a window's chrome — `vf-window`'s own. */
+export interface VfWindowChromeOptions {
+    /** `'utility'` for the windoid's 12px bar; anything else is the 18px one. */
+    variant?: 'utility' | null;
+    /** The edge scroll rails, as on `vf-window`. */
+    scrollbars?: 'vertical' | 'horizontal' | 'both' | null;
+    /** The header's height, rule included, while the `header` slot is populated. */
+    headerHeight?: number | null;
+    /** Whether the `status` slot is populated. */
+    status?: boolean;
+}
+/** Four insets in system px. */
+export interface VfInsets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * The insets, in system px, between a window's outer box (its `width` and
+ * `height`) and the region its content lays out in: the body, or under
+ * `scrollbars` the scrolled plane's viewport. They go both ways — the content
+ * of a window `W` wide is `W − left − right`, and a window that holds content
+ * `w` wide is `w + left + right`. The frame's 1px stroke on every side, the
+ * title bar (18, or 12 for a utility window) and the header above, the status
+ * strip (15) and a horizontal rail (15) below, a vertical rail (15) on the
+ * right. The numbers are the default tokens': a page that restyles
+ * `--vf-titlebar-height` or `--vf-status-bar-height` restates them.
+ */
+export declare function windowChrome({ variant, scrollbars, headerHeight, status, }?: VfWindowChromeOptions): VfInsets;