@trinityui/design-system 2.11.0 → 2.13.0

package/dist/hooks/storageStore.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview Internal storage store: an external store over localStorage or sessionStorage
+ * for `useSyncExternalStore` (B-55, ADR-35-R6, ADR-27 (1)).
+ * @module hooks/storageStore
+ *
+ * @internal Not part of the public API (ADR-02, ADR-35). It is not re-exported from
+ * `src/hooks.ts`, `src/index.ts` or any other entry; `useLocalStorage` and components import it
+ * from this file directly.
+ *
+ * Why a store: reading `window.localStorage` while rendering makes the server render (no storage)
+ * and the hydration render disagree. `useSyncExternalStore` renders the server snapshot during
+ * hydration and the client snapshot straight after it, and a client-only mount reads the client
+ * snapshot on its first render.
+ *
+ * The rules:
+ * - There is one store per storage area and key: `createStorageStore` returns the same object
+ *   for the same pair, so every caller shares the snapshot cache and the listeners. A write
+ *   through one caller re-renders every other caller in the same tab.
+ * - `getSnapshot` returns the parsed JSON value, or `undefined` when nothing usable is stored:
+ *   no item, the storage is unavailable, or the text is not JSON (warned once per text). The
+ *   result is cached by the raw text, so the reference stays the same until the text changes.
+ * - `getServerSnapshot` is always `undefined`: the server has no storage. Callers map
+ *   `undefined` to their initial value.
+ * - Other tabs reach it through the window `storage` event, including `clear()` (key `null`).
+ * - When a write fails (quota, a blocked storage), the value still changes for this page: the
+ *   store keeps the text in memory until the next successful write or storage event, and warns.
+ */
+/** @internal The browser storage a store reads. */
+export type StorageArea = 'local' | 'session';
+/** @internal The store `createStorageStore` returns; the shape `useSyncExternalStore` needs. */
+export interface StorageStore<T> {
+    /** Adds a listener for writes from this tab and from other tabs. Returns the unsubscribe. */
+    subscribe: (onChange: () => void) => () => void;
+    /** The parsed value, or `undefined` when nothing usable is stored. Stable until the text changes. */
+    getSnapshot: () => T | undefined;
+    /** Always `undefined`: the server has no storage. */
+    getServerSnapshot: () => T | undefined;
+    /** Stores the value as JSON and notifies every listener of this key. */
+    set: (value: T) => void;
+    /** Removes the key and notifies every listener of this key. */
+    remove: () => void;
+}
+/**
+ * @internal Returns the store for `key` in the given storage area (one per pair). Safe to call
+ * during render and on the server: nothing touches storage until a method runs.
+ *
+ * @param key - The storage key.
+ * @param area - `'local'` for localStorage, `'session'` for sessionStorage.
+ */
+export declare function createStorageStore<T>(key: string, area: StorageArea): StorageStore<T>;
+//# sourceMappingURL=storageStore.d.ts.map

package/dist/hooks/storageStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storageStore.d.ts","sourceRoot":"","sources":["../../src/hooks/storageStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,mDAAmD;AACnD,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,SAAS,CAAC;AAE9C,gGAAgG;AAChG,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,6FAA6F;IAC7F,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;IAChD,qGAAqG;IACrG,WAAW,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACjC,qDAAqD;IACrD,iBAAiB,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACvC,wEAAwE;IACxE,GAAG,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IACxB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAwFD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,YAAY,CAAC,CAAC,CAAC,CAiDrF"}

