@trinityui/design-system 2.11.0 → 2.13.0

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

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview The focus trap of Trinity's light-dismiss surfaces (C-07, ADR-15, ADR-34).
+ * @module components/shared/focusTrap
+ *
+ * @internal — not part of the public API; see ADR-02
+ *
+ * Trinity adopts MUI's focus trap instead of writing one (keyboard-models.md, "Popper click
+ * mode": ADOPT). MUI 9.4.0 ships it only as `Unstable_TrapFocus`; this module is the one place
+ * that imports it, so a rename in MUI touches one line. A hand-written Tab trap is a strict
+ * check:behavior finding (`focus-trap-manual`).
+ *
+ * What the trap does while `open`: it moves focus into its child (the child needs `tabIndex={-1}`
+ * and must hold a ref), keeps Tab and Shift+Tab inside it, and pulls focus back if it leaves.
+ * Options a surface sets:
+ * - `disableRestoreFocus`: the surface restores focus itself (Popper returns it to its trigger,
+ *   which a browser that does not focus clicked buttons, Safari, would not have recorded);
+ * - `disableEnforceFocus`: for surfaces that must let focus leave (not used by Popper).
+ *
+ * @example
+ * ```tsx
+ * <FocusTrap open={open} disableRestoreFocus>
+ *   <Paper ref={ref} tabIndex={-1} role="dialog" aria-modal="true" aria-label="Filters">…</Paper>
+ * </FocusTrap>
+ * ```
+ */
+import TrapFocus from '@mui/material/Unstable_TrapFocus';
+import type { TrapFocusProps } from '@mui/material/Unstable_TrapFocus';
+/** MUI's focus trap, under Trinity's name. @internal */
+export declare const FocusTrap: typeof TrapFocus;
+/** Props of {@link FocusTrap}: MUI's `TrapFocusProps`. @internal */
+export type FocusTrapProps = TrapFocusProps;
+/** The elements a keyboard user can reach with Tab. @internal */
+export declare const TABBABLE_SELECTOR: string;
+/** The first element inside `root` that Tab reaches, or null. @internal */
+export declare function firstTabbable(root: Element | null): HTMLElement | null;
+//# sourceMappingURL=focusTrap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"focusTrap.d.ts","sourceRoot":"","sources":["../../../src/components/shared/focusTrap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,SAAS,MAAM,kCAAkC,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEvE,wDAAwD;AACxD,eAAO,MAAM,SAAS,kBAAY,CAAC;AAEnC,oEAAoE;AACpE,MAAM,MAAM,cAAc,GAAG,cAAc,CAAC;AAE5C,iEAAiE;AACjE,eAAO,MAAM,iBAAiB,QAYnB,CAAC;AAEZ,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,WAAW,GAAG,IAAI,CAMtE"}

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

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview getInitials: up to two initials from a name, safe for any Unicode letter
+ * (master-plan C-21).
+ * @module components/shared/getInitials
+ *
+ * @internal — not part of the public API; see ADR-02
+ */
+/**
+ * The initials of a name: the first character of each of its first two words, upper-cased.
+ *
+ * - Characters are code points (`Array.from`), so a letter outside the Basic Multilingual
+ *   Plane (`𝒜`, `𠀋`, an emoji) is kept whole instead of being cut into half a surrogate pair.
+ * - Words are split on any whitespace; leading, trailing and repeated whitespace is ignored.
+ *   An empty or whitespace-only name gives `''`.
+ * - Without `locale`, `toUpperCase()` is locale-independent, so the server and the client
+ *   render the same text. Pass a locale for language-specific casing (`'tr'`: `i` becomes `İ`).
+ *
+ * UserAvatar and OrgChart use it; AuditDrawer moves onto it in C-34.
+ *
+ * @example
+ * ```ts
+ * getInitials('Ada Lovelace'); // 'AL'
+ * getInitials('  grace   brewster hopper '); // 'GB'
+ * getInitials('ilkay', 'tr'); // 'İ'
+ * ```
+ * @internal
+ */
+export declare function getInitials(name: string, locale?: string | string[]): string;
+//# sourceMappingURL=getInitials.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getInitials.d.ts","sourceRoot":"","sources":["../../../src/components/shared/getInitials.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAW5E"}

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

