efficient-shell 7.75.0 → 8.0.0

package/dist/forms/imageFocus.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The maths behind "which part of this picture survives the crop", as plain
+ * functions — `ImageFocusPoint`'s, and any host's that reads the value.
+ *
+ * Moved in from efficient-web-builder's `lib/image-focus.ts` (harness UI-24)
+ * without a change to what it reads or writes.
+ *
+ * THE VALUE IS A CSS `object-position` STRING, AND THAT IS ALL IT IS. A host
+ * stores it and renders it straight into `style={{ objectPosition }}`, so
+ * `"38% 64%"` is legal data and legal CSS. Nothing here migrates anything: the
+ * nine values the old 3×3 grid wrote (`"0% 0%"` … `"100% 100%"`) round-trip
+ * through these functions unchanged.
+ *
+ * A module of its own, not helpers inside the component: none of this needs
+ * React or a DOM, so a test can drive the keyboard path and the pointer maths
+ * with no renderer at all.
+ *
+ * ── The shape this reads and writes ─────────────────────────────────────────
+ * `"<x>% <y>%"`, two whole numbers from 0 to 100, origin top-left — exactly
+ * what `FOCAL_DEFAULT` is. `object-position` also takes keywords (`left top`)
+ * and lengths (`12px 4rem`); nothing has ever written one here, so a value
+ * this cannot read is the CENTRE rather than half of a point nobody chose.
+ */
+/** The picture's centre — also the browser's own `object-position` default. */
+declare const FOCAL_DEFAULT = "50% 50%";
+/** One press of an arrow key, in percent. */
+declare const FOCAL_NUDGE_STEP = 1;
+/** …and one press with Shift held: ten presses cross the picture, not a hundred. */
+declare const FOCAL_NUDGE_COARSE = 10;
+interface FocalPoint {
+    /** 0 (left edge) … 100 (right edge). */
+    x: number;
+    /** 0 (top edge) … 100 (bottom edge). */
+    y: number;
+}
+/**
+ * A stored `object-position` string, as a point. Anything that is not two
+ * percentages is the centre — what `FOCAL_DEFAULT` says and what the browser
+ * draws for an absent value, so the dot agrees with the page.
+ */
+declare function parseFocal(value?: string | null): FocalPoint;
+/** A point, as the string that is stored. ONE shape, so a point set by the
+ *  keyboard and the same point set by a press are the same bytes. */
+declare function formatFocal(x: number, y: number): string;
+/**
+ * The keyboard path: the moved value for an arrow key, `null` for any other
+ * key. `null` and not the unchanged value, because the caller uses it to decide
+ * whether to take the key at all — a control that ate Tab could not be left.
+ */
+declare function nudgeFocal(value: string | undefined | null, key: string, coarse?: boolean): string | null;
+/**
+ * The pointer path: where a press landed, as a point on the picture.
+ *
+ * `rect` is the PICTURE's own box, never the frame around it. The picture is
+ * shown whole, so it is letterboxed inside its frame, and measuring against the
+ * frame would put the dot on a different pixel for every shape of picture.
+ *
+ * Clamped, because a drag carries on outside the picture (the pointer is
+ * captured) and `-14% 130%` is a value nobody can see or meant. A picture with
+ * no size yet answers the centre rather than `NaN`.
+ */
+declare function focalFromRect(rect: {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}, clientX: number, clientY: number): FocalPoint;
+
+export { FOCAL_DEFAULT, FOCAL_NUDGE_COARSE, FOCAL_NUDGE_STEP, type FocalPoint, focalFromRect, formatFocal, nudgeFocal, parseFocal };

package/dist/forms/imageFocus.js

@@ -0,0 +1 @@
+export{FOCAL_DEFAULT,FOCAL_NUDGE_COARSE,FOCAL_NUDGE_STEP,focalFromRect,formatFocal,nudgeFocal,parseFocal}from"../chunk-25RR3GQW.js";