package/dist/hooks/useAsyncAction.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Where an async action is: not run yet (or reset), running, done, or failed.
+ * @since 2.13.0
+ */
+export type AsyncActionStatus = 'idle' | 'pending' | 'success' | 'error';
+/**
+ * What `run` resolves to. It never rejects.
+ * @since 2.13.0
+ */
+export type AsyncActionResult = {
+    status: 'success';
+} | {
+    status: 'error';
+    error: unknown;
+};
+/**
+ * Options of {@link useAsyncAction}.
+ * @since 2.13.0
+ */
+export interface UseAsyncActionOptions {
+    /**
+     * Called with the error when the action throws or rejects. Without it, the error is reported
+     * through `globalThis.reportError` (or re-thrown from a microtask).
+     */
+    onError?(error: unknown): void;
+    /**
+     * Messages announced to screen readers through `useAnnounce`: `pending` and `success` politely,
+     * `error` assertively. Each is optional; nothing is announced without one. Use your own strings.
+     */
+    announce?: {
+        pending?: string;
+        success?: string;
+        error?: string;
+    };
+}
+/**
+ * Return value of {@link useAsyncAction}.
+ * @since 2.13.0
+ */
+export interface UseAsyncActionReturn<A extends unknown[]> {
+    /**
+     * Runs the action. While a run is pending, returns that run's promise without calling `fn`
+     * again. Resolves to the result; never rejects. Stable identity.
+     */
+    run(...args: A): Promise<AsyncActionResult>;
+    /** Where the latest run is. */
+    status: AsyncActionStatus;
+    /** The latest run's error while `status` is 'error'; otherwise `undefined`. */
+    error: unknown;
+    /**
+     * Back to 'idle' with no error. A run still in flight keeps going but no longer changes
+     * `status`; its outcome is still reported and announced. Stable identity.
+     */
+    reset(): void;
+}
+/**
+ * Runs an asynchronous action with a pending state, a never-rejecting result, error reporting and
+ * announcements (ADR-07). See the module notes.
+ *
+ * @param fn - The action. May return nothing, a promise or any thenable.
+ * @param options - Error handler and announcement strings.
+ * @since 2.13.0
+ */
+export declare function useAsyncAction<A extends unknown[]>(fn?: (...args: A) => void | PromiseLike<void>, options?: UseAsyncActionOptions): UseAsyncActionReturn<A>;
+//# sourceMappingURL=useAsyncAction.d.ts.map

package/dist/hooks/useAsyncAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAsyncAction.d.ts","sourceRoot":"","sources":["../../src/hooks/useAsyncAction.ts"],"names":[],"mappings":"AA4CA;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,CAAC;AAEzE;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE5F;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,OAAO,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B;;;OAGG;IACH,QAAQ,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACnE;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,OAAO,EAAE;IACvD;;;OAGG;IACH,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;IAC5C,+BAA+B;IAC/B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,+EAA+E;IAC/E,KAAK,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;CACf;AAqBD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,EAChD,EAAE,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,KAAK,IAAI,GAAG,WAAW,CAAC,IAAI,CAAC,EAC7C,OAAO,GAAE,qBAA0B,GAClC,oBAAoB,CAAC,CAAC,CAAC,CA8EzB"}

package/dist/hooks/useDisclosure.d.ts

