@trinityui/design-system 2.11.0 → 2.13.0

package/dist/components/shared/rootProps.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview Root props contract helpers (ADR-04, master-plan E-15).
+ * @module components/shared/rootProps
+ *
+ * @internal — not part of the public API; see ADR-02
+ *
+ * ADR-04 gives every new or touched component the same root contract: the ref and
+ * `className` reach the root, rest props are spread on it, a closed list of owned
+ * attributes stays the component's, and `id`, `aria-describedby` and `aria-labelledby` are
+ * composed. `useRootProps` implements the rest-props part once:
+ *
+ * - The consumer's rest props are spread first.
+ * - The owned attributes ({@link OwnedAttribute}) are always the component's. A consumer
+ *   value for one of them is dropped, and a development warning names it, once per
+ *   component. Production builds print nothing.
+ * - `id` defaults to `useId()`, so it is stable between the server and the client.
+ * - `aria-describedby` and `aria-labelledby` join the component's ids and the consumer's,
+ *   in that order, without duplicates.
+ *
+ * Two types here are public, because public `slotProps` and docs reference them:
+ * {@link OwnedAttribute} and {@link TrinitySlotProps}. Everything else is internal.
+ *
+ * @example
+ * ```tsx
+ * const { className, sx, id, ...rest } = props;
+ * const rootProps = useRootProps({ rest, id, owned: { role: 'log', 'aria-live': 'polite' }, componentName: 'ChatThread' });
+ * return <Box ref={ref} className={className} sx={mergeSx(baseSx, sx)} {...rootProps} />;
+ * ```
+ */
+import * as React from 'react';
+import type { SxProps, Theme } from '@mui/material/styles';
+/**
+ * The attributes a Trinity component owns on its root and on its slots. A consumer value
+ * for one of them is ignored, with a development warning, so rest props cannot break the
+ * component's role or live-region model (ADR-04, ADR-19).
+ *
+ * @since 2.13.0
+ */
+export type OwnedAttribute = 'role' | 'aria-live' | 'aria-busy' | 'aria-relevant' | 'aria-atomic' | 'aria-modal';
+/**
+ * Props of a Trinity-owned slot, as accepted by a component's `slotProps.<slot>`:
+ * `className`, `sx`, `id`, and the HTML attributes of the slot's element, including
+ * `aria-*`, `data-*` and event handlers. The {@link OwnedAttribute} attributes are not
+ * accepted. Slot names and elements are documented per component (ADR-04 (6)).
+ *
+ * @since 2.13.0
+ */
+export type TrinitySlotProps<El extends HTMLElement = HTMLElement> = {
+    /** Added to the slot's own class names. */
+    className?: string;
+    /** Applied after the slot's own styles. */
+    sx?: SxProps<Theme>;
+    /** Replaces the slot's generated id. The component's references follow it. */
+    id?: string;
+} & Omit<React.HTMLAttributes<El>, OwnedAttribute | 'className' | 'id'> & {
+    [dataAttribute: `data-${string}`]: string | number | boolean | undefined;
+};
+/**
+ * The rest props a component's root accepts: every HTML attribute of the root element,
+ * minus the component's own prop names and `color` (ADR-04 (3)).
+ * @internal
+ */
+export type TrinityRootProps<El extends HTMLElement, Own> = Omit<React.HTMLAttributes<El>, keyof Own | 'color'>;
+/** The owned attributes, as a runtime list. @internal */
+export declare const OWNED_ATTRIBUTES: readonly OwnedAttribute[];
+/** An id list: one id string, or several, with empty entries skipped. @internal */
+export type IdList = string | ReadonlyArray<string | false | null | undefined> | false | null | undefined;
+/**
+ * Joins id lists into one space-separated value: tokens in order, duplicates and empty
+ * entries removed. Returns `undefined` when nothing is left.
+ * @internal
+ */
+export declare function joinIds(...lists: IdList[]): string | undefined;
+/** Whether `key` is one of the owned attributes. @internal */
+export declare function isOwnedAttribute(key: string): key is OwnedAttribute;
+/**
+ * Warns once per component that a consumer passed owned attributes, which were ignored.
+ * Silent in production builds.
+ * @internal
+ */
+export declare function warnOwnedAttributes(componentName: string, attributes: readonly string[], slotName?: string): void;
+/**
+ * Test-only: forget which components already warned, so a test can observe the warning
+ * again.
+ * @internal
+ */
+export declare function __resetOwnedAttributeWarnings(): void;
+/** Options of {@link useRootProps}. @internal */
+export interface UseRootPropsOptions<El extends HTMLElement = HTMLElement> {
+    /** The consumer's rest props. Spread first. */
+    rest?: React.HTMLAttributes<El> | Record<string, unknown>;
+    /**
+     * The owned attributes this component sets on its root. Applied after `rest`; a consumer
+     * value never replaces them. Owned attributes left out here are not set at all.
+     */
+    owned?: Partial<Record<OwnedAttribute, string | boolean | undefined>>;
+    /** The consumer's `id`, if the component takes it out of `rest`. Else `rest.id`, else `useId()`. */
+    id?: string;
+    /** The component's own description ids, joined before the consumer's `aria-describedby`. */
+    describedBy?: IdList;
+    /** The component's own label ids, joined before the consumer's `aria-labelledby`. */
+    labelledBy?: IdList;
+    /** Names the component in the development warning. */
+    componentName: string;
+}
+/** What {@link useRootProps} returns: props to spread on the root element. @internal */
+export type RootPropsResult<El extends HTMLElement = HTMLElement> = React.HTMLAttributes<El> & {
+    id: string;
+    [attribute: string]: unknown;
+};
+/**
+ * Builds the root's props: the consumer's rest props, then the component's owned
+ * attributes, a stable `id` and the joined `aria-describedby` and `aria-labelledby`.
+ * @internal
+ */
+export declare function useRootProps<El extends HTMLElement = HTMLElement>(options: UseRootPropsOptions<El>): RootPropsResult<El>;
+//# sourceMappingURL=rootProps.d.ts.map