@@ -0,0 +1,69 @@
+/**
+ * Heading-level contract (master plan WI-45, ADR-19 (2); docs/NAMING.md, "Heading level").
+ *
+ * One public type and two internal helpers, used by every component that renders its own title
+ * as a heading (AIContainer, AISourcesSection, AIExplainability, ChatHeader, AIDigestCard,
+ * AIChainOfThought phases, ChatThread) and by components that shift authored headings
+ * (AITextBlock's `headingOffset`).
+ *
+ * - `headingLevel?: HeadingLevel` sets the element of the component's own title. Level 1 is
+ *   reserved for the page.
+ * - The default preserves today's element, so adding the prop changes no DOM.
+ * - `headingOffset` (0-5) shifts authored headings inside content, clamped at h6.
+ * - A component whose title is not a heading takes `component`, never `headingLevel`.
+ *
+ * Invalid levels throw in development, so a wrong value is caught at once; in production they
+ * clamp into range, so a page never crashes over a heading.
+ *
+ * @module components/shared/headingLevel
+ *
+ * @internal — not part of the public API; see ADR-02
+ * (The `HeadingLevel` type is public: src/index.ts exports it. The helpers are internal.)
+ */
+/**
+ * The level of the heading element a component renders for its own title: 2 to 6, for h2 to
+ * h6. Level 1 is reserved for the page title. Every `headingLevel` prop uses this type (NAMING,
+ * "Heading level"), and its default keeps the element the component rendered before the prop.
+ *
+ * @example
+ * ```ts
+ * interface ReportCardProps {
+ *   title: string;
+ *   // Element of the title. Default 3: the card rendered an h3 before the prop existed.
+ *   headingLevel?: HeadingLevel;
+ * }
+ * ```
+ *
+ * @since 2.13.0
+ */
+export type HeadingLevel = 2 | 3 | 4 | 5 | 6;
+/**
+ * How many levels authored headings shift down, for example in markdown content: 0 to 5.
+ * The result is clamped at h6.
+ *
+ * @internal
+ */
+export type HeadingOffset = 0 | 1 | 2 | 3 | 4 | 5;
+/** @internal */
+export type HeadingElement = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+/**
+ * The element for a component's own title: `headingComponent(3)` is `'h3'`.
+ *
+ * @throws RangeError in development for anything but 2, 3, 4, 5 or 6. In production the level
+ *   is rounded and clamped into 2-6 (a non-number gives 'h2').
+ *
+ * @internal
+ */
+export declare function headingComponent(level: HeadingLevel): Exclude<HeadingElement, 'h1'>;
+/**
+ * The element for an authored heading (level 1-6, as written in the content) shifted down by
+ * `offset`, clamped at h6: `offsetHeadingComponent(1, 2)` is `'h3'`, `offsetHeadingComponent(5, 3)`
+ * is `'h6'`. The default offset 0 keeps the authored level.
+ *
+ * @throws RangeError in development for a level outside 1-6 or an offset outside 0-5. In
+ *   production both are rounded and clamped into range.
+ *
+ * @internal
+ */
+export declare function offsetHeadingComponent(level: 1 | 2 | 3 | 4 | 5 | 6, offset?: HeadingOffset): HeadingElement;
+//# sourceMappingURL=headingLevel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"headingLevel.d.ts","sourceRoot":"","sources":["../../../src/components/shared/headingLevel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE7C;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAElD,gBAAgB;AAChB,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAWrE;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,EAAE,IAAI,CAAC,CAMnF;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,MAAM,GAAE,aAAiB,GAAG,cAAc,CAQ9G"}

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