package/dist/forms/keypadInput.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The rules for typing a decimal amount on an on-screen keypad — pure string
+ * functions, no React and no DOM.
+ *
+ * Split out for the same reason as `selectNav.ts`: these are the rules people
+ * actually get wrong, and they are far easier to pin exhaustively as functions
+ * than by rendering a keypad and firing clicks at it.
+ *
+ * A STRING, not a number, all the way through. `'1.'` and `'1.0'` are states a
+ * user passes through while typing and neither survives a round trip through a
+ * float — `'1.'` would become `1` and erase the decimal point the moment it was
+ * pressed. The caller converts once, at the end, when it has a whole amount.
+ */
+/** Digits after the point. Two, because these are money amounts. */
+declare const MAX_FRACTION_DIGITS = 2;
+/**
+ * Apply one keypress. `key` is a digit `'0'`-`'9'` or `'.'`.
+ * Returns the value unchanged when the press is not allowed, so a caller can
+ * always assign the result — an ignored key is a no-op, never an error.
+ */
+declare function appendKey(value: string, key: string): string;
+/** Remove the last character. Empty stays empty rather than underflowing. */
+declare function backspace(value: string): string;
+
+export { MAX_FRACTION_DIGITS, appendKey, backspace };

package/dist/forms/keypadInput.js

@@ -0,0 +1 @@
+export{MAX_FRACTION_DIGITS,appendKey,backspace}from"../chunk-VEPVOHCV.js";

package/dist/forms/linkHref.d.ts

@@ -0,0 +1 @@
+export { isSafeLinkHref } from '../markup/index.js';

package/dist/forms/linkHref.js

@@ -0,0 +1 @@
+import"../chunk-UJUTS6LJ.js";export{isSafeLinkHref}from"../chunk-PJPK2ADX.js";

package/dist/forms/settingRowContext.d.ts

@@ -0,0 +1,16 @@
+import * as react from 'react';
+
+declare const InSettingRowContext: react.Context<boolean>;
+declare function useInSettingRow(): boolean;
+/**
+ * Whether the row's value is AUTO in this view (S7: V2 2026-10-09, D3
+ * 2026-10-12) — `SettingRow viewState="auto"`. ONE prop on the row, and the
+ * controls in its value (`InputNumber`, `Select`, `Slider`) wear the auto look
+ * from it, so a host never says "auto" twice. A control's own `auto` prop wins
+ * (`auto={false}` keeps one control solid in an auto row). Outside an auto row
+ * it is `false`.
+ */
+declare const SettingAutoContext: react.Context<boolean>;
+declare function useSettingAuto(): boolean;
+
+export { InSettingRowContext, SettingAutoContext, useInSettingRow, useSettingAuto };

package/dist/forms/settingRowContext.js

@@ -0,0 +1,2 @@
+"use client";
+export{InSettingRowContext,SettingAutoContext,useInSettingRow,useSettingAuto}from"../chunk-E4Z5OXBI.js";

package/dist/forms/showWhenRule.d.ts