@@ -0,0 +1,190 @@
+/**
+ * @fileoverview useDisclosure: state, ids and ARIA wiring for expand/collapse triggers and popup
+ * triggers (B-05, ADR-35 (2) with ADR-35-R1/R2, ADR-15 (2) with ADR-15-R1).
+ * @module hooks/useDisclosure
+ *
+ * Re-exported from `src/hooks.ts` and the package root (ADR-35-R8).
+ *
+ * Two modes:
+ * - `inline` (default): a trigger that shows and hides a panel next to it. The trigger gets
+ *   `aria-expanded`, and `aria-controls` while the panel is in the document.
+ * - `popup`: a trigger that opens an MUI overlay (Menu, Popover, Dialog, a Popper listbox). The
+ *   trigger gets `aria-haspopup` (the popup's role), `aria-expanded`, and `aria-controls` only
+ *   while the popup is open, so the reference never points at nothing.
+ *
+ * State comes from MUI `useControlled`: pass `open` to control it, or `defaultOpen`. Every change
+ * calls `onOpenChange(open, reason, event)`; in controlled mode the value waits for the parent.
+ * Ids come from `useId` (`options.id` overrides); the panel id is `${triggerId}-panel`.
+ *
+ * @example
+ * ```tsx
+ * const details = useDisclosure();
+ * <Button {...details.getTriggerProps()}>Details</Button>
+ * <Collapse in={details.open}>
+ *   <div {...details.getPanelProps({ role: 'region' })}>…</div>
+ * </Collapse>
+ *
+ * const actions = useDisclosure({ mode: 'popup', popupRole: 'menu' });
+ * <Button {...actions.getTriggerProps()}>Actions</Button>
+ * <Menu {...actions.getPopupProps()}>
+ *   <MenuItem onClick={() => actions.setOpen(false)}>Rename</MenuItem>
+ * </Menu>
+ * ```
+ */
+import * as React from 'react';
+/**
+ * Why an open state changed. Shared by every open-state callback in Trinity: components add
+ * literals of their own (for example 'hover' or 'action') but never rename these.
+ * - `trigger`: the user activated the trigger;
+ * - `escape`: Escape closed the popup;
+ * - `clickAway`: a click outside, or focus leaving the popup (MUI Menu's Tab), closed it;
+ * - `programmatic`: code called `setOpen` without a reason.
+ * @since 2.13.0
+ */
+export type OpenChangeReason = 'trigger' | 'escape' | 'clickAway' | 'programmatic';
+/**
+ * The reasons `useDisclosure` reports. An alias of {@link OpenChangeReason}.
+ * @since 2.13.0
+ */
+export type DisclosureChangeReason = OpenChangeReason;
+/**
+ * `inline` for a panel shown next to its trigger, `popup` for an overlay.
+ * @since 2.13.0
+ */
+export type DisclosureMode = 'inline' | 'popup';
+/**
+ * The role of the popup a `popup`-mode trigger opens; it becomes the trigger's `aria-haspopup`.
+ * @since 2.13.0
+ */
+export type DisclosurePopupRole = 'dialog' | 'menu' | 'listbox' | 'tree' | 'grid';
+/**
+ * Options of {@link useDisclosure}.
+ * @since 2.13.0
+ */
+export interface UseDisclosureOptions {
+    /**
+     * `inline` for a panel next to the trigger, `popup` for an overlay.
+     * @default 'inline'
+     */
+    mode?: DisclosureMode;
+    /** Controlled open state. Leave it undefined (for the component's lifetime) for uncontrolled use. */
+    open?: boolean;
+    /**
+     * Initial open state when uncontrolled.
+     * @default false
+     */
+    defaultOpen?: boolean;
+    /**
+     * Called on every requested change, in both modes, with the reason and the event when there is
+     * one. In controlled mode, update `open` here.
+     */
+    onOpenChange?: (open: boolean, reason: OpenChangeReason, event?: React.SyntheticEvent | Event) => void;
+    /**
+     * The trigger's id. The panel's id is `${id}-panel`.
+     * @default an id from `React.useId()`
+     */
+    id?: string;
+    /**
+     * The popup's role in `popup` mode (the trigger's `aria-haspopup`).
+     * @default 'dialog'
+     */
+    popupRole?: DisclosurePopupRole;
+    /** When true, activating the trigger does not toggle. `setOpen` still works. */
+    disabled?: boolean;
+    /**
+     * `inline` mode: whether the panel stays in the document while closed (hidden by a Collapse, for
+     * example). When false, `aria-controls` is set only while open. A development warning fires when
+     * `aria-controls` points at an element that is not in the document.
+     * @default true
+     */
+    panelMountedWhenClosed?: boolean;
+}
+/** The trigger props `getTriggerProps` merges with its own: the user's click handler and ref. */
+type TriggerUserProps = {
+    onClick?: React.MouseEventHandler<HTMLElement>;
+    ref?: React.Ref<HTMLElement>;
+};
+/** The panel props `getPanelProps` reads: the panel's role and an optional label source. */
+type PanelUserProps = {
+    role?: React.AriaRole;
+    labelledBy?: string;
+};
+/**
+ * Props `getTriggerProps` adds to the trigger.
+ * @since 2.13.0
+ */
+export interface DisclosureTriggerProps {
+    id: string;
+    'aria-expanded': boolean;
+    'aria-controls'?: string;
+    'aria-haspopup'?: DisclosurePopupRole;
+    onClick: React.MouseEventHandler<HTMLElement>;
+    ref: React.RefCallback<HTMLElement>;
+}
+/**
+ * Props `getPanelProps` adds to the panel.
+ * @since 2.13.0
+ */
+export interface DisclosurePanelProps {
+    id: string;
+    'aria-labelledby'?: string;
+}
+/**
+ * Props `getPopupProps` returns for an MUI Menu, Popover or Dialog.
+ * @since 2.13.0
+ */
+export interface DisclosurePopupProps {
+    id: string;
+    open: boolean;
+    anchorEl: HTMLElement | null;
+    onClose: (event: object, reason: 'backdropClick' | 'escapeKeyDown' | 'tabKeyDown') => void;
+}
+/**
+ * Return value of {@link useDisclosure}.
+ * @since 2.13.0
+ */
+export interface UseDisclosureReturn {
+    /** Whether the panel or popup is open. */
+    open: boolean;
+    /**
+     * Requests a change. Calls `onOpenChange` (when the value differs) and, when uncontrolled,
+     * changes the state.
+     * @param reason - @default 'programmatic'
+     */
+    setOpen: (open: boolean, reason?: OpenChangeReason, event?: React.SyntheticEvent | Event) => void;
+    /** Requests the opposite state, with reason 'trigger'. */
+    toggle: (event?: React.SyntheticEvent) => void;
+    /** The trigger's id. */
+    triggerId: string;
+    /** The panel's id: `${triggerId}-panel`. */
+    panelId: string;
+    /** The trigger element once mounted (the popup's anchor). */
+    anchorEl: HTMLElement | null;
+    /**
+     * Props for the trigger. The user's `onClick` runs first; calling `event.preventDefault()` in it
+     * skips the toggle. The user's `ref` receives the element too.
+     */
+    getTriggerProps: <P extends TriggerUserProps>(userProps?: P) => Omit<P, keyof DisclosureTriggerProps> & DisclosureTriggerProps;
+    /**
+     * Props for the panel. `aria-labelledby` (the trigger, or `labelledBy` when given) is added only
+     * when `role` is a role that can be named, such as 'region', 'dialog', 'group', 'menu' or
+     * 'listbox'; a generic panel gets no name (axe aria-prohibited-attr).
+     */
+    getPanelProps: <P extends PanelUserProps>(userProps?: P) => Omit<P, 'labelledBy'> & DisclosurePanelProps;
+    /**
+     * Props for an MUI Menu, Popover or Dialog in `popup` mode. MUI's close reasons map to 'escape'
+     * (escapeKeyDown) and 'clickAway' (backdropClick, tabKeyDown). MUI returns focus to the trigger.
+     */
+    getPopupProps: () => DisclosurePopupProps;
+}
+/**
+ * State, ids and ARIA wiring for an expand/collapse trigger (`inline`) or a popup trigger
+ * (`popup`). See the module notes.
+ *
+ * @param options - See {@link UseDisclosureOptions}.
+ * @returns See {@link UseDisclosureReturn}.
+ * @since 2.13.0
+ */
+export declare function useDisclosure(options?: UseDisclosureOptions): UseDisclosureReturn;
+export {};
+//# sourceMappingURL=useDisclosure.d.ts.map