package/dist/components/shared/rootProps.d.ts.map

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

package/dist/components/shared/safeContent.d.ts

@@ -0,0 +1,136 @@
+/**
+ * @internal — not part of the public API; see ADR-02. Used by components that render untrusted content.
+ * @fileoverview Safe rendering of untrusted (model-, user- or data-supplied) content.
+ * @module components/shared/safeContent
+ *
+ * One module owns every policy for turning untrusted strings into DOM, so AI
+ * components never reach for `dangerouslySetInnerHTML` (ADR-09, audit SEC-01..03):
+ *
+ * - {@link renderSafeHtml} — a deterministic string tokenizer (no DOMParser, no
+ *   `window`), so `renderToString` and the client build identical trees (no
+ *   hydration mismatch). Allowlisted tags become React elements; dangerous tags
+ *   are dropped with their content; every other tag is unwrapped to its text.
+ * - {@link isSafeHref} / {@link isSafeSrc} — separate URL policies for links and
+ *   images, evaluated after decoding entities and removing whitespace/C0 controls,
+ *   so obfuscations like `java\tscript:` or `javascript:` are caught.
+ * - {@link sanitizeInlineStyle} — a typographic/box allowlist for inline styles.
+ *
+ * React escapes every text node and attribute value, so output is inert by
+ * construction; the policies decide only what structure survives.
+ */
+import * as React from 'react';
+/**
+ * @internal
+ * Decode decimal, hex and known named character references the way browsers do.
+ * Numeric references decode with or without a semicolon. Named references need
+ * their semicolon, except the legacy set; in attribute values a legacy reference
+ * followed by `=` or an alphanumeric stays literal (so `?a=1&copy=2` keeps its
+ * query string).
+ */
+export declare function decodeEntities(input: string, inAttribute?: boolean): string;
+/**
+ * @internal
+ * Link policy: http, https, mailto, tel, relative paths and fragments.
+ * Everything else — javascript:, vbscript:, data:, file:, and any obfuscated
+ * form of them — is unsafe.
+ */
+export declare function isSafeHref(url: string | null | undefined): boolean;
+/**
+ * @internal
+ * Image-source policy: http, https, blob:, relative paths, and raster
+ * `data:image/(png|jpeg|gif|webp|avif|bmp|x-icon)`. Never `data:image/svg+xml`
+ * (SVG can carry script), never any other data: payload, and no app-shell
+ * schemes (file:, asset:, tauri:, capacitor:).
+ */
+export declare function isSafeSrc(url: string | null | undefined): boolean;
+/** @internal Test-only: forget which unsafe-URL warnings were shown (mirrors `__resetDevWarnings` in warnDeprecated.ts). */
+export declare function __resetUnsafeUrlWarnings(): void;
+/**
+ * @internal
+ * Dev-only, once per component, kind and scheme: report a URL that a safety
+ * policy blocked, so integrators notice a dropped link or image instead of
+ * silently losing it. Silent in production builds.
+ */
+export declare function warnUnsafeUrl(component: string, url: string | null | undefined, kind?: 'link' | 'image'): void;
+/**
+ * @internal
+ * True for sources fetched from the network: http(s) and network-path URLs.
+ * Browsers treat a backslash like a slash in such URLs, so `\\host/x` and
+ * `/\\host/x` count as remote too.
+ */
+export declare function isRemoteSrc(url: string | null | undefined): boolean;
+/** @internal A style map suitable for an MUI `sx` / React `style` object. */
+export type SafeStyleMap = Record<string, string | number>;
+/**
+ * @internal
+ * Parse an inline `style` attribute through the typographic/box allowlist.
+ * Positioning (position, inset, top/left/right/bottom, z-index), transforms,
+ * filters and any value that can fetch or execute (url(), expression(), var(),
+ * attr(), image-set(), @import, escapes) are dropped.
+ */
+export declare function sanitizeInlineStyle(styleValue: string | null | undefined): SafeStyleMap | undefined;
+/**
+ * @internal
+ * Tags removed together with everything inside them. A superset of the
+ * historical HtmlToMui BLOCKED_TAGS, so nothing previously dropped is loosened.
+ */
+export declare const DROP_WITH_CONTENT_TAGS: ReadonlySet<string>;
+/** @internal Default (and maximum) tag set kept by {@link renderSafeHtml}. */
+export declare const DEFAULT_ALLOWED_TAGS: ReadonlySet<string>;
+type Token = {
+    kind: 'text';
+    value: string;
+} | {
+    kind: 'start';
+    name: string;
+    attrs: Record<string, string>;
+    selfClosing: boolean;
+} | {
+    kind: 'end';
+    name: string;
+};
+/** @internal Split HTML into tokens. Comments, doctypes and processing instructions vanish. */
+export declare function tokenizeHtml(source: string): Token[];
+/** @internal Tags {@link renderSafeHtml} can keep. */
+export type SafeHtmlTag = 'b' | 'strong' | 'i' | 'em' | 'code' | 'br' | 'p' | 'ul' | 'ol' | 'li' | 'span' | 'a' | 'mark';
+/** @internal Options for {@link renderSafeHtml}. */
+export interface RenderSafeHtmlOptions {
+    /**
+     * Restrict the kept tags to a subset of {@link DEFAULT_ALLOWED_TAGS} (see
+     * {@link SafeHtmlTag}). Other names are accepted, warned about in development
+     * and unwrapped to text: the builder only implements the HTML parser's nesting
+     * rules for the default tags, and that is what keeps server and client output
+     * identical (no hydration mismatch).
+     */
+    allowTags?: Iterable<string>;
+    /**
+     * Classes allowed on `span`/`mark`, mapped to the element that renders them.
+     * `{ 'insight-highlight': 'span' }` keeps the class on a span;
+     * `{ highlight: 'mark' }` renders a semantic `<mark>`. All other classes are dropped.
+     */
+    allowClasses?: Record<string, 'span' | 'mark'>;
+    /**
+     * The id of the caller's new-tab hint ("Opens in a new tab", WI-56). Every kept
+     * `target="_blank"` anchor gets `aria-describedby` with this id, so its name
+     * stays its text. The caller renders the hint element once.
+     */
+    newTabHintId?: string;
+}
+/**
+ * @internal
+ * Render untrusted HTML as React nodes through the allowlist. Deterministic:
+ * the same input yields the same tree on the server and the client.
+ *
+ * Default tags: b, strong, i, em, code, br, p, ul, ol, li, span, a, mark.
+ * Anchors keep only a safe `href`, `title` and `target="_blank"`, and always
+ * get `rel="noopener noreferrer"`; an anchor with an unsafe href becomes text.
+ * With `newTabHintId`, a `target="_blank"` anchor is described by that hint.
+ *
+ * @example
+ * ```tsx
+ * <Box>{renderSafeHtml(thought, { allowClasses: { 'insight-highlight': 'span' } })}</Box>
+ * ```
+ */
+export declare function renderSafeHtml(html: string | null | undefined, options?: RenderSafeHtmlOptions): React.ReactNode;
+export {};
+//# sourceMappingURL=safeContent.d.ts.map