@@ -0,0 +1,50 @@
+/**
+ * @fileoverview mergeSlotProps: a slot's own props merged with the consumer's slotProps
+ * (ADR-04 (6), master-plan E-15).
+ * @module components/shared/mergeSlotProps
+ *
+ * @internal — not part of the public API; see ADR-02
+ *
+ * Merge rules, tested once here so every component's slots behave the same:
+ *
+ * - `sx`: the slot's own sx, then the consumer's ({@link mergeSx}).
+ * - `className`: both, the slot's first.
+ * - `style`: shallow merge, the consumer's keys win.
+ * - Event handlers (`on*`): when both are functions, the slot's own runs first, then the
+ *   consumer's, with the same arguments.
+ * - `aria-describedby` and `aria-labelledby`: both id lists, joined.
+ * - Owned attributes ({@link OwnedAttribute}): the slot's own values stay. A consumer value
+ *   is dropped, with a development warning (once per component).
+ * - Any other prop: the consumer's value wins, unless it is `undefined`. Read references
+ *   such as `id` from the merged result, so they follow a consumer's override.
+ *
+ * Slots are Trinity-owned: never pass the result straight into an MUI component's own
+ * slotProps without mapping it (ADR-04 (6)).
+ *
+ * @example
+ * ```tsx
+ * const titleProps = mergeSlotProps({ id: titleId, sx: titleSx }, slotProps?.title, { componentName: 'AIReviewItem', slotName: 'title' });
+ * <Typography {...titleProps} />  // and aria-labelledby={titleProps.id} on the region
+ * ```
+ */
+import type * as React from 'react';
+import { type OwnedAttribute, type TrinitySlotProps } from './rootProps';
+/**
+ * The props a component gives its own slot: the consumer's slot props plus the owned
+ * attributes, which only the component may set.
+ * @internal
+ */
+export type SlotOwnProps<El extends HTMLElement = HTMLElement> = TrinitySlotProps<El> & Partial<Pick<React.HTMLAttributes<El>, OwnedAttribute>>;
+/** Options of {@link mergeSlotProps}. @internal */
+export interface MergeSlotPropsOptions {
+    /** Names the component in the development warning. */
+    componentName?: string;
+    /** Names the slot in the development warning. */
+    slotName?: string;
+}
+/**
+ * Merges a slot's own props (`own`) with the consumer's `slotProps.<slot>` (`consumer`).
+ * @internal
+ */
+export declare function mergeSlotProps<El extends HTMLElement = HTMLElement>(own: SlotOwnProps<El> | undefined, consumer: TrinitySlotProps<El> | undefined, options?: MergeSlotPropsOptions): SlotOwnProps<El>;
+//# sourceMappingURL=mergeSlotProps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeSlotProps.d.ts","sourceRoot":"","sources":["../../../src/components/shared/mergeSlotProps.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAC;AAGpC,OAAO,EAA+D,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEtI;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,EAAE,SAAS,WAAW,GAAG,WAAW,IAAI,gBAAgB,CAAC,EAAE,CAAC,GACnF,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,EAAE,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;AAE1D,mDAAmD;AACnD,MAAM,WAAW,qBAAqB;IACpC,sDAAsD;IACtD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAWD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,SAAS,WAAW,GAAG,WAAW,EACjE,GAAG,EAAE,YAAY,CAAC,EAAE,CAAC,GAAG,SAAS,EACjC,QAAQ,EAAE,gBAAgB,CAAC,EAAE,CAAC,GAAG,SAAS,EAC1C,OAAO,GAAE,qBAA0B,GAClC,YAAY,CAAC,EAAE,CAAC,CAiClB"}

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

@@ -0,0 +1,26 @@
+/**
+ * @fileoverview mergeSx: one ordered sx array from several parts (ADR-04 (4), master-plan E-15).
+ * @module components/shared/mergeSx
+ *
+ * @internal — not part of the public API; see ADR-02
+ *
+ * Object spread of `sx` drops function sx and turns array sx into keys '0', '1' (ADR-04).
+ * `mergeSx(base, sx)` replaces both that and the hand-written
+ * `[base, ...(Array.isArray(sx) ? sx : [sx])]`: objects and functions are kept as entries,
+ * arrays are flattened one level, and `false`, `true`, `null` and `undefined` are dropped.
+ * Later parts win, so pass the component's own styles first and the consumer's `sx` last.
+ *
+ * @example
+ * ```tsx
+ * <Box sx={mergeSx({ display: 'flex' }, dense && { gap: 0.5 }, sx)} />
+ * ```
+ */
+import type { SxProps, Theme } from '@mui/material/styles';
+/** One part of {@link mergeSx}: any sx value, or a falsy value to skip. @internal */
+export type SxPart = SxProps<Theme> | false | null | undefined;
+/**
+ * Merges sx parts into one ordered array that MUI resolves left to right.
+ * @internal
+ */
+export declare function mergeSx(...parts: SxPart[]): SxProps<Theme>;
+//# sourceMappingURL=mergeSx.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeSx.d.ts","sourceRoot":"","sources":["../../../src/components/shared/mergeSx.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE3D,qFAAqF;AACrF,MAAM,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,CAAC;AAQ/D;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,CAU1D"}

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