@@ -0,0 +1,142 @@
+/**
+ * showWhen — the ONE rule for "show this settings row only when another
+ * setting has a value".
+ *
+ * ── Why it exists ──
+ * The same idea was written by hand in about 70 places across the shell, the
+ * website editor, the blocks and the email designer: a `resolveFields` that
+ * deletes keys, a panel's `{a && <Row/>}`, one helper per family of sections.
+ * Every copy decided on its own what "on" meant (`=== true`? truthy?
+ * trimmed?) and what an unset value counted as. Lewis ruled on 2026-10-17 that
+ * the rule lives here, once, and every panel reads it.
+ *
+ * ── Why it is data ──
+ * A rule is a plain object, with no functions in it, so it can sit on a field
+ * definition next to the field's label, be stored, be compared and be read by
+ * a check. `isShown` is the only thing that decides what it means.
+ *
+ * ── The shape ──
+ *   { field: "country_selector_enabled", is: true }     one stored value equals
+ *   { field: "layout", in: ["tabs", "count"] }           …is one of
+ *   { field: "src", set: true }                          …holds anything at all
+ *   { field: "mediaType", is: "image", default: "image" }  an unset field counts as "image"
+ *   { field: "source.slug", set: true }                  a dotted name reads into an object
+ *   { context: "parentType", in: ["Flex"] }              where the row is, not what it stores
+ *   { not: rule }   { all: [rule, …] }   { any: [rule, …] }
+ *
+ * `set` counts as nothing: `undefined`, `null`, `false`, an empty or blank
+ * string, an empty list. Everything else is set — `0` included, because 0 is a
+ * real answer (a gap of 0 pins two things together).
+ *
+ * ── A hidden row keeps its value ──
+ * Hiding is drawing, never writing. Nothing here touches the values it reads,
+ * and nothing that uses it may clear a hidden field: a merchant who switches
+ * the selector off and on again finds what they had.
+ *
+ * ── A rule it cannot read shows the row ──
+ * Rules may come from storage. A row hidden by a rule nobody can read is a
+ * setting nobody can reach; a row shown by mistake is only noise.
+ */
+/** A value a rule can compare against. */
+type ShowWhenValue = string | number | boolean | null;
+/** What a check reads: a stored setting, or a fact about where the row is. */
+type ShowWhenSource = {
+    field: string;
+    context?: never;
+} | {
+    context: string;
+    field?: never;
+};
+/** The one test a check makes. */
+type ShowWhenTest = {
+    is: ShowWhenValue;
+    in?: never;
+    set?: never;
+} | {
+    in: readonly ShowWhenValue[];
+    is?: never;
+    set?: never;
+} | {
+    set: boolean;
+    is?: never;
+    in?: never;
+};
+/** One check on one value. */
+type ShowWhenCheck = ShowWhenSource & ShowWhenTest & {
+    /** Used in place of the value when it holds nothing (`undefined` or `null`). */
+    default?: ShowWhenValue;
+};
+/** When a settings row is shown. See the file's header for the shapes. */
+type ShowWhenRule = ShowWhenCheck | {
+    not: ShowWhenRule;
+} | {
+    all: readonly ShowWhenRule[];
+} | {
+    any: readonly ShowWhenRule[];
+};
+/** The facts about where a row is drawn — e.g. `{ parentType: "Flex" }`. */
+type ShowWhenContext = Readonly<Record<string, unknown>>;
+/**
+ * Whether a row with this rule is shown, given the stored values and where the
+ * row is. No rule: shown. Never writes to `values` or `context`.
+ */
+declare function isShown(rule: ShowWhenRule | null | undefined, values: Readonly<Record<string, unknown>> | null | undefined, context?: ShowWhenContext | null | undefined): boolean;
+/** A field definition that may say when it is shown. */
+type WithShowWhen = {
+    showWhen?: ShowWhenRule;
+};
+/**
+ * The same field, carrying `showWhen`. Its own type is kept, so it still fits
+ * whatever field map it goes into. The field passed in is not changed.
+ */
+declare function withShowWhen<F extends object>(field: F, rule: ShowWhenRule): F;
+/** The rule a field carries, if any. */
+declare function showWhenOf(field: unknown): ShowWhenRule | undefined;
+declare function withRowsShownWhen<T extends Record<string, unknown>>(fields: T, keys: readonly string[], rule: ShowWhenRule): T;
+/** One line of a panel's rule table: these rows, shown while this rule holds. */
+type RowRule = readonly [keys: readonly string[], rule: ShowWhenRule];
+/** The panel with each line of `table` applied, in order (`withRowsShownWhen`). */
+declare function withRowRules<T extends Record<string, unknown>>(fields: T, table: readonly RowRule[]): T;
+/**
+ * On, the way code reads a stored value with `if (value)` or `||`: every value
+ * a stored document can hold is truthy except `false`, `0`, `""` and `null`,
+ * or no value at all. (`set` is a different question: it counts `0` as set and
+ * a blank string as nothing.)
+ */
+declare function truthy(field: string): ShowWhenRule;
+/**
+ * Shown for some values of an option field, read the way the code that draws
+ * it parses the option: a value outside `known` falls back to `fallback`. So
+ * a stored value nobody knows shows the row exactly when the fallback does.
+ */
+declare function shownForOption(field: string, known: readonly string[], fallback: string, shownFor: readonly string[]): ShowWhenRule;
+/** What a fact reads: the node, as an editor's resolver is handed it. */
+type ShowWhenFactData = {
+    props?: Record<string, unknown>;
+};
+/** A block's facts, by name. `P` is what the editor hands a resolver beside the node. */
+type ShowWhenFacts<P = unknown> = Readonly<Record<string, (data: ShowWhenFactData, params: P) => unknown>>;
+/** A block that may name facts of its own. */
+type WithShowWhenFacts<P = unknown> = {
+    showWhenFacts?: ShowWhenFacts<P>;
+};
+/**
+ * A context whose entries are read only when a rule asks for them, and each at
+ * most once per read: a fact may walk a document, and most rules never ask.
+ */
+declare function lazyShowWhenContext(readers: Readonly<Record<string, () => unknown>>): ShowWhenContext;
+/** A block's facts as readers for one node (for a context with facts of its own). */
+declare function showWhenFactReaders<P>(facts: ShowWhenFacts<P> | undefined, data: ShowWhenFactData, params: P): Record<string, () => unknown>;
+/** What a block's `{ context }` rules read for one node: its facts. */
+declare function showWhenFactsContext<P>(facts: ShowWhenFacts<P> | undefined, data: ShowWhenFactData, params: P): ShowWhenContext;
+/**
+ * The same block with these facts added; a fact it names already is kept. The
+ * block passed in is not changed, and its own type is kept (so a component
+ * config literal takes facts its editor's type does not list).
+ */
+declare function withShowWhenFacts<B extends object, P = unknown>(block: B, facts: ShowWhenFacts<P>): B & WithShowWhenFacts<P>;
+/** Add facts to a block in place (a pass that rebuilds a registry's blocks); a
+ *  fact it names already is kept. */
+declare function addShowWhenFacts<P = unknown>(block: object, facts: ShowWhenFacts<P>): void;
+
+export { type RowRule, type ShowWhenCheck, type ShowWhenContext, type ShowWhenFactData, type ShowWhenFacts, type ShowWhenRule, type ShowWhenValue, type WithShowWhen, type WithShowWhenFacts, addShowWhenFacts, isShown, lazyShowWhenContext, showWhenFactReaders, showWhenFactsContext, showWhenOf, shownForOption, truthy, withRowRules, withRowsShownWhen, withShowWhen, withShowWhenFacts };