package/dist/components/shared/safeContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"safeContent.d.ts","sourceRoot":"","sources":["../../../src/components/shared/safeContent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AA6F/B;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,UAAQ,GAAG,MAAM,CAqBzE;AAqBD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAMlE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAQjE;AAID,4HAA4H;AAC5H,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,IAAI,GAAE,MAAM,GAAG,OAAgB,GAAG,IAAI,CAetH;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAMnE;AA+BD,6EAA6E;AAC7E,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;AAkC3D;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAoBnG;AAMD;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,MAAM,CAIrD,CAAC;AAKH,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,EAAE,WAAW,CAAC,MAAM,CAEnD,CAAC;AA2BH,KAAK,KAAK,GACN;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,GACpF;IAAE,IAAI,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAQlC,+FAA+F;AAC/F,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,CAmIpD;AAoBD,sDAAsD;AACtD,MAAM,MAAM,WAAW,GAAG,GAAG,GAAG,QAAQ,GAAG,GAAG,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC;AAEzH,oDAAoD;AACpD,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC7B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IAC/C;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AA6MD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,GAAE,qBAA0B,GAAG,KAAK,CAAC,SAAS,CAIpH"}

package/dist/components/shared/targetSize.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview Target-size hit area: one recipe that grows a compact control's pointer target to
+ * the 24px floor without changing how it looks.
+ * @module components/shared/targetSize
+ *
+ * @internal — not part of the public API; see ADR-02
+ *
+ * WCAG 2.2 SC 2.5.8 Target Size (Minimum, AA) asks for a pointer target of at least 24 by 24 CSS
+ * pixels. The program's floor is that 24px (DN-12, 2026-10-05; the record is
+ * docs/remediation/primitives/target-size.md). Standard MUI controls already meet it. A compact
+ * control whose visual box is smaller (a 20px pill, a dense icon button) gets a larger hit area
+ * here, so its look and its layout stay the same:
+ *
+ * - the host keeps its box and gets `position: relative`;
+ * - an `::after` pseudo-element is the hit area. It is centred on the host and is
+ *   `max(box, floor)` on each axis: `inset: min(0px, (100% - floor) / 2)`. A host that is already
+ *   24px or larger on an axis gets a hit area equal to its box on that axis, so the recipe is a
+ *   no-op there;
+ * - the pseudo-element paints nothing. A press on it is a press on the host (hit testing reports
+ *   the originating element), so the host's own handlers, cursor and hover styles apply.
+ *
+ * The inset is symmetric, so the recipe needs no physical `left`/`right` and works the same in
+ * right-to-left layouts.
+ *
+ * Use it on a control that is not an inline target in a sentence (the 2.5.8 inline exception) and
+ * whose visual size cannot grow. Do not hand-roll a local `::before`/`::after` hit area instead:
+ * the remediation stop rule forbids local hit-area hacks (WI-54).
+ *
+ * Limits:
+ * - The host must not be absolutely or fixed positioned (the recipe sets `position: relative`);
+ *   put the recipe on an inner element instead.
+ * - The host must not use its own `::after`.
+ * - An ancestor with `overflow: hidden` clips the hit area at its edge, like any other content.
+ * - Two compact controls closer than 24px centre to centre would share hit area; the later one in
+ *   the DOM wins. Keep such controls at least 24px apart (the 2.5.8 spacing rule).
+ *
+ * @example
+ * ```tsx
+ * <IconButton aria-label="Remove filter" sx={[{ width: 20, height: 20 }, targetSizeHitAreaSx]}>
+ *   <CloseIcon fontSize="inherit" />
+ * </IconButton>
+ * ```
+ */
+import type { SxProps, Theme } from '@mui/material/styles';
+/**
+ * One style object of an `sx` array. Narrower than `SxProps<Theme>` (and assignable to it), so a
+ * host can combine the recipe with its own styles: `sx={[{ width: 20 }, targetSizeHitAreaSx]}`.
+ */
+type SxStyleObject = Exclude<Extract<SxProps<Theme>, ReadonlyArray<unknown>>[number], boolean | ((theme: Theme) => unknown)>;
+/**
+ * The floor in CSS pixels: `scaleHierarchy.touchTargets.floor` (24, DN-12).
+ *
+ * @internal
+ */
+export declare const TARGET_SIZE_FLOOR_PX: number;
+/**
+ * The hit-area recipe. Add it to the host's `sx` array after the component's own styles and
+ * before the consumer's `sx`, so a consumer can still override it deliberately.
+ *
+ * @internal
+ */
+export declare const targetSizeHitAreaSx: SxStyleObject;
+export {};
+//# sourceMappingURL=targetSize.d.ts.map