@@ -0,0 +1,110 @@
+/**
+ * @fileoverview Motion helpers: token durations in milliseconds, reduced-motion styles and
+ * scoped keyframes (master-plan E-13, ADR-11 §4).
+ * @module components/shared/motion
+ *
+ * @internal — not part of the public API; see ADR-02
+ *
+ * The motion policy (docs/TOKEN_USAGE_RULES.md, "Motion"):
+ *
+ * - Durations and easings come from `semanticTokens.motion` (or `aiTokens.motion`), never
+ *   from literals (ADR-22-R7, the motion-literal rule).
+ * - An infinite loop stops under reduced motion, and the state it shows stays visible: wrap
+ *   the stop in {@link reducedMotion}.
+ * - An entrance falls back to an instant change of opacity under reduced motion.
+ * - A JavaScript timeout (a MUI `Fade` or `Collapse` `timeout`, a delayed state change that
+ *   waits for an animation) reads {@link useMotionTimeout}, which is 0 under reduced motion.
+ * - Keyframes come only from {@link keyframes}, which gives each animation a scoped,
+ *   collision-free name. A nested `'@keyframes name'` key in `sx` declares a global name: two
+ *   components that both say `pulse` overwrite each other (E-13's characterization test).
+ *
+ * Components guard their own motion with these helpers, because only the component knows
+ * which state a stopped loop must keep visible. The theme's CssBaseline backstop (E-44+)
+ * collapses whatever they miss; motion that must keep running opts out with
+ * {@link ESSENTIAL_MOTION_CLASS}.
+ *
+ * @example
+ * ```tsx
+ * const spin = keyframes({ from: { transform: 'rotate(0deg)' }, to: { transform: 'rotate(360deg)' } });
+ * <Box sx={{
+ *   animation: `${spin} ${semanticTokens.motion.loop.spin} linear infinite`,
+ *   ...reducedMotion({ animation: 'none' }),
+ * }} />
+ *
+ * const timeout = useMotionTimeout(semanticTokens.motion.duration.slower);
+ * <Collapse in={open} timeout={timeout} />
+ * ```
+ */
+import { keyframes } from '@mui/material/styles';
+import type { CSSObject } from '@mui/material/styles';
+import { REDUCED_MOTION_QUERY } from '../../accessibility';
+import type { TrinitySemanticMotion } from '../../tokens';
+export { keyframes };
+/**
+ * A motion token in milliseconds: `'200ms'` → 200, `'1.5s'` → 1500, and a number is taken as
+ * milliseconds already. Throws on anything that is not a CSS time, so a malformed token fails
+ * loudly instead of turning into `NaN` or 0. The theme reads its transitions with the same
+ * parser (`cssTimeToMs`).
+ */
+export declare function toMs(token: string | number): number;
+/**
+ * The token's duration in milliseconds for a JavaScript timeout, or 0 when the user prefers
+ * reduced motion. SSR-stable: the server render and the hydration render use the token's
+ * duration, then the component re-renders with the user's preference (ADR-27).
+ */
+export declare function useMotionTimeout(token: string | number): number;
+/**
+ * Styles that apply only under reduced motion, keyed by the shared
+ * `REDUCED_MOTION_QUERY`, for spreading into an `sx` object:
+ * `{ animation: …, ...reducedMotion({ animation: 'none' }) }`.
+ */
+export declare function reducedMotion(styles: CSSObject): Record<typeof REDUCED_MOTION_QUERY, CSSObject>;
+/**
+ * The class that exempts an element from the theme's reduced-motion backstop. Only for motion
+ * that carries information with no static equivalent; the element still respects reduced
+ * motion in its own styles where it can. The exemption covers the element and its `::before`
+ * and `::after`, not its descendants.
+ */
+export declare const ESSENTIAL_MOTION_CLASS = "trinity-essential-motion";
+/** The duration the backstop gives every transition and animation under reduced motion. */
+export declare const REDUCED_MOTION_DURATION = "0.01ms";
+/**
+ * The theme's `transitions` option, read from the semantic motion tokens. Value-neutral where
+ * MUI's default equals a token, so default motion does not change:
+ *
+ * | theme.transitions | MUI default | Token |
+ * |---|---|---|
+ * | `duration.shortest` | 150 | `motion.duration.fast` |
+ * | `duration.shorter` | 200 | `motion.duration.normal` |
+ * | `duration.standard` | 300 | `motion.duration.slow` |
+ * | `easing.easeInOut` | `cubic-bezier(0.4, 0, 0.2, 1)` | `motion.easing.default` |
+ * | `easing.easeOut` | `cubic-bezier(0.0, 0, 0.2, 1)` | `motion.easing.enter` (the same curve) |
+ * | `easing.easeIn` | `cubic-bezier(0.4, 0, 1, 1)` | `motion.easing.exit` |
+ *
+ * MUI's `duration.short` (250), `complex` (375), `enteringScreen` (225), `leavingScreen` (195)
+ * and `easing.sharp` have no equal token and keep MUI's values (C-26 keeps 225/195 for the
+ * drawers and dialogs); docs/remediation/E-44-theme-motion-backstop.md records them. Token
+ * overrides now reach `theme.transitions`.
+ */
+export declare function themeTransitions(motion: TrinitySemanticMotion): {
+    duration: {
+        shortest: number;
+        shorter: number;
+        standard: number;
+    };
+    easing: {
+        easeInOut: string;
+        easeOut: string;
+        easeIn: string;
+    };
+};
+/**
+ * The CssBaseline `styleOverrides` that collapse motion under `REDUCED_MOTION_QUERY`: every
+ * element except one with {@link ESSENTIAL_MOTION_CLASS} (and its `::before` and `::after`)
+ * gets 0.01ms animation and transition durations, one animation iteration and
+ * `scroll-behavior: auto`. An animation jumps to its end state and a transition to its target.
+ * A safety net only: components still guard their own motion, because only a component knows
+ * which state a stopped loop must keep visible.
+ */
+export declare function reducedMotionBackstop(): CSSObject;
+//# sourceMappingURL=motion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"motion.d.ts","sourceRoot":"","sources":["../../../src/components/shared/motion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAoB,MAAM,qBAAqB,CAAC;AAE7E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,EAAE,SAAS,EAAE,CAAC;AAErB;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAEnD;AAGD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAG/D;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,OAAO,oBAAoB,EAAE,SAAS,CAAC,CAE/F;AAOD;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,6BAA6B,CAAC;AAEjE,2FAA2F;AAC3F,eAAO,MAAM,uBAAuB,WAAW,CAAC;AAEhD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,qBAAqB;;;;;;;;;;;EAa7D;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,IAAI,SAAS,CAYjD"}

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

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Stable React keys for lists whose items carry no id (WI-52).
+ * @module components/shared/occurrenceKeys
+ *
+ * @internal — not part of the public API; see ADR-02
+ */
+/**
+ * Stable React keys for a list whose items carry no id.
+ *
+ * Each key is the item's natural identity (a label, a URL, the text) plus how
+ * many earlier items share it, so duplicates stay distinct. Removing or
+ * reordering items leaves every other item's key unchanged: React keeps each
+ * DOM node, and the focus inside it, with the same logical item. An index key
+ * hands the node to whichever item now sits at that index, so focus silently
+ * moves to a different item (WCAG 2.4.3).
+ *
+ * The key is a JSON pair, so no identity string can collide with another
+ * identity's counted form.
+ *
+ * @internal Not exported from any package entry.
+ */
+export declare function occurrenceKeys<T>(items: readonly T[], identity: (item: T) => string): string[];
+//# sourceMappingURL=occurrenceKeys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"occurrenceKeys.d.ts","sourceRoot":"","sources":["../../../src/components/shared/occurrenceKeys.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,MAAM,EAAE,CAQ9F"}

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