package/dist/hooks/useDisclosure.d.ts.map

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

package/dist/hooks/useFocusOnReplace.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview useFocusOnReplace: after React commits, move focus to a
+ * replacement target when the focused control was removed or disabled
+ * (B-08, ADR-31, step 3 toolkit T3).
+ * @module hooks/useFocusOnReplace
+ *
+ * @internal Not part of the public API (ADR-02, ADR-35). It is deliberately not
+ * re-exported from `src/hooks.ts`, `src/accessibility.tsx`, `src/index.ts` or
+ * any other entry. Components import it from this file directly.
+ *
+ * The problem it solves: a control that unmounts or disables itself while it
+ * has focus (an "Expand" button that disappears once its subtree is shown, a
+ * clear button that unmounts once the field is empty, a "Move" button that
+ * disables itself) drops keyboard focus to `<body>` (WCAG 2.4.3).
+ *
+ * The rule: focus moves only when it was lost. After each commit while a
+ * request is pending, the hook looks at the focused element:
+ * - focus is on `<body>` (or nothing) and the trigger (the element focused when
+ *   `focusAfterCommit()` was called) is gone, disabled, inert or hidden, or no
+ *   trigger was focused: focus is lost, so it moves to the target, else to
+ *   the fallback;
+ * - focus is still on the trigger and the trigger is disconnected, disabled,
+ *   inert or hidden (jsdom and some browsers keep focus there): lost, same as
+ *   above;
+ * - focus is still on the live trigger: nothing moves and the request stays
+ *   pending, so an asynchronous replacement (for example an `onExpand` that
+ *   loads data first) is handled by a later commit;
+ * - focus is on any other element (the user or the consumer moved it), or on
+ *   `<body>` while the trigger is still live (the user clicked away): the
+ *   request is dropped and nothing moves. Focus is never stolen.
+ *
+ * @example
+ * ```tsx
+ * const { targetRef, focusAfterCommit } = useFocusOnReplace<HTMLButtonElement>();
+ * <ButtonBase ref={targetRef}>{node.title}</ButtonBase>
+ * {collapsed && (
+ *   <Tooltip title="Expand subtree">
+ *     <IconButton aria-label="Expand subtree" onClick={() => { focusAfterCommit(); onExpand(node); }}>
+ *       <ChevronRight aria-hidden />
+ *     </IconButton>
+ *   </Tooltip>
+ * )}
+ * ```
+ */
+import * as React from 'react';
+/**
+ * @internal Where focus goes after the commit: a ref, or a getter that is
+ * called after the commit, so it can return an element the same commit created
+ * (for example the first row moved into another list).
+ */
+export type FocusOnReplaceTarget = React.RefObject<HTMLElement | null> | (() => HTMLElement | null | undefined);
+/** @internal Options of {@link useFocusOnReplace}. */
+export interface UseFocusOnReplaceOptions {
+    /**
+     * Default replacement target, used when `focusAfterCommit()` is called
+     * without one. A ref, or a getter called after the commit.
+     * @default the returned `targetRef`
+     */
+    target?: FocusOnReplaceTarget;
+    /**
+     * Tried when the target is missing, disconnected or does not take focus
+     * (disabled, hidden, not focusable). A ref, or a getter called after the
+     * commit. When neither resolves, a development-only warning is logged and
+     * focus stays where the browser put it.
+     */
+    fallbackRef?: FocusOnReplaceTarget;
+}
+/** @internal Return value of {@link useFocusOnReplace}. */
+export interface UseFocusOnReplaceResult<T extends HTMLElement = HTMLElement> {
+    /**
+     * Ref for the replacement element. It is the default target when neither
+     * `options.target` nor a per-call target is given.
+     */
+    targetRef: React.RefObject<T | null>;
+    /**
+     * Call from the event handler (or effect) that is about to remove, disable or
+     * replace the focused control, before or after the state update; never during
+     * render. Records the focused element as the trigger, schedules a commit of the
+     * host component, and moves focus to the target after the first commit in which
+     * focus was lost (see the module notes). Stable identity across renders.
+     *
+     * @param target - Replacement target for this call only (a ref or a getter).
+     * Overrides `options.target` and `targetRef`.
+     */
+    focusAfterCommit: (target?: FocusOnReplaceTarget) => void;
+}
+/**
+ * @internal Moves focus to a replacement target after React commits, but only
+ * when focus was lost (B-08, ADR-31). Not exported from any entry.
+ *
+ * @param options - Optional default target and fallback.
+ * @returns `targetRef` for the default target and a stable `focusAfterCommit`.
+ */
+export declare function useFocusOnReplace<T extends HTMLElement = HTMLElement>(options?: UseFocusOnReplaceOptions): UseFocusOnReplaceResult<T>;
+//# sourceMappingURL=useFocusOnReplace.d.ts.map