package/dist/components/shared/targetSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"targetSize.d.ts","sourceRoot":"","sources":["../../../src/components/shared/targetSize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAG3D;;;GAGG;AACH,KAAK,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC;AAE7H;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAA0C,CAAC;AAE9E;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,aAOjC,CAAC"}

package/dist/components/shared/useContainerInlineSize.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview useContainerInlineSize: an element's inline size from a ResizeObserver
+ * (master-plan H-20, ADR-11 (5), ADR-27).
+ * @module components/shared/useContainerInlineSize
+ *
+ * @internal — not part of the public API; see ADR-02
+ *
+ * For a switch CSS container queries cannot express: a structural change, such as
+ * ListDetailTemplate's split view becoming a list with a full-width drawer
+ * (`collapseMode="container"`). Styling that only changes properties uses
+ * `containerUp` / `containerDown` (containerQueries.ts) instead.
+ *
+ * Semantics:
+ *
+ * - The size is `null` until the element is measured: on the server and in the first client
+ *   render, so hydration matches (ADR-27's stable initial value). Callers treat `null` as
+ *   "wide enough" (the split layout).
+ * - The element is passed through the returned callback ref, so an element that is replaced
+ *   (a new root node) is observed again.
+ * - The size is the border box's content inline size (`contentBoxSize[0].inlineSize`, else
+ *   `contentRect.width`), updated on every ResizeObserver report; state changes only when the
+ *   value changes.
+ * - Without ResizeObserver (an old engine, a server) the size stays `null`.
+ * - `enabled: false` observes nothing and reports `null`.
+ *
+ * @example
+ * ```tsx
+ * const [inlineSize, measureRef] = useContainerInlineSize<HTMLDivElement>({ enabled: collapseMode === 'container' });
+ * const handleRef = useForkRef(ref, measureRef);
+ * const collapsed = inlineSize !== null && inlineSize < threshold;
+ * ```
+ */
+/** Options of {@link useContainerInlineSize}. @internal */
+export interface UseContainerInlineSizeOptions {
+    /** Observe the element. Default `true`; `false` reports `null`. */
+    enabled?: boolean;
+}
+/**
+ * The inline size of the element given to the returned ref, or `null` before it is measured.
+ * @internal
+ */
+export declare function useContainerInlineSize<El extends HTMLElement = HTMLElement>(options?: UseContainerInlineSizeOptions): [inlineSize: number | null, ref: (node: El | null) => void];
+//# sourceMappingURL=useContainerInlineSize.d.ts.map

