zabi-components 8.0.0 → 8.1.0

package/dist/components/util/dropdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dropdown.d.ts","sourceRoot":"","sources":["../../../src/components/util/dropdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAExC,wDAAwD;AACxD,MAAM,MAAM,gBAAgB,GAAG,SAAS,CAAC;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE5E,MAAM,MAAM,gBAAgB,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEpD,yCAAyC;AACzC,MAAM,WAAW,cAAc;IAC3B,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gFAAgF;IAChF,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACxB,wDAAwD;IACxD,IAAI,CAAC,EAAE,gBAAgB,CAAC;IACxB,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,gDAAgD,CAAC;AAE/E;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,YAAY,EAAE,oBAAoB,GAAG,OAAO,CAQxE;AAED,iDAAiD;AACjD,MAAM,WAAW,eAAe;IAC5B,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,UAAU,GAAG,QAAQ,CAAC;CAC5C;AAED,eAAO,MAAM,oBAAoB,eAAqB,CAAC"}

package/dist/components/util/field.d.ts

@@ -0,0 +1,39 @@
+/**
+ * What Input, Textarea and Select share about the text under a field, and
+ * DateField and TimeField through Input. Kept in one place so the four cannot
+ * drift: which message shows, in which variant, and what the control is
+ * described by.
+ */
+import type { SemanticVariant } from "../types/variants.js";
+export interface FieldMessageInput {
+    variant?: SemanticVariant;
+    message?: string;
+    hint?: string;
+    error?: string;
+}
+export interface FieldMessageState {
+    /** The variant the control is drawn in: `error` whenever there is an error. */
+    variant: SemanticVariant;
+    /** The text of the status message: the error, or else `message`. */
+    message: string;
+    /** Whether the status message is rendered. A `message` without a variant is not. */
+    showMessage: boolean;
+    /** Whether the hint is rendered. */
+    showHint: boolean;
+}
+/**
+ * `error` wins over `variant` and `message`: it sets the error variant and is
+ * the message. Without it, `message` shows in a `success`, `warning` or
+ * `error` variant, as it always has, and not in `default`: text for a field
+ * that is neither is a `hint`.
+ */
+export declare function fieldMessageState({ variant, message, hint, error, }: FieldMessageInput): FieldMessageState;
+export declare const fieldHintId: (fieldId: string) => string;
+export declare const fieldMessageId: (fieldId: string) => string;
+/**
+ * The ids a control is described by: the caller's own (a FormField around the
+ * field, say), then the hint, then the status message. Only ids of elements
+ * that are rendered; `undefined` when there are none, so no empty attribute.
+ */
+export declare function fieldDescribedBy(fieldId: string, state: Pick<FieldMessageState, "showMessage" | "showHint">, own?: string | null): string | undefined;
+//# sourceMappingURL=field.d.ts.map

package/dist/components/util/field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../../../src/components/util/field.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D,MAAM,WAAW,iBAAiB;IAC9B,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAC9B,+EAA+E;IAC/E,OAAO,EAAE,eAAe,CAAC;IACzB,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,oFAAoF;IACpF,WAAW,EAAE,OAAO,CAAC;IACrB,oCAAoC;IACpC,QAAQ,EAAE,OAAO,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,EAC9B,OAAmB,EACnB,OAAY,EACZ,IAAS,EACT,KAAU,GACb,EAAE,iBAAiB,GAAG,iBAAiB,CASvC;AAED,eAAO,MAAM,WAAW,GAAI,SAAS,MAAM,WAAsB,CAAC;AAClE,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,WAAyB,CAAC;AAExE;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC5B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,IAAI,CAAC,iBAAiB,EAAE,aAAa,GAAG,UAAU,CAAC,EAC1D,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GACpB,MAAM,GAAG,SAAS,CAUpB"}