package/dist/hooks/useFocusOnReplace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusOnReplace.d.ts","sourceRoot":"","sources":["../../src/hooks/useFocusOnReplace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAK/B;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAC5B,KAAK,CAAC,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,GACnC,CAAC,MAAM,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAE3C,sDAAsD;AACtD,MAAM,WAAW,wBAAwB;IACvC;;;;OAIG;IACH,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACpC;AAED,2DAA2D;AAC3D,MAAM,WAAW,uBAAuB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW;IAC1E;;;OAGG;IACH,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IACrC;;;;;;;;;OASG;IACH,gBAAgB,EAAE,CAAC,MAAM,CAAC,EAAE,oBAAoB,KAAK,IAAI,CAAC;CAC3D;AA+CD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACnE,OAAO,GAAE,wBAA6B,GACrC,uBAAuB,CAAC,CAAC,CAAC,CA6D5B"}

package/dist/hooks/useTrinityPalette.d.ts

@@ -1,54 +1,52 @@
 /**
- * Trinity Theme Utilities
+ * Trinity palette resolver (ADR-26 (3), ADR-03-R4, master plan E-06).
  *
- * These hooks provide access to Trinity's extended palette in a type-safe way.
- * Use these instead of importing tokens directly when you need colors that
- * should respond to light/dark mode.
+ * `getTrinityPalette(theme)` and `useTrinityPalette()` always return a complete
+ * {@link ResolvedTrinityPalette}. Under a Trinity theme they return its `palette.trinity`
+ * groups. Under any other MUI theme (plain `createTheme()`, a consumer theme with a partial
+ * `palette.trinity`) the missing groups come from a fallback derived from the MUI palette with
+ * contrast-safe pairs. The fallback is a supported mode, so nothing is logged.
+ *
+ * Components read Trinity roles only through these two functions (ADR-03).
  */