package/dist/components/shared/useContainerInlineSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useContainerInlineSize.d.ts","sourceRoot":"","sources":["../../../src/components/shared/useContainerInlineSize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAIH,2DAA2D;AAC3D,MAAM,WAAW,6BAA6B;IAC5C,mEAAmE;IACnE,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AASD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,SAAS,WAAW,GAAG,WAAW,EACzE,OAAO,GAAE,6BAAkC,GAC1C,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,EAAE,GAAG,IAAI,KAAK,IAAI,CAAC,CAqB7D"}

package/dist/components/shared/useCopyAction.d.ts

@@ -0,0 +1,35 @@
+import { type AsyncActionResult } from '../../hooks';
+/** Options of {@link useCopyAction}. @internal */
+export interface UseCopyActionOptions {
+    /** Announced through `useAnnounce`: `success` politely, `error` assertively. */
+    messages?: {
+        success?: string;
+        error?: string;
+    };
+    /** Called with the copied text after a successful copy. */
+    onCopied?: (text: string) => void;
+    /** Called with the error after a failed copy. Without it the error goes to `globalThis.reportError`. */
+    onCopyError?: (error: unknown) => void;
+    /**
+     * How long `status` stays `'copied'` or `'error'`, in ms.
+     * @default 2000
+     */
+    feedbackDuration?: number;
+}
+/** Where the latest copy is. @internal */
+export type CopyActionStatus = 'idle' | 'pending' | 'copied' | 'error';
+/** Return value of {@link useCopyAction}. @internal */
+export interface UseCopyActionResult {
+    /** Copies `text`. Resolves to the outcome; never rejects. Stable identity. */
+    copy: (text: string) => Promise<AsyncActionResult>;
+    status: CopyActionStatus;
+    /** Back to `'idle'`. Stable identity. */
+    reset: () => void;
+}
+/**
+ * Copies text through `useClipboard` and `useAsyncAction`, with failures surfaced. See the
+ * module notes.
+ * @internal
+ */
+export declare function useCopyAction(options?: UseCopyActionOptions): UseCopyActionResult;
+//# sourceMappingURL=useCopyAction.d.ts.map