package/dist/components/util/fit-in-viewport.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Keeps a floating box (a menu, a panel, a tooltip) where it can be seen.
+ *
+ * One module for everything that opens next to a trigger. Two layers:
+ *
+ * - `pickSide` and `shiftIntoViewport` are the two decisions every such box
+ *   needs: which side of its trigger it opens on, and how far it has to move
+ *   along that side to stay on screen. Tooltip uses them as they are.
+ * - `fitPanel` builds on them for a panel that hangs from one edge of its
+ *   anchor (Dropdown, Select's list, NavigationMenuContent): it also narrows
+ *   and shortens a panel too large for the screen. `measurePlacement` reads
+ *   the layout for it, and `watchViewport` re-runs it while the panel is open.
+ *
+ * The arithmetic is pure, so it can be tested without a layout.
+ *
+ * The screen is not the only thing that cuts a panel off. Inside a box that
+ * scrolls (a Modal's body, a list with its own scrollbar) the box clips it
+ * first. `measurePlacement` takes the nearest such box into account: it
+ * decides which side the panel opens on, and when the panel fits on neither
+ * side it says where to put the panel with `position: fixed`, which a
+ * scrolling ancestor does not clip.
+ */
+export type PanelBlock = "bottom" | "top";
+export type PanelInline = "start" | "end";
+export interface PanelBox {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+export interface FitPanelInput {
+    /** The box the panel is positioned against, in viewport coordinates. */
+    anchor: PanelBox;
+    /** The panel's natural size, measured with no limit on it. */
+    panel: {
+        width: number;
+        height: number;
+    };
+    viewport: {
+        width: number;
+        height: number;
+    };
+    /** The side asked for. It is kept whenever the panel fits there. */
+    block: PanelBlock;
+    inline: PanelInline;
+    /** Right-to-left layout: `start` is then the right edge. */
+    rtl?: boolean;
+    /** Room kept between the panel and every edge of the viewport. */
+    margin?: number;
+    /** Distance between the anchor and the panel. */
+    gap?: number;
+    /** False keeps the panel on the `block` side asked for, whatever fits. */
+    flipBlock?: boolean;
+    /** False keeps it on the `inline` edge asked for and slides it back inside instead. */
+    flipInline?: boolean;
+    /**
+     * The inside of the nearest ancestor that clips, in viewport coordinates.
+     * It decides which side the panel opens on and how far it slides; it
+     * never limits the panel's size, which only the viewport does.
+     */
+    clip?: PanelBox | null;
+}
+export interface PanelFit {
+    block: PanelBlock;
+    inline: PanelInline;
+    /**
+     * Distance to put between the anchor's `inline` edge and the panel's, for
+     * `inset-inline-start` or `inset-inline-end`. 0 when the panel fits as it
+     * is; otherwise what slides it back inside.
+     */
+    inlineOffset: number;
+    /** A limit to set, or null when the panel fits without one. */
+    maxWidth: number | null;
+    maxHeight: number | null;
+    /** Where the panel's box ends up, in viewport coordinates, and how wide it is there. */
+    left: number;
+    top: number;
+    width: number;
+    /** False when part of the panel is outside `clip` (or the viewport) even so. */
+    visible: boolean;
+}
+export type FloatingSide = "top" | "bottom" | "left" | "right";
+/**
+ * The side a floating box of `size` opens on: the preferred one when it fits
+ * there, the opposite one when only that fits, and otherwise whichever of the
+ * two has more room.
+ *
+ * `gap` is the distance between trigger and box; `margin` is how close to the
+ * viewport edge the box may come. `clip` is the inside of an ancestor that
+ * cuts the box off, when there is one: the box then has to fit in what both
+ * leave.
+ */
+export declare function pickSide(preferred: FloatingSide, trigger: PanelBox, size: {
+    width: number;
+    height: number;
+}, viewport: {
+    width: number;
+    height: number;
+}, { gap, margin, clip, }?: {
+    gap?: number;
+    margin?: number;
+    clip?: PanelBox | null;
+}): FloatingSide;
+/**
+ * How far `box` has to move, in px, to lie inside the viewport with `margin`
+ * to spare. Zero on an axis where it already does. A box larger than the
+ * viewport is aligned to the start edge (top, left), where its text begins.
+ */
+export declare function shiftIntoViewport(box: PanelBox, viewport: {
+    width: number;
+    height: number;
+}, margin?: number): {
+    x: number;
+    y: number;
+};
+export interface ViewportPoint {
+    x: number;
+    y: number;
+}
+/**
+ * True when `point` lies in the triangle `a`, `b`, `c`, edges included. For
+ * the path a pointer takes from a trigger to its floating box: as long as it
+ * stays in the triangle between where it left and the near edge of the box,
+ * it is on its way there.
+ */
+export declare function insideTriangle(point: ViewportPoint, a: ViewportPoint, b: ViewportPoint, c: ViewportPoint): boolean;
+/** Where the panel fits, starting from the side asked for. */
+export declare function fitPanel(input: FitPanelInput): PanelFit;
+/** A fit that changes nothing: the panel where the CSS puts it, with no limits. */
+export declare function unfitted(block: PanelBlock, inline: PanelInline): PanelFit;
+export interface MeasureOptions {
+    margin?: number;
+    gap?: number;
+    flipBlock?: boolean;
+    flipInline?: boolean;
+    /** Overrides the anchor's own direction; `false` for a panel placed with `left`, not `inset-inline-start`. */
+    rtl?: boolean;
+    clip?: PanelBox | null;
+}
+/**
+ * Measures `panel` against `anchor` and returns its fit. Any limit already on
+ * the panel is lifted for the measurement, so the answer does not depend on
+ * the previous one. Call it before paint (from an effect) and apply the result.
+ */
+export declare function measureFit(anchor: Element, panel: HTMLElement, preferred: {
+    block: PanelBlock;
+    inline: PanelInline;
+}, options?: MeasureOptions): PanelFit;
+/**
+ * The nearest ancestor of `element` that clips what reaches outside it (any
+ * `overflow` but `visible`), with the box it clips to: its inside, without
+ * borders or scrollbars, in viewport coordinates. Null when only the viewport
+ * clips.
+ */
+export declare function clippingAncestor(element: Element): {
+    element: HTMLElement;
+    box: PanelBox;
+} | null;
+export interface PanelPlacement extends PanelFit {
+    /**
+     * Set when the panel has to leave a clipping ancestor to be seen: the
+     * `top`, `left` and `width` to give it with `position: fixed`. Null when
+     * it stays where the CSS puts it.
+     *
+     * The width is the one the panel has where the CSS puts it. A fixed box
+     * is sized against the viewport instead of the anchor, so without it the
+     * panel would change width as it leaves the box.
+     */
+    fixed: {
+        left: number;
+        top: number;
+        width: number;
+    } | null;
+}
+/**
+ * The fit of `panel`, with the nearest clipping ancestor of `anchor` taken
+ * into account.
+ *
+ * - The panel fits inside that ancestor on the side asked for: nothing changes.
+ * - It fits on the other side: it opens there.
+ * - It fits on neither: it is placed against the viewport with `fixed`, on the
+ *   side the viewport has room for, and reaches out of the ancestor. Only
+ *   while some of the anchor can be seen in the ancestor: scrolled out of it,
+ *   the anchor takes the panel with it.
+ * - It cannot be: something between the panel and that ancestor is the
+ *   containing block of fixed descendants (a `transform`, a `filter`). It then
+ *   opens on the side of the ancestor with more room, and is cut where that
+ *   ends. That is the limit of what a panel can do without leaving its place
+ *   in the DOM, and it stays there so that the keyboard, focus and a dialog's
+ *   focus trap treat it as part of what opened it.
+ */
+export declare function measurePlacement(anchor: Element, panel: HTMLElement, preferred: {
+    block: PanelBlock;
+    inline: PanelInline;
+}, options?: MeasureOptions): PanelPlacement;
+/**
+ * Calls `update` when the viewport changes size or anything outside `panel`
+ * scrolls, at most once a frame. Returns the function that stops it.
+ */
+export declare function watchViewport(update: () => void, panel?: Element | null): () => void;
+//# sourceMappingURL=fit-in-viewport.d.ts.map

package/dist/components/util/fit-in-viewport.d.ts.map

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

package/dist/components/util/focus-utils.d.ts

@@ -2,11 +2,84 @@
 /** From `app.css` `@layer components` — import the library/app stylesheet. */
 export declare const FOCUS_BRAND_CLASS = "focus-brand";
 export declare const FOCUS_NAV_CLASS = "focus-nav";
+/** Every dialog panel: `dialog` and `alertdialog` are both dialogs to a focus trap. */
+export declare const DIALOG_SELECTOR = "[role=\"dialog\"], [role=\"alertdialog\"]";
 export declare function getFocusableElements(container: HTMLElement): HTMLElement[];
+/** The region a `Toaster` renders its toasts in. */
+export declare const TOAST_REGION_SELECTOR = "[data-zabi-toaster]";
+/**
+ * Whether an event's target is in a toast. A toast is drawn over whatever is
+ * open, and a press on it is for the toast (to hold it, read it, dismiss it):
+ * a menu or a panel that closes on a press outside itself asks this first,
+ * and leaves a press on a toast alone.
+ */
+export declare function isInsideToastRegion(target: unknown): boolean;
+/**
+ * The controls of the toasts on screen. A toast is drawn over a modal
+ * overlay and can cover its buttons, so a focus trap that kept the keyboard
+ * out of it would leave no way to dismiss it: the trap takes these in, after
+ * the overlay's own controls.
+ */
+export declare function getToastFocusables(): HTMLElement[];
+/**
+ * One step of the Tab cycle of a modal overlay: through the controls of
+ * `container`, then through the toasts on screen, and round again. Focusables
+ * are looked up on every Tab, so what is added while the overlay is open is
+ * in the cycle. Focus that is nowhere in it goes to the first control.
+ */
+export declare function cycleTrappedFocus(container: HTMLElement, event: KeyboardEvent): void;
 /** Tab wraps first↔last inside `container`. Caller should pair with `saveFocus` / `returnFocus`. */
 export declare function trapFocus(container: HTMLElement): () => void;
 export declare function saveFocus(): void;
-/** Restores focus from the last `saveFocus`. Skips disconnected or unfocusable nodes. */
+/**
+ * Restores focus from the last `saveFocus`. If that element has left the
+ * document, the element that now has its id takes the focus instead (a
+ * dropzone swapped for its Change button, say); with neither, nothing happens.
+ */
 export declare function returnFocus(): void;
-export declare function focusFirstElement(container: HTMLElement): void;
+/**
+ * Moves focus into an overlay: to its first focusable element, or to the
+ * container itself when it has none (give the container `tabindex="-1"`), so
+ * focus never stays on the opener behind the backdrop.
+ *
+ * `preferred` is a CSS selector, looked up inside the container: the matching
+ * control takes focus instead of the first one, if it can take focus.
+ */
+export declare function focusFirstElement(container: HTMLElement, preferred?: string): void;
+/**
+ * Joins the stack of open modal overlays (Modal, SlideUp, a drawer).
+ *
+ * Every overlay shares one z-index, so without this the paint order is the
+ * DOM order, and an overlay opened later but placed earlier in the document
+ * opens behind the first. `depth` is 0 for the first overlay and one more than
+ * the highest open one after that: put it on the overlay root as
+ * `z-index: calc(var(--z-modal) + depth)`.
+ *
+ * `panel` is the element with the dialog role. Call this when the overlay
+ * opens, in the browser, and `leave()` when it closes.
+ */
+export declare function joinOverlayStack(panel: HTMLElement): {
+    depth: number;
+    leave: () => void;
+};
+/**
+ * Keeps a modal overlay in charge of the keyboard when focus has left it
+ * without a Tab: the focused control was disabled or removed and the browser
+ * dropped focus on `<body>`, where the overlay's own key handlers never hear
+ * the key, and Tab would walk the page behind it.
+ *
+ * While installed, a Tab pressed with focus outside every dialog moves focus
+ * to the first focusable element of `container` (or to `container` itself),
+ * and Escape calls `onEscape`. Only the overlay on top of the stack acts (the
+ * one opened last), so every open overlay can install its own. An overlay that
+ * has not called `joinOverlayStack` is added to the stack for as long as the
+ * recovery is installed.
+ *
+ * `container` is the panel with `role="dialog"` or `"alertdialog"` and
+ * `aria-modal="true"`. Call it when the overlay opens, in the browser, and call
+ * the returned function when it closes.
+ */
+export declare function recoverStrayFocus(container: HTMLElement, options?: {
+    onEscape?: (event: KeyboardEvent) => void;
+}): () => void;
 //# sourceMappingURL=focus-utils.d.ts.map

package/dist/components/util/focus-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"focus-utils.d.ts","sourceRoot":"","sources":["../../../src/components/util/focus-utils.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAE1F,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,gBAAgB,CAAC;AAC/C,eAAO,MAAM,eAAe,cAAc,CAAC;AAE3C,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,WAAW,GAAG,WAAW,EAAE,CAgB1E;AAED,oGAAoG;AACpG,wBAAgB,SAAS,CAAC,SAAS,EAAE,WAAW,GAAG,MAAM,IAAI,CA2C5D;AAKD,wBAAgB,SAAS,IAAI,IAAI,CAUhC;AAED,yFAAyF;AACzF,wBAAgB,WAAW,IAAI,IAAI,CAgBlC;AAED,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,WAAW,GAAG,IAAI,CAK9D"}
+{"version":3,"file":"focus-utils.d.ts","sourceRoot":"","sources":["../../../src/components/util/focus-utils.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAE1F,8EAA8E;AAC9E,eAAO,MAAM,iBAAiB,gBAAgB,CAAC;AAC/C,eAAO,MAAM,eAAe,cAAc,CAAC;AAE3C,uFAAuF;AACvF,eAAO,MAAM,eAAe,8CAA0C,CAAC;AAEvE,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,WAAW,GAAG,WAAW,EAAE,CAqB1E;AAED,oDAAoD;AACpD,eAAO,MAAM,qBAAqB,wBAAwB,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAK5D;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,WAAW,EAAE,CAKlD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI,CAiCpF;AAED,oGAAoG;AACpG,wBAAgB,SAAS,CAAC,SAAS,EAAE,WAAW,GAAG,MAAM,IAAI,CA2C5D;AASD,wBAAgB,SAAS,IAAI,IAAI,CAUhC;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAqBlC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAMlF;AAKD;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG;IAClD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,IAAI,CAAC;CACrB,CAWA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,WAAW,EACtB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAA;CAAO,GAC5D,MAAM,IAAI,CAgCZ"}

package/dist/components/util/hydration.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Controls that keep what a visitor chose before the page hydrated.
+ *
+ * A server-rendered page can be used before its scripts arrive: a checkbox
+ * can be ticked, a radio chosen. A component that writes `checked={…}` from
+ * its own state and listens for `change` loses that on hydration: Svelte sets
+ * `checked` from the state, which still says nothing was chosen.
+ *
+ * Svelte's own bindings do not. `bind:checked` and `bind:group` know when
+ * they run during hydration, compare the input with the markup the server
+ * sent (`defaultChecked`), and where they differ hand the input's state to
+ * the binding instead of overwriting it. They also put the binding back on a
+ * form reset. So the controls bind, and what they bind to is an accessor of
+ * their own: the place where a choice is taken in, by whatever road it came.
+ *
+ * `bind:group` takes only an identifier or a member expression, which is why
+ * this is an object with a `value` and not a pair of functions.
+ */
+/** What Svelte hands a group binding when no radio is checked: after a reset, or when hydration finds none. */
+export type NoChoice = null | undefined;
+/**
+ * The target of a radio's `bind:group={binding.value}`.
+ *
+ * `read` gives the chosen value; a radio is checked while its own value is
+ * that. `choose` is called when a radio was picked: by the user, or before
+ * hydration. `restore` is called with nothing chosen: a form is being reset
+ * (see `resetValueOf` for what to go back to).
+ */
+export declare function groupBinding<T>(read: () => T | NoChoice, choose: (value: T) => void, restore: () => void): {
+    value: T | NoChoice;
+};
+/**
+ * The value a group of radios goes back to on a form reset: that of the one
+ * whose `checked` attribute is set, in the type the component's options have
+ * (Svelte keeps it on the input as `__value`), or `undefined` when none is.
+ *
+ * It reads the attribute (`defaultChecked`), not `checked`: Svelte calls a
+ * binding's reset handler in a microtask after the `reset` event, and when a
+ * user pressed the reset button that is before the browser has reset
+ * anything. Svelte takes the `checked` attribute off a bound input once it
+ * has hydrated, so in practice a reset empties the group, as it does a bound
+ * native input.
+ */
+export declare function resetValueOf<T>(inputs: Iterable<HTMLInputElement | undefined>): T | undefined;
+//# sourceMappingURL=hydration.d.ts.map

package/dist/components/util/hydration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydration.d.ts","sourceRoot":"","sources":["../../../src/components/util/hydration.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,+GAA+G;AAC/G,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC;AAExC;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC1B,IAAI,EAAE,MAAM,CAAC,GAAG,QAAQ,EACxB,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC1B,OAAO,EAAE,MAAM,IAAI;WAGF,CAAC,GAAG,QAAQ;EAQhC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,gBAAgB,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,SAAS,CAK7F"}

package/dist/components/util/keyboard-inset.d.ts

@@ -0,0 +1,18 @@
+/**
+ * How much of the bottom of the page the on-screen keyboard covers.
+ *
+ * Browsers disagree on what a keyboard does. Some shrink the layout viewport,
+ * and everything pinned to the bottom moves up by itself. Others (iOS Safari,
+ * and Chrome on Android by default) leave the layout alone and only shrink
+ * the *visual* viewport, so a bar pinned to the bottom ends up behind the
+ * keyboard. The difference between the two viewports is the part to lift a
+ * bar by; where the layout has already shrunk, it is 0.
+ */
+/** The covered height in px, or 0 where it cannot be told (the server, an old browser). */
+export declare function readKeyboardInset(): number;
+/**
+ * Calls `onChange` with the inset now, and again whenever it changes. Call it
+ * in the browser; the returned function stops it.
+ */
+export declare function watchKeyboardInset(onChange: (inset: number) => void): () => void;
+//# sourceMappingURL=keyboard-inset.d.ts.map

package/dist/components/util/keyboard-inset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyboard-inset.d.ts","sourceRoot":"","sources":["../../../src/components/util/keyboard-inset.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,2FAA2F;AAC3F,wBAAgB,iBAAiB,IAAI,MAAM,CAU1C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,MAAM,IAAI,CAoBhF"}

package/dist/components/util/media-grid.d.ts

@@ -0,0 +1,51 @@
+/** Types and pure helpers for `MediaGrid`. Kept out of the component so they can be tested without a DOM. */
+export type MediaGridKey = string | number;
+export type MediaGridItemType = "image" | "video";
+/** Payload of `onselect`. */
+export interface MediaGridSelectDetail<T> {
+    item: T;
+    /** False when the activation cleared the item's selection. */
+    selected: boolean;
+    /** Every selected key after the change: one or none unless `multiple`. */
+    keys: MediaGridKey[];
+}
+/** Every built-in string. Pass a partial object to `strings` to translate. */
+export interface MediaGridStrings {
+    /** Accessible name of an item's delete button. */
+    deleteLabel: (label: string) => string;
+    /** Accessible name of a video item; an image is named by its label alone. */
+    videoLabel: (label: string) => string;
+    /** Announced, and never shown, while `loading` is set. */
+    loading: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    /**
+     * How to get around by keyboard. Read once when focus enters the grid,
+     * and shown below it while it has keyboard focus. Keep it to one short
+     * sentence.
+     */
+    keyboardHint: string;
+}
+export declare const MEDIA_GRID_STRINGS: MediaGridStrings;
+export { isVideoUrl } from "./media.js";
+/**
+ * Columns in the rendered grid, read from the top edge of each tile in DOM
+ * order: the first row ends where the top edge changes. The layout is CSS
+ * `auto-fill`, so only the browser knows the answer.
+ */
+export declare function columnCount(tops: readonly number[]): number;
+export type MediaGridMove = "left" | "right" | "up" | "down" | "rowStart" | "rowEnd" | "first" | "last";
+/**
+ * Index a navigation key lands on. Nothing wraps. Moving down from the row
+ * above a short last row lands on the last item, so the last row can always
+ * be reached from any column.
+ */
+export declare function moveIndex(index: number, move: MediaGridMove, columns: number, total: number): number;
+/**
+ * The move a key asks for in a grid of tiles, or undefined for a key that is
+ * not a navigation key. Left and Right follow what is on screen, which is
+ * mirrored in a right-to-left layout; Ctrl with Home or End goes to the first
+ * or last tile. Shared by `MediaGrid` and `PhotoGrid`.
+ */
+export declare function moveForKey(event: Pick<KeyboardEvent, "key" | "ctrlKey">, rtl: boolean): MediaGridMove | undefined;
+//# sourceMappingURL=media-grid.d.ts.map

package/dist/components/util/media-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-grid.d.ts","sourceRoot":"","sources":["../../../src/components/util/media-grid.ts"],"names":[],"mappings":"AAAA,6GAA6G;AAE7G,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,CAAC;AAE3C,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,OAAO,CAAC;AAElD,6BAA6B;AAC7B,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACpC,IAAI,EAAE,CAAC,CAAC;IACR,8DAA8D;IAC9D,QAAQ,EAAE,OAAO,CAAC;IAClB,0EAA0E;IAC1E,IAAI,EAAE,YAAY,EAAE,CAAC;CACxB;AAED,8EAA8E;AAC9E,MAAM,WAAW,gBAAgB;IAC7B,kDAAkD;IAClD,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACvC,6EAA6E;IAC7E,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACtC,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;CACxB;AAED,eAAO,MAAM,kBAAkB,EAAE,gBAOhC,CAAC;AAGF,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAK3D;AAED,MAAM,MAAM,aAAa,GACnB,MAAM,GACN,OAAO,GACP,IAAI,GACJ,MAAM,GACN,UAAU,GACV,QAAQ,GACR,OAAO,GACP,MAAM,CAAC;AAEb;;;;GAIG;AACH,wBAAgB,SAAS,CACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,aAAa,EACnB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACd,MAAM,CAyBR;AASD;;;;;GAKG;AACH,wBAAgB,UAAU,CACtB,KAAK,EAAE,IAAI,CAAC,aAAa,EAAE,KAAK,GAAG,SAAS,CAAC,EAC7C,GAAG,EAAE,OAAO,GACb,aAAa,GAAG,SAAS,CAQ3B"}

package/dist/components/util/media.d.ts

@@ -0,0 +1,6 @@
+/** How the library tells a video from an image by its address. Shared by `ImageUpload` and `MediaGrid`. */
+/** True for a path or file name with a video extension, before any query or hash. */
+export declare function isVideoPath(path: string): boolean;
+/** True for a video data URL, or a URL whose path has a video extension. */
+export declare function isVideoUrl(url: string): boolean;
+//# sourceMappingURL=media.d.ts.map

package/dist/components/util/media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../src/components/util/media.ts"],"names":[],"mappings":"AAAA,2GAA2G;AAI3G,qFAAqF;AACrF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD;AAED,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE/C"}

package/dist/components/util/overlay-chrome.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The chrome of an overlay at large text: the header of a BottomSheet, Drawer,
+ * Modal or SlideUp, and the padding of its footer.
+ *
+ * Tailwind's spacing is in rem, so at `html { font-size: 200% }` the gutters,
+ * the gap above the title, the title and the close button all doubled. On a
+ * phone that left a third of a half-height sheet to what the sheet was opened
+ * for. This is navigation chrome, as the app bar is (see AppBar): it says
+ * where you are and how to leave, and it is not what the user enlarged the
+ * text to read. So it is laid out in px, and its title grows to 1.3 times its
+ * size and stops. The content, and whatever the app puts in the footer, scale
+ * in full. docs/ACCESSIBILITY.md has the reasoning against WCAG 1.4.4.
+ */
+/**
+ * On the header box: the spacing scale in px for everything inside it, so
+ * `px-6`, `gap-4`, `size-8` and the 44px of `TOUCH_HIT_AREA` are the sizes
+ * they are at 100% text. Only for a box that holds chrome alone: an app's
+ * Button inside it would stop growing too, which is why a footer spells its
+ * padding out in px instead.
+ */
+export declare const OVERLAY_CHROME = "[--spacing:4px]";
+/**
+ * How a title wraps: onto as many lines as it needs, between words, and a
+ * word wider than the whole line is cut rather than left sticking out.
+ */
+export declare const OVERLAY_TITLE_WRAP = "[overflow-wrap:break-word]";
+/**
+ * On the title while the text is enlarged (`textIsEnlarged`): a word that does
+ * not fit at the end of a line is hyphenated by the rules of the page's
+ * `lang`, where the browser has them, before it is cut.
+ *
+ * Not at the default text size, and not narrowed with `hyphenate-limit-chars`:
+ * `hyphens: auto` hyphenates at the end of every line, not only where a word
+ * is too wide, and what a browser offers as a hyphenation point is the
+ * platform's ("sett-ings", "histor-y" in Chromium on macOS). A title that
+ * wraps between words today would get those. A limit, where it is supported
+ * at all (not in Safari), turns a hyphenated break of a shorter word into a
+ * plain cut.
+ */
+export declare const OVERLAY_TITLE_HYPHENS = "hyphens-auto";
+/**
+ * Whether the reader has enlarged the text: the root font size is above the
+ * 16px every browser starts from. Read when an overlay opens. False on the
+ * server and until then, which is the layout at the default size.
+ */
+export declare function textIsEnlarged(): boolean;
+/** A title of 20px (`text-xl`): up to 26px, on the same 1.4 line. */
+export declare const OVERLAY_TITLE_XL = "text-[length:min(1.25rem,26px)] leading-[1.4]";
+/** A title of 24px (`text-2xl`): up to 31.2px, on the same 4/3 line. */
+export declare const OVERLAY_TITLE_2XL = "text-[length:min(1.5rem,31.2px)] leading-[calc(4/3)]";
+/** The "×" of a close button: a control, so the size it is at 100%. */
+export declare const OVERLAY_CLOSE_GLYPH = "text-[24px] leading-[32px]";
+//# sourceMappingURL=overlay-chrome.d.ts.map

package/dist/components/util/overlay-chrome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay-chrome.d.ts","sourceRoot":"","sources":["../../../src/components/util/overlay-chrome.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,oBAAoB,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,+BAA+B,CAAC;AAE/D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,iBAAiB,CAAC;AAEpD;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAGxC;AAED,qEAAqE;AACrE,eAAO,MAAM,gBAAgB,kDAAkD,CAAC;AAEhF,wEAAwE;AACxE,eAAO,MAAM,iBAAiB,yDAAyD,CAAC;AAExF,uEAAuE;AACvE,eAAO,MAAM,mBAAmB,+BAA+B,CAAC"}

package/dist/components/util/overlay.d.ts

@@ -0,0 +1,72 @@
+/**
+ * What Modal, SlideUp and Drawer share beyond `focus-utils.ts`: the scroll
+ * lock on `<body>` and the Tab cycle inside the panel. One copy, so the
+ * overlays cannot drift apart and keep working when nested in any order.
+ */
+/**
+ * Stops the page behind an overlay from scrolling. Ref-counted on `<body>`
+ * (`data-zabi-scroll-lock`), so nested overlays share one lock and the page
+ * scrolls again only when the last one has released it.
+ *
+ * Call it when the overlay opens, in the browser, and call the returned
+ * function when it closes.
+ */
+export declare function lockBodyScroll(): () => void;
+/**
+ * Keeps Tab inside `container`: call it from the panel's `keydown` handler.
+ * Focusables are re-queried on every Tab, so content added while the overlay
+ * is open stays inside the cycle. A Tab that comes from a dialog nested in the
+ * container is left to that dialog. The toasts on screen are in the cycle too,
+ * after the container's own controls: see `getToastFocusables`.
+ */
+export declare function trapTabKey(container: HTMLElement | undefined, event: KeyboardEvent): void;
+/**
+ * Watches a scrolling box in an overlay and reports whether it has to be a
+ * Tab stop itself: true when its content is taller than it and holds nothing
+ * that can take focus, so the keyboard would otherwise have no way to scroll
+ * it. The answer changes with the viewport and with the content, so it is
+ * reported again whenever either does.
+ *
+ * Call it when the overlay opens, in the browser; the returned function stops it.
+ */
+export declare function watchScrollerNeedsFocus(box: HTMLElement, onChange: (needsFocus: boolean) => void): () => void;
+/**
+ * Keeps an overlay on the part of the screen the on-screen keyboard leaves.
+ *
+ * Where the keyboard covers the page instead of shrinking it (iOS Safari,
+ * Chrome on Android), a panel at the bottom of a `fixed inset-0` root ends up
+ * behind it, footer and all. This moves the root's bottom edge up to the top
+ * of the keyboard (and its top edge down, if the browser has panned the
+ * screen), so everything laid out against the root follows: a sheet's height,
+ * a pinned footer, a drawer's end. `data-keyboard-open` is set on the root
+ * meanwhile. The field that has focus is scrolled back into view once the
+ * root has its new size. Where the page shrinks by itself, nothing is done.
+ *
+ * The root is usually the backdrop as well: while it is moved, its dimming is
+ * carried on past its edges, so the page does not show undimmed where the
+ * keyboard was while that slides away.
+ *
+ * `root` is the overlay's outermost, fixed element. Call it when the overlay
+ * opens, in the browser; the returned function stops it and puts the root back.
+ */
+export declare function followKeyboard(root: HTMLElement): () => void;
+/**
+ * Says that `footer` is pinned to the bottom of an open overlay, so what is
+ * drawn over the overlays (the toast stack) can stay off it. Call it when the
+ * footer is rendered, in the browser; the returned function withdraws it.
+ */
+export declare function registerOverlayFooter(footer: HTMLElement): () => void;
+/**
+ * Says that `header` is the top of an open overlay and holds its close
+ * button, so the toast stack starts below it and never lies over the one
+ * control that always closes the overlay. Call it when the header is
+ * rendered, in the browser; the returned function withdraws it.
+ */
+export declare function registerOverlayHeader(header: HTMLElement): () => void;
+/** The footer of the overlay on top, if it has one. */
+export declare function topOverlayFooter(): HTMLElement | null;
+/** The header of the overlay on top, if it has one. */
+export declare function topOverlayHeader(): HTMLElement | null;
+/** Calls `listener` whenever a registered header or footer appears, goes, moves or changes size. */
+export declare function watchOverlayFooters(listener: () => void): () => void;
+//# sourceMappingURL=overlay.d.ts.map

package/dist/components/util/overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlay.d.ts","sourceRoot":"","sources":["../../../src/components/util/overlay.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH;;;;;;;GAOG;AACH,wBAAgB,cAAc,IAAI,MAAM,IAAI,CAkB3C;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,WAAW,GAAG,SAAS,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI,CAMzF;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACnC,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,GACxC,MAAM,IAAI,CAaZ;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,IAAI,CAuD5D;AAyDD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,IAAI,CAErE;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,IAAI,CAErE;AAWD,uDAAuD;AACvD,wBAAgB,gBAAgB,IAAI,WAAW,GAAG,IAAI,CAGrD;AAED,uDAAuD;AACvD,wBAAgB,gBAAgB,IAAI,WAAW,GAAG,IAAI,CAGrD;AAED,oGAAoG;AACpG,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAKpE"}