-import { Theme } from '@mui/material';
+import { type Theme } from '@mui/material/styles';
+import type { ResolvedTrinityPalette } from '../theme-augmentation';
+export type { ResolvedTrinityPalette, TrinityPalette, TrinityStatusColor, TrinityInteractive, TrinityBorder, } from '../theme-augmentation';
 /**
- * Trinity palette types
+ * Get the complete Trinity palette of a theme, for use outside React components and inside
+ * `(theme) => …` sx callbacks. Cached per theme object.
+ *
+ * - Under a Trinity theme, every group is `theme.palette.trinity`'s own group; `ai` adds the
+ *   derived `gradient` strings.
+ * - Under any other theme, missing groups (or keys) come from a fallback derived from the MUI
+ *   palette: status text from `palette[x].dark` (light) or `.light` (dark), adjusted to 4.5:1
+ *   on the paper; backgrounds `alpha(main, 0.12)`; AI roles from `palette.primary` and
+ *   `palette.secondary` (the avatar fill runs from secondary to primary, the progress colour is the
+ *   success text, the canvas fill is a faint primary and secondary tint); confidence and
+ *   verification from the status fallback; surfaces, overlays and states from
+ *   `palette.background`, `palette.action` and the status mains; the indicator group from the
+ *   status `dark` shades, grey[700], primary and secondary; the favorite role from the warning
+ *   status text.
+ *
+ * @example
+ * ```tsx
+ * <Box sx={(theme) => ({ color: getTrinityPalette(theme).ai.primary })} />
+ * ```
+ *
+ * @since 2.13.0
  */