@@ -0,0 +1,89 @@
+/**
+ * @fileoverview Primary-action overlay: one pattern for a clickable container that holds nested actions.
+ * @module components/shared/primaryAction
+ *
+ * @internal — not part of the public API; see ADR-02
+ *
+ * A card or row that is clickable as a whole, and also holds its own buttons
+ * or links, must not become one big button: that nests interactive content
+ * (axe `nested-interactive`), and the nested actions lose their names. Use
+ * three layers instead (BEHAVIOR_CONTRACT §2 "Pressable elements"):
+ *
+ * 1. The host gets `primaryActionContainerSx` (`position: relative`).
+ * 2. Its first child is the primary action: a `ButtonBase` with
+ *    `disableRipple` and `primaryActionOverlaySx`. It covers the host
+ *    (`inset: 0`) and takes its name from the title through
+ *    `aria-labelledby`.
+ * 3. The content follows in a box with `primaryActionContentSx`. It sits
+ *    above the overlay and lets clicks fall through to it, except on
+ *    interactive descendants (buttons, links, inputs, `[tabindex]`), which
+ *    keep their own clicks.
+ *
+ * Tab order follows the DOM: the primary action first, then the nested
+ * actions. Enter and Space work because the overlay is a real button.
+ *
+ * The focus ring: MUI Card sets `overflow: hidden`, and the theme draws the
+ * ButtonBase ring outside the element (`outlineOffset: 2`). A ring on an
+ * overlay with `inset: 0` would be clipped. The overlay draws the same ring
+ * inside the host instead: the offset is minus the focus border width
+ * (`semanticTokens.borders.width.focus`), so the theme's ring colour stays.
+ *
+ * Fallback, if a browser clips the inset ring: draw it on the host with
+ * `'&:has(> .<overlay class>:focus-visible)': { outline: …, outlineOffset: -2 }`
+ * and remove the overlay's outline. Every browser that runs the
+ * test:storybook check (Chromium) passes without it.
+ *
+ * Limits: text in the content layer cannot be selected with the mouse,
+ * because the overlay takes the press. A component that needs selectable
+ * text keeps an explicit action button instead.
+ *
+ * @example
+ * ```tsx
+ * const titleId = React.useId();
+ * <Card sx={primaryActionContainerSx}>
+ *   <ButtonBase disableRipple aria-labelledby={titleId} onClick={open} sx={primaryActionOverlaySx} />
+ *   <Box sx={primaryActionContentSx}>
+ *     <Typography id={titleId}>Q3 report</Typography>
+ *     <Tooltip title="More actions">
+ *       <IconButton aria-label="More actions" onClick={openMenu}><MoreIcon /></IconButton>
+ *     </Tooltip>
+ *   </Box>
+ * </Card>
+ * ```
+ */
+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 helper with its own styles: `sx={[{ overflow: 'hidden' }, primaryActionContainerSx]}`.
+ */
+type SxStyleObject = Exclude<Extract<SxProps<Theme>, ReadonlyArray<unknown>>[number], boolean | ((theme: Theme) => unknown)>;
+/**
+ * A CSS selector for interactive elements. A host that also handles clicks
+ * itself (a table row) uses it to ignore clicks that started on a nested
+ * control: `(event.target as Element).closest(PRIMARY_ACTION_INTERACTIVE_SELECTOR)`.
+ *
+ * @internal
+ */
+export declare const PRIMARY_ACTION_INTERACTIVE_SELECTOR: string;
+/**
+ * The host: positions the overlay. Required on the element the overlay covers.
+ *
+ * @internal
+ */
+export declare const primaryActionContainerSx: SxStyleObject;
+/**
+ * The primary action: a `ButtonBase` with `disableRipple`, the host's first
+ * child. It covers the host and draws the theme's focus ring inside it.
+ *
+ * @internal
+ */
+export declare const primaryActionOverlaySx: SxStyleObject;
+/**
+ * The content layer: above the overlay. Clicks on plain content reach the
+ * overlay; interactive descendants keep their own.
+ *
+ * @internal
+ */
+export declare const primaryActionContentSx: SxStyleObject;
+export {};
+//# sourceMappingURL=primaryAction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"primaryAction.d.ts","sourceRoot":"","sources":["../../../src/components/shared/primaryAction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;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;AAqB7H;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC,QAAyB,CAAC;AAI1E;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,EAAE,aAEtC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,aAQpC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,aAOpC,CAAC"}

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

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Keyboard model for resizable surfaces (internal).
+ * @module components/shared/resizeKeyboard
+ *
+ * @internal — not part of the public API; see ADR-02
+ *
+ * One keyboard model for the two resizable surfaces: SplitPane's separator and
+ * ResizablePanel's window splitter (APG Window Splitter). It is extracted from
+ * SplitPane's handler, the only RTL-aware keyboard resize in the library:
+ *
+ * - Arrow keys move the separator by `step` (10px), or `largeStep` (50px) with Shift.
+ * - Home goes to `min`, End goes to `max`.
+ * - Under RTL the horizontal arrows swap, so the arrow that points to the
+ *   inline end always moves the separator toward the inline end.
+ *
+ * SplitPane adopts it in H-33 and ResizablePanel in H-31. Until then neither
+ * calls it. It is not exported from any package entry.
+ */
+/** Layout of the two areas the separator divides (SplitPane's `direction`). */
+export type ResizeOrientation = 'horizontal' | 'vertical';
+/**
+ * Which way the resized area grows. 'forward': it grows when the separator
+ * moves toward the inline end (horizontal) or down (vertical), as SplitPane's
+ * first pane does. 'reverse': it grows when the separator moves the other way,
+ * as a panel docked at the inline end does. Same meaning as useResizable's
+ * `direction` option.
+ */
+export type ResizeGrowDirection = 'forward' | 'reverse';
+export interface ResizeKeyOptions {
+    /** Whether Shift is held: the arrow keys then use `largeStep`. */
+    shiftKey?: boolean;
+    /** 'horizontal': the areas sit side by side and the size is a width. */
+    orientation: ResizeOrientation;
+    /** Which way the resized area grows. */
+    growDirection: ResizeGrowDirection;
+    /** Right-to-left layout (`theme.direction === 'rtl'`). Swaps the horizontal arrows. */
+    isRtl: boolean;
+    /** The current size, in px. */
+    current: number;
+    /** The smallest size, in px. Home goes here. */
+    min: number;
+    /** The largest size, in px. End goes here. */
+    max: number;
+    /** Arrow-key step, in px. @default 10 */
+    step?: number;
+    /** Arrow-key step with Shift, in px. @default 50 */
+    largeStep?: number;
+    /**
+     * Also move the separator with the arrows of the other axis: Down and Right
+     * move it forward, Up and Left move it back, with no RTL swap. SplitPane does
+     * this today; APG and ResizablePanel use only the arrows of the separator's
+     * own axis. @default false
+     */
+    crossAxisKeys?: boolean;
+}
+/** Arrow-key step, in px (SplitPane and ResizablePanel). */
+export declare const RESIZE_KEY_STEP = 10;
+/** Arrow-key step with Shift, in px (SplitPane and ResizablePanel). */
+export declare const RESIZE_KEY_LARGE_STEP = 50;
+/**
+ * The size a key press resizes to, or `null` when the key is not a resize key
+ * (the caller then leaves the event alone). Arrow results are clamped to
+ * `[min, max]`; when `min` is above `max` (a container too small for both
+ * bounds), `min` wins, as in SplitPane's clamp. Home returns `min` and End
+ * returns `max`.
+ */
+export declare function getResizeKeyTarget(key: string, options: ResizeKeyOptions): number | null;
+//# sourceMappingURL=resizeKeyboard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resizeKeyboard.d.ts","sourceRoot":"","sources":["../../../src/components/shared/resizeKeyboard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,UAAU,CAAC;AAE1D;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,SAAS,CAAC;AAExD,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,wEAAwE;IACxE,WAAW,EAAE,iBAAiB,CAAC;IAC/B,wCAAwC;IACxC,aAAa,EAAE,mBAAmB,CAAC;IACnC,uFAAuF;IACvF,KAAK,EAAE,OAAO,CAAC;IACf,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,gDAAgD;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,yCAAyC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,4DAA4D;AAC5D,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,uEAAuE;AACvE,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAqBxC;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,MAAM,GAAG,IAAI,CAuBxF"}