package/dist/forms/showWhenRule.js

@@ -0,0 +1 @@
+export{addShowWhenFacts,isShown,lazyShowWhenContext,showWhenFactReaders,showWhenFactsContext,showWhenOf,shownForOption,truthy,withRowRules,withRowsShownWhen,withShowWhen,withShowWhenFacts}from"../chunk-HCP7WOAL.js";

package/dist/forms/styles.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Shared form-control styling — the single source of truth for the kit's
+ * text-input look. Promoted out of SearchableSelect so every form control
+ * (Input, Textarea, Select, SearchableSelect) renders identically and picks
+ * up the same `[data-theme="dark"]` input remaps from styles.css.
+ *
+ * Keep this in the documented Tailwind vocabulary (see .design-sync/conventions.md)
+ * so the classes survive both the dark-mode allow-list and the design-sync
+ * compiled stylesheet.
+ */
+/**
+ * The look of a filter that is ON, written once: the accent border and the
+ * light accent fill. A `FilterBar` chip, a `DateRangePicker` chip and a
+ * filter field (`INPUT_BASE_ON`) all wear it. Duplicate scan, 2026-10-13: it
+ * had been written four times. tests/filterOnOneSource.test.ts holds it here.
+ */
+declare const FILTER_ON = "border-blue-400 bg-blue-50";
+/** The ink of a filter CHIP that is on: it says its value in the accent. A
+ *  filter field that is on keeps an ordinary field's ink. */
+declare const FILTER_ON_INK = "text-blue-700";
+/** A filter CHIP that is off: grey frame, grey ink, and a darker frame on
+ *  hover. `FilterBar`'s chips and `DateRangePicker`'s chip wear it. */
+declare const FILTER_OFF = "border-gray-300 text-gray-600 hover:border-gray-400";
+/**
+ * The ink of a field's placeholder or hint, and of the icon that sits in the
+ * field beside it (a search glass, a date icon, a select's arrow): that icon's
+ * words are the placeholder, so it is the placeholder's colour (an icon is the
+ * colour of its words; GG, 2026-10-13). Use this token for such an icon, never
+ * a grey written again. `INPUT_SHAPE_POST` spells `placeholder:text-gray-400`
+ * out in full because Tailwind only generates a class it can read in the
+ * source; tests/iconInkFollowsWords.test.tsx holds the two to the same grey.
+ */
+declare const PLACEHOLDER_INK = "text-gray-400";
+/** `sm`/`md`/`lg` are the desktop ladder; `touch` is a finger on glass. See
+ *  ButtonSize for why touch is a separate rung rather than the top of this
+ *  ladder — a till's idea of "large" is 56px, and one word cannot mean both. */
+type InputSize = 'sm' | 'md' | 'lg' | 'touch';
+declare const INPUT_SIZES: Record<InputSize, string>;
+/** Base look for a text-bearing form control. Native <input>/<select>/<textarea>
+ *  also receive dark styling for free via the global rule in styles.css. */
+declare const INPUT_BASE: string;
+/** `INPUT_BASE` for a filter that is on — see `INPUT_SHAPE_PRE_ON`. Not part
+ *  of the package's exports: `SearchableSelect`'s `filter` is the way in. */
+declare const INPUT_BASE_ON: string;
+/** Error-state ring/border, layered on top of INPUT_BASE. The ring colour
+ *  competes with INPUT_BASE's on the same variant and wins by compiled order,
+ *  as the red border beats the gray one beside it — `tests/focusVisible.test.ts`
+ *  asserts that order in a real Tailwind build. */
+declare const INPUT_INVALID = "border-red-300 focus:border-red-400 focus-visible:ring-[color:var(--rosh-focus-ring-invalid)]";
+/** Disabled affordance — opacity-based so it stays correct in every theme. */
+declare const INPUT_DISABLED = "disabled:cursor-not-allowed disabled:opacity-60";
+/** Compose the input classes for a control. Omitting `size` — or passing the
+ *  default `md` — yields exactly `INPUT_BASE`, so every existing caller is
+ *  unaffected. */
+declare function inputClasses(opts?: {
+    invalid?: boolean;
+    size?: InputSize;
+    /** A box that grows with its content — a textarea, a tag field whose chips
+     *  wrap. It takes `INPUT_SIZES_MULTILINE`: padding, no fixed height. */
+    multiline?: boolean;
+    /** The read-only ground (`bg-gray-50`) in place of the field's white. */
+    readOnly?: boolean;
+    /** The AUTO look (S7): dashed edge, sunken ground, grey value — a value
+     *  this view works out rather than holds. Read-only wins over it. */
+    auto?: boolean;
+    className?: string;
+}): string;
+/**
+ * The rungs for a box that grows with what is in it: `Textarea`, and
+ * `TagInput`, whose chips wrap onto more lines. A fixed height would clip
+ * them, so these keep top and bottom padding — on the spacing scale (4 / 8 /
+ * 8) — and the same side padding and text size as the single-line rung of the
+ * same name. Touch is the single-line string, unchanged.
+ */
+declare const INPUT_SIZES_MULTILINE: Record<InputSize, string>;
+
+export { FILTER_OFF, FILTER_ON, FILTER_ON_INK, INPUT_BASE, INPUT_BASE_ON, INPUT_DISABLED, INPUT_INVALID, INPUT_SIZES, INPUT_SIZES_MULTILINE, type InputSize, PLACEHOLDER_INK, inputClasses };