-export interface TrinityStatusColor {
-    text: string;
-    background: string;
-    border: string;
-}
-export interface TrinityInteractive {
-    default: string;
-    hover: string;
-    active: string;
-    disabled: string;
-    focus: string;
-}
-export interface TrinityBorder {
-    default: string;
-    subtle: string;
-    strong: string;
-}
-export interface TrinityPalette {
-    interactive: TrinityInteractive;
-    status: {
-        success: TrinityStatusColor;
-        warning: TrinityStatusColor;
-        error: TrinityStatusColor;
-        info: TrinityStatusColor;
-    };
-    border: TrinityBorder;
-}
+export declare function getTrinityPalette(theme: Theme): ResolvedTrinityPalette;
 /**
- * Hook to access Trinity's semantic colors from the theme.
- * Returns mode-aware colors that automatically adjust for light/dark mode.
+ * Hook to access Trinity's semantic colors from the theme: the complete palette of the current
+ * theme (see {@link getTrinityPalette}). Mode-aware, and complete under any MUI theme.
  *
  * @example
  * ```tsx
  * const trinity = useTrinityPalette();
  * <Box color={trinity.status.success.text} />
  * ```
+ *
+ * @since 2.13.0
  */
-export declare function useTrinityPalette(): TrinityPalette;
-/**
- * Get Trinity palette from a theme object (for use outside React components)
- */
-export declare function getTrinityPalette(theme: Theme): TrinityPalette;
+export declare function useTrinityPalette(): ResolvedTrinityPalette;
 //# sourceMappingURL=useTrinityPalette.d.ts.map