package/dist/components/shared/useCopyAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCopyAction.d.ts","sourceRoot":"","sources":["../../../src/components/shared/useCopyAction.ts"],"names":[],"mappings":"AAgCA,OAAO,EAAgC,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAYnF,kDAAkD;AAClD,MAAM,WAAW,oBAAoB;IACnC,gFAAgF;IAChF,QAAQ,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,wGAAwG;IACxG,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,0CAA0C;AAC1C,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEvE,uDAAuD;AACvD,MAAM,WAAW,mBAAmB;IAClC,8EAA8E;IAC9E,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACnD,MAAM,EAAE,gBAAgB,CAAC;IACzB,yCAAyC;IACzC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,mBAAmB,CAmDrF"}

package/dist/components/shared/useOverflow.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @fileoverview useOverflow: whether an element's content overflows its box (master-plan D-43).
+ * @module components/shared/useOverflow
+ *
+ * @internal — not part of the public API; see ADR-02
+ *
+ * One measurement for every component that reacts to overflow: OverflowTooltip today,
+ * MetaChip truncation (D-04) and CodeBlock scrolling (D-07) next. Semantics:
+ *
+ * - The first render reports no overflow, on the server and on the client, so hydration
+ *   matches.
+ * - The element is measured after layout, on every commit. A content change (a new value,
+ *   streamed text) is measured without a dependency list.
+ * - It is measured again when a ResizeObserver reports the element and on window resize.
+ *   Without ResizeObserver, window resize still works.
+ * - State changes only when a result changes, so a re-render or a resize with the same
+ *   overflow causes no extra render.
+ * - The observer is disconnected and the resize listener removed on unmount.
+ *
+ * @example
+ * ```tsx
+ * const ref = React.useRef<HTMLSpanElement>(null);
+ * const { overflowX } = useOverflow(ref, { axis: 'x' });
+ * ```
+ */
+import * as React from 'react';
+/** Which overflow to measure. `'both'` (the default) measures both axes. */
+export type OverflowAxis = 'x' | 'y' | 'both';
+export interface UseOverflowOptions {
+    /** Which axis to measure. An axis left out always reports `false`. Default `'both'`. */
+    axis?: OverflowAxis;
+}
+export interface UseOverflowResult {
+    /** `scrollWidth` is larger than `clientWidth`. */
+    overflowX: boolean;
+    /** `scrollHeight` is larger than `clientHeight`. */
+    overflowY: boolean;
+}
+/**
+ * Reports whether the element in `ref` overflows horizontally and vertically.
+ * @internal
+ */
+export declare function useOverflow(ref: React.RefObject<HTMLElement | null>, options?: UseOverflowOptions): UseOverflowResult;
+//# sourceMappingURL=useOverflow.d.ts.map

package/dist/components/shared/useOverflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOverflow.d.ts","sourceRoot":"","sources":["../../../src/components/shared/useOverflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,4EAA4E;AAC5E,MAAM,MAAM,YAAY,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC;AAE9C,MAAM,WAAW,kBAAkB;IACjC,wFAAwF;IACxF,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,kDAAkD;IAClD,SAAS,EAAE,OAAO,CAAC;IACnB,oDAAoD;IACpD,SAAS,EAAE,OAAO,CAAC;CACpB;AAYD;;;GAGG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EACxC,OAAO,GAAE,kBAAuB,GAC/B,iBAAiB,CAuCnB"}

package/dist/components/shared/useResizable.d.ts

@@ -6,16 +6,24 @@
  * `ResizablePanel`, and any future drag-to-resize surface:
  *
  *   1. `mousedown` on a handle captures the start position + start size