package/dist/forms/styles.js

@@ -0,0 +1 @@
+export{FILTER_OFF,FILTER_ON,FILTER_ON_INK,INPUT_BASE,INPUT_BASE_ON,INPUT_DISABLED,INPUT_INVALID,INPUT_SIZES,INPUT_SIZES_MULTILINE,PLACEHOLDER_INK,inputClasses}from"../chunk-JFSYWEHD.js";

package/dist/forms/useFileIntake.d.ts

@@ -0,0 +1,94 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import { ReactNode, ChangeEvent, DragEvent, ClipboardEvent } from 'react';
+import { ShellStrings } from '../shell/strings.js';
+
+type FileRejectionReason = 'type' | 'size' | 'count';
+interface FileRejection {
+    file: File;
+    reason: FileRejectionReason;
+    /** Human sentence naming the file and the rule it broke. */
+    message: string;
+}
+interface FileIntakeLimits {
+    /**
+     * Native `accept` string — `image/*`, `.pdf,application/pdf`, … Enforced on
+     * EVERY gesture, not only the dialog: a dropped or pasted file that fails it
+     * is rejected with a reason. Empty or `*` accepts anything.
+     */
+    accept?: string;
+    /** Rejected above this many bytes, with the reason shown. */
+    maxSizeBytes?: number;
+    /** Rejected once this many files are held in total (see `currentCount`). */
+    maxFiles?: number;
+}
+interface FileIntakeOptions extends FileIntakeLimits {
+    /** Receives the files that passed every check. Never called with an empty list. */
+    onAccept: (files: File[]) => void;
+    /** `false` takes the first candidate only — a single slot. Default `true`. */
+    multiple?: boolean;
+    /** Files the surface already holds, so `maxFiles` counts the total. Default 0. */
+    currentCount?: number;
+    /** Short kind hint for the type-rejection sentence, e.g. "PNG · JPG". */
+    acceptHint?: ReactNode;
+    disabled?: boolean;
+}
+/**
+ * Does `file` satisfy a native `accept` string? Extension rules match the
+ * name, `type/*` rules match the MIME prefix, anything else is an exact MIME.
+ * A browser reports several media types for one `.ico` file and sometimes
+ * none at all, which is why an extension rule exists at all.
+ */
+declare function acceptsFile(file: File, accept?: string): boolean;
+/** `812 B`, `14 KB`, `6.2 MB` — the units, and their digits, from the catalog. */
+declare const humanSize: (bytes: number, strings?: ShellStrings["files"]) => string;
+/** Is this drag carrying files (as opposed to text, a URL, or an in-page reorder)? */
+declare const isFileDrag: (e: DragEvent) => boolean;
+/** Files on a clipboard event, if the paste carried any. */
+declare function pastedFiles(e: ClipboardEvent): File[];
+declare function useFileIntake({ onAccept, accept, maxSizeBytes, maxFiles, multiple, currentCount, acceptHint, disabled, }: FileIntakeOptions): {
+    inputRef: react.RefObject<HTMLInputElement>;
+    inputProps: {
+        ref: react.RefObject<HTMLInputElement>;
+        type: "file";
+        accept: string | undefined;
+        multiple: boolean;
+        disabled: boolean;
+        tabIndex: number;
+        'aria-hidden': true;
+        className: string;
+        onChange: (e: ChangeEvent<HTMLInputElement>) => void;
+    };
+    zoneProps: {
+        onDragEnter?: undefined;
+        onDragOver?: undefined;
+        onDragLeave?: undefined;
+        onDrop?: undefined;
+    } | {
+        onDragEnter: (e: DragEvent) => void;
+        onDragOver: (e: DragEvent) => void;
+        onDragLeave: (e: DragEvent) => void;
+        onDrop: (e: DragEvent) => void;
+    };
+    pasteProps: {
+        onPaste?: undefined;
+    } | {
+        onPaste: (e: ClipboardEvent) => void;
+    };
+    open: () => void;
+    take: (incoming: FileList | File[] | null | undefined) => void;
+    dragOver: boolean;
+    rejections: FileRejection[];
+    clearRejections: () => void;
+};
+/**
+ * The rejection list, announced. `role="alert"` is what tells a screen-reader
+ * user why the drop did nothing; the sighted user sees the same sentences.
+ * Renders nothing while there is nothing to say.
+ */
+declare function FileIntakeAlert({ rejections, className }: {
+    rejections: FileRejection[];
+    className?: string;
+}): react_jsx_runtime.JSX.Element | null;
+
+export { FileIntakeAlert, type FileIntakeLimits, type FileIntakeOptions, type FileRejection, type FileRejectionReason, acceptsFile, humanSize, isFileDrag, pastedFiles, useFileIntake };