package/dist/hooks/useTrinityPalette.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTrinityPalette.d.ts","sourceRoot":"","sources":["../../src/hooks/useTrinityPalette.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAY,KAAK,EAAE,MAAM,eAAe,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,kBAAkB,CAAC;IAChC,MAAM,EAAE;QACN,OAAO,EAAE,kBAAkB,CAAC;QAC5B,OAAO,EAAE,kBAAkB,CAAC;QAC5B,KAAK,EAAE,kBAAkB,CAAC;QAC1B,IAAI,EAAE,kBAAkB,CAAC;KAC1B,CAAC;IACF,MAAM,EAAE,aAAa,CAAC;CACvB;AAoCD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CASlD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,cAAc,CAO9D"}
+{"version":3,"file":"useTrinityPalette.d.ts","sourceRoot":"","sources":["../../src/hooks/useTrinityPalette.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAoC,KAAK,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAWpF,OAAO,KAAK,EACV,sBAAsB,EAKvB,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EACV,sBAAsB,EACtB,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,GACd,MAAM,uBAAuB,CAAC;AAoM/B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,sBAAsB,CA4BtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,IAAI,sBAAsB,CAE1D"}

package/dist/hooks.d.ts

@@ -34,16 +34,36 @@ export declare function useDebounce<T>(value: T, delay: number): T;
  * ```
  */
 export declare function useDebouncedCallback<T extends (...args: unknown[]) => unknown>(callback: T, delay: number): (...args: Parameters<T>) => void;
-interface UseClipboardOptions {
-    /** Duration to show success state in ms */
+/**
+ * Options of {@link useClipboard}.
+ * @since 2.13.0
+ */
+export interface UseClipboardOptions {
+    /**
+     * Duration to show success state in ms
+     * @default 2000
+     */
     successDuration?: number;
     /** Callback on successful copy */
     onSuccess?: (text: string) => void;
     /** Callback on error */
     onError?: (error: Error) => void;
+    /**
+     * Messages read to screen readers through `useAnnounce` (the nearest `LiveRegionProvider`, else
+     * the document regions): `success` politely after a copy, `error` assertively after a failure.
+     * Each is optional; nothing is announced without one. Use your own strings.
+     */
+    announce?: {
+        success?: string;
+        error?: string;
+    };
 }
-interface UseClipboardReturn {
-    /** Copy text to clipboard */
+/**
+ * Return value of {@link useClipboard}.
+ * @since 2.13.0
+ */
+export interface UseClipboardReturn {
+    /** Copy text to clipboard. Resolves to `true` on success and `false` when the copy fails. */
     copy: (text: string) => Promise<boolean>;
     /** Whether last copy was successful */
     copied: boolean;
@@ -55,12 +75,18 @@ interface UseClipboardReturn {
 /**
  * Hook for copying text to clipboard with feedback.
  *
+ * `copy(text)` resolves to `false` instead of rejecting when the copy fails; `error` then holds the
+ * reason. Without the Clipboard API (an insecure context, an old browser) the error says so:
+ * "Clipboard unavailable: …". With `announce` strings, the outcome is read to screen readers, so
+ * the "Copied" feedback is not visual only (BEHAVIOR_CONTRACT §2). `copy` and `reset` keep one
+ * identity, and the success timer is cleared on unmount.
+ *
  * @param options - Configuration options
  * @returns Clipboard utilities
  *
  * @example
  * ```tsx
- * const { copy, copied, error } = useClipboard({ successDuration: 2000 });
+ * const { copy, copied } = useClipboard({ announce: { success: 'Copied', error: 'Copy failed' } });
  *
  * <Button onClick={() => copy('Hello World!')}>
  *   {copied ? 'Copied!' : 'Copy'}
@@ -72,6 +98,14 @@ type SetValue<T> = T | ((prevValue: T) => T);
 /**
  * Hook for persisting state in localStorage.
  *
+ * Hydration-safe (ADR-27): the server render and the hydration render use `initialValue`, and the
+ * stored value follows in the render straight after hydration. A client-only mount reads the stored
+ * value on its first render. Every hook on the same key in the tab shows the same value, and writes
+ * from other tabs arrive through the `storage` event. A missing key, an unavailable storage or text
+ * that is not JSON gives `initialValue`. Functional updates start from the latest stored value, so
+ * several in one handler all apply. When storage refuses a write (quota, blocked storage), the value
+ * still changes for this page and a warning is logged.
+ *
  * @param key - localStorage key
  * @param initialValue - Initial value if key doesn't exist
  * @returns [value, setValue, removeValue]
@@ -212,6 +246,10 @@ export declare function useKeyPress(targetKey: string, handler?: (event: Keyboar
  * ```
  */
 export declare function useInterval(callback: () => void, delay: number | null): void;
+export { useDisclosure } from './hooks/useDisclosure';
+export type { OpenChangeReason, DisclosureChangeReason, DisclosureMode, DisclosurePopupRole, UseDisclosureOptions, UseDisclosureReturn, DisclosureTriggerProps, DisclosurePanelProps, DisclosurePopupProps, } from './hooks/useDisclosure';
+export { useAsyncAction } from './hooks/useAsyncAction';
+export type { AsyncActionStatus, AsyncActionResult, UseAsyncActionOptions, UseAsyncActionReturn, } from './hooks/useAsyncAction';
 export { useTrinityPalette, getTrinityPalette } from './hooks/useTrinityPalette';
-export type { TrinityPalette, TrinityStatusColor, TrinityInteractive, TrinityBorder } from './hooks/useTrinityPalette';
+export type { ResolvedTrinityPalette, TrinityPalette, TrinityStatusColor, TrinityInteractive, TrinityBorder, } from './theme-augmentation';
 //# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

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