+ *      (the current size through the caller's clamp)
  *   2. Global `mousemove` listener updates size (clamped by the caller)
  *   3. Global `mouseup` ends the drag
  *   4. Optional body cursor lock and text-selection suppression during drag
  *
+ * The size can be uncontrolled (seeded once from `initialSize`) or controlled
+ * (`size` + `onSizeChange`), through MUI `useControlled` (ADR-35). Every size
+ * write — drag, `setSize`, `setSizeClamped` — goes through one internal
+ * commit that stores the size when uncontrolled and reports it through
+ * `onSizeChange` in both modes.
+ *
  * **Not used by `DockLayout`** — that component uses the HTML5 Drag-and-Drop
  * API (`DragEvent`, `dataTransfer`) for whole-panel moves between zones, which
  * is a fundamentally different mechanism. Don't try to unify them.
  *
  * @example
  * ```tsx
+ * // Uncontrolled: the hook owns the size.
  * const { size, isResizing, onMouseDown, setSize } = useResizable({
  *   initialSize: 400,
  *   axis: 'x',
@@ -26,11 +34,85 @@
  *
  * return <div onMouseDown={onMouseDown}>...</div>;
  * ```
+ *
+ * @example
+ * ```tsx
+ * // Controlled: the caller owns the size; the hook reports changes.
+ * const [width, setWidth] = React.useState(400);
+ * const { size, onMouseDown } = useResizable({
+ *   initialSize: 400,
+ *   size: width,
+ *   onSizeChange: (next) => setWidth(next),
+ *   axis: 'x',
+ * });
+ * ```
  */
 import * as React from 'react';
+/**
+ * Why the size changed, as reported to `onSizeChange`.
+ *
+ * - `'drag'`: a mouse or touch drag on the handle (set by the hook).
+ * - `'keyboard'`: a key press on the handle. The hook binds no keys itself; the
+ *   caller passes this reason to `setSize` / `setSizeClamped`.
+ * - `'set'`: any other `setSize` / `setSizeClamped` call (the default).
+ */
+export type ResizeReason = 'drag' | 'keyboard' | 'set';
 export interface UseResizableOptions {
-    /** Initial pixel size — can be a function for lazy/derived values */
+    /**
+     * Initial pixel size when uncontrolled — can be a function for lazy/derived
+     * values. Read once, on mount: later changes (a new number or a new
+     * function) are ignored, so a caller may recompute it on every render
+     * (e.g. `controlledSize ?? 200`) without resetting the size or triggering
+     * MUI's "changing the default size state" warning. When `size` is
+     * controlled it is still resolved on mount, but not used.
+     */
     initialSize: number | (() => number);
+    /**
+     * Controlled pixel size. When defined on the first render, the hook never
+     * changes the size on its own: drags and `setSize` / `setSizeClamped`
+     * report the next (clamped) size through `onSizeChange`, and the returned
+     * `size` changes only when this option changes. A drag starts from
+     * `clamp(size)`, so a controlled size outside the caller's bounds has no
+     * dead zone. The mode is decided on the first render; switching between
+     * `undefined` and a number afterwards is unsupported and logs MUI's
+     * controlled/uncontrolled warning in development (it names `name` and
+     * `stateName`). Implemented with MUI `useControlled` (ADR-35).
+     */
+    size?: number;
+    /**
+     * Component name shown in MUI's controlled/uncontrolled warning. A
+     * component built on the hook passes its own name, so the warning points
+     * at the component the consumer rendered (for example `'ResizablePanel'`).
+     * @internal
+     * @default 'useResizable'
+     */
+    name?: string;
+    /**
+     * Name of the controlled prop shown in MUI's controlled/uncontrolled
+     * warning (for example `'width'`).
+     * @internal
+     * @default 'size'
+     */
+    stateName?: string;
+    /**
+     * Turns drag resizing off. While true, `onMouseDown` and `onTouchStart`
+     * start nothing, and a drag already in progress ends at once: its global
+     * listeners and the body cursor lock are released, no further move is
+     * reported, and `onResizeEnd` fires once with the size it reached.
+     * `setSize` and `setSizeClamped` still work.
+     * @internal
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Fires with the next size on every write, in both controlled and
+     * uncontrolled mode: once per drag move (the clamped size, like `onResize`,
+     * including repeats of the same value at a bound) with reason `'drag'`, and
+     * once per `setSize` / `setSizeClamped` call with the reason passed there
+     * (default `'set'`). Not called when a controlled `size` changes. The latest
+     * function is always used (no re-binding needed).
+     */
+    onSizeChange?: (size: number, reason: ResizeReason) => void;
     /** Which axis the drag handle moves along */
     axis: 'x' | 'y';
     /**
@@ -45,7 +127,13 @@ export interface UseResizableOptions {
     onResize?: (size: number) => void;
     /** Fires once when drag begins */
     onResizeStart?: () => void;
-    /** Fires once when drag ends (with the final size) */
+    /**
+     * Fires once when drag ends (with the final size). It runs in an effect
+     * after the commit in which `isResizing` turns false, so it reports the
+     * settled size (for a controlled `size`, the value the parent kept). A
+     * consumer that switches animations off while `isResizing` is true sees
+     * them come back one commit before this call.
+     */
     onResizeEnd?: (size: number) => void;
     /**
      * Lock body cursor + suppress text selection during drag. Default true.
@@ -59,7 +147,7 @@ export interface UseResizableOptions {
     dragCursor?: string;
 }
 export interface UseResizableReturn {
-    /** Current pixel size */
+    /** Current pixel size: the controlled `size` when given, else the hook's own state */
     size: number;
     /** True while a drag is in progress */
     isResizing: boolean;
@@ -67,10 +155,20 @@ export interface UseResizableReturn {
     onMouseDown: (e: React.MouseEvent) => void;
     /** Attach to the drag handle's onTouchStart (mobile touch support) */
     onTouchStart: (e: React.TouchEvent) => void;
-    /** Imperatively set the size (for keyboard nav, reset buttons, etc.) */
-    setSize: (size: number) => void;
-    /** Same as setSize but routes through clamp first */
-    setSizeClamped: (size: number) => void;
+    /**
+     * Imperatively set the size (for keyboard nav, reset buttons, etc.). Stores
+     * it when uncontrolled and reports it through `onSizeChange` with `reason`.
+     * Stable identity.
+     * @param size Next pixel size, used as given (not clamped).
+     * @param reason Reported to `onSizeChange` (default `'set'`).
+     */
+    setSize: (size: number, reason?: ResizeReason) => void;
+    /**
+     * Same as setSize but routes through clamp first. Stable identity.
+     * @param size Next pixel size, clamped with the latest `clamp`.
+     * @param reason Reported to `onSizeChange` (default `'set'`).
+     */
+    setSizeClamped: (size: number, reason?: ResizeReason) => void;
 }
 /**
  * useResizable — React hook that owns the pointer-drag lifecycle for a
@@ -79,4 +177,5 @@ export interface UseResizableReturn {
  * The hook does NOT render anything. It's a headless primitive.
  */
 export declare function useResizable(options: UseResizableOptions): UseResizableReturn;
+export { getResizeKeyTarget, RESIZE_KEY_STEP, RESIZE_KEY_LARGE_STEP, type ResizeKeyOptions, type ResizeOrientation, type ResizeGrowDirection, } from './resizeKeyboard';
 //# sourceMappingURL=useResizable.d.ts.map

package/dist/components/shared/useResizable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useResizable.d.ts","sourceRoot":"","sources":["../../../src/components/shared/useResizable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,MAAM,WAAW,mBAAmB;IAClC,qEAAqE;IACrE,WAAW,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC;IACrC,6CAA6C;IAC7C,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAClC,+EAA+E;IAC/E,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACjC,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,kCAAkC;IAClC,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;IAC3B,sDAAsD;IACtD,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,UAAU,EAAE,OAAO,CAAC;IACpB,8CAA8C;IAC9C,WAAW,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IAC3C,sEAAsE;IACtE,YAAY,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IAC5C,wEAAwE;IACxE,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC,qDAAqD;IACrD,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACxC;AAID;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CAoJ7E"}
+{"version":3,"file":"useResizable.d.ts","sourceRoot":"","sources":["../../../src/components/shared/useResizable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,CAAC;AAEvD,MAAM,WAAW,mBAAmB;IAClC;;;;;;;OAOG;IACH,WAAW,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,CAAC;IACrC;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;IAC5D,6CAA6C;IAC7C,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAChB;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;IAClC,+EAA+E;IAC/E,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACjC,6CAA6C;IAC7C,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,kCAAkC;IAClC,aAAa,CAAC,EAAE,MAAM,IAAI,CAAC;IAC3B;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,UAAU,EAAE,OAAO,CAAC;IACpB,8CAA8C;IAC9C,WAAW,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IAC3C,sEAAsE;IACtE,YAAY,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;IAC5C;;;;;;OAMG;IACH,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;IACvD;;;;OAIG;IACH,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;CAC/D;AAKD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CAwL7E;AAMD,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAC"}