package/dist/forms/useFileIntake.js

@@ -0,0 +1,2 @@
+"use client";
+export{FileIntakeAlert,acceptsFile,humanSize,isFileDrag,pastedFiles,useFileIntake}from"../chunk-PZRKVGML.js";import"../chunk-5LHPDU6X.js";import"../chunk-C3QOHMR6.js";

package/dist/hooks/useClickOutside.d.ts

@@ -0,0 +1,5 @@
+import { RefObject } from 'react';
+
+declare function useClickOutside(ref: RefObject<HTMLElement | null>, onClose: () => void): void;
+
+export { useClickOutside as default };

package/dist/hooks/useClickOutside.js

@@ -0,0 +1,2 @@
+"use client";
+export{useClickOutside as default}from"../chunk-SI26KESU.js";

package/dist/hooks/useDebouncedValue.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The value, settled: it changes only after `delay` ms (300 by default) with no
+ * new change. Feed the settled value into a search query or a query key, not
+ * the raw one, so typing does not send a request per key.
+ */
+declare function useDebouncedValue<T>(value: T, delay?: number): T;
+
+export { useDebouncedValue as default };

package/dist/hooks/useDebouncedValue.js

@@ -0,0 +1,2 @@
+"use client";
+export{useDebouncedValue as default}from"../chunk-SLGT5WPJ.js";

package/dist/hooks/useTheme.d.ts

@@ -0,0 +1,75 @@
+type Theme = 'system' | 'light' | 'dark' | 'pink' | 'green' | 'grey' | 'blue';
+/** Resolve a stored theme to the attribute value <html> actually carries
+ *  ('system' follows the OS dark-mode media query, and is 'light' on a server,
+ *  which has no OS setting to follow). */
+declare function resolveTheme(theme: string | null | undefined): string;
+/**
+ * How round the kit's corners are: a person's own setting, beside the colour
+ * theme. 'soft' is the kit as it has always been drawn.
+ */
+type Corners = 'square' | 'soft' | 'round';
+declare const CORNERS: readonly Corners[];
+/** A stored value to a setting. Anything that is not one, unset included, is 'soft'. */
+declare function resolveCorners(corners: unknown): Corners;
+/**
+ * The corners a colour theme (its `data-theme` key) brings, like its icon set
+ * (Victor Mau, 2026-10-14): Blossom is round, Quicksilver square. A theme not
+ * listed is soft.
+ */
+declare const CORNERS_FOR_THEME: Readonly<Record<string, Corners>>;
+/**
+ * The corners the page draws with. A colour theme decides its own (Victor
+ * Mau, 2026-10-14: the Corners setting is offered only on the Custom theme);
+ * on Custom (`custom`, an accent colour set) the user's own setting draws,
+ * soft until they pick one. `theme` is the resolved `data-theme` key. A
+ * setting picked on Custom is kept, and draws again when Custom is chosen.
+ */
+declare function cornersFor(theme: string, chosen: unknown, custom: boolean): Corners;
+/**
+ * Stamp the corners setting on <html>, where `ui.css` reads it.
+ *
+ * 'soft' REMOVES the attribute rather than writing it. With no attribute none
+ * of the corner rules apply, so the radii are the scale's own and a host's
+ * `@theme` still decides them: the default costs nothing and changes nothing.
+ */
+declare function applyCorners(corners: unknown): void;
+/**
+ * Choose the icon set the theme draws with (`null` or unset for the host's
+ * default). The registry does the work: every `<Icon>` on the page redraws.
+ * `data-icon-set` is stamped beside `data-theme` and `data-corners` for a
+ * host's own CSS, and removed when nothing is chosen.
+ */
+declare function applyIconSet(iconSet: unknown): void;
+/**
+ * Imperatively apply a theme/accent/custom-color prefs snapshot to <html>.
+ *
+ * useTheme() already reconciles these from prefs, but it does so via effects
+ * that only fire once prefs actually changes — and a backend-backed prefs
+ * adapter (the admin/supplier portals PATCH /auth/me/ and refetch) can take
+ * seconds to settle, leaving the repaint stalled the whole time. The shell's
+ * <Customization> calls this on every theme/accent/color click so the switch
+ * lands on the same frame, then persists through save() in the background.
+ */
+declare function applyThemePrefs(p: {
+    theme?: string | null;
+    accent_color?: string | null;
+    custom_bg_color?: string | null;
+    custom_title_color?: string | null;
+    custom_window_color?: string | null;
+    custom_button_color?: string | null;
+    /** The user's own corners, drawn only on the Custom theme. Left alone when the
+     *  key is absent: a caller that only knows colours (every caller before the
+     *  setting existed) must not reset the corners. */
+    corners?: string | null;
+    /** The user's own icon set, drawn only on the Custom theme. Left alone
+     *  when the key is absent, like `corners`. */
+    icon_set?: string | null;
+}): void;
+declare function useTheme(): {
+    theme: Theme;
+    resolved: "dark" | "light" | "blue" | "green" | "grey" | "pink";
+    corners: Corners;
+    iconSet: string | null;
+};
+
+export { CORNERS, CORNERS_FOR_THEME, type Corners, type Theme, applyCorners, applyIconSet, applyThemePrefs, cornersFor, resolveCorners, resolveTheme, useTheme };

package/dist/hooks/useTheme.js

@@ -0,0 +1,2 @@
+"use client";
+export{CORNERS,CORNERS_FOR_THEME,applyCorners,applyIconSet,applyThemePrefs,cornersFor,resolveCorners,resolveTheme,useTheme}from"../chunk-4LXH6DCN.js";import"../chunk-VQCKMT5F.js";import"../chunk-KC3EX26K.js";import"../chunk-J75ZT2JQ.js";import"../chunk-D65T4H6J.js";

package/dist/i18n/index.d.ts

@@ -1,5 +1,5 @@
 import { ResourceLanguage, i18n, TFunction } from 'i18next';
-import { S as ShellStringsOverride } from '../strings-Dh85JfDa.js';
+import { ShellStringsOverride } from '../shell/strings.js';
 import 'react/jsx-runtime';
 import 'react';