@slotted/react 0.0.0-stage → 0.1.0-beta.0

package/dist/tree.js

@@ -0,0 +1,2 @@
+import { a as e, c as t, d as n, f as r, i, l as a, n as o, o as s, r as c, s as l, t as u, u as d } from "./tree-C6fYJqT9.js";
+export { u as Tree, a as TreeDefaultsProvider, o as TreeDescription, c as TreeEmpty, i as TreeGroup, e as TreeIcon, s as TreeLabel, l as TreeMeta, t as TreeNode, n as useTree, d as useTreeDefaults, r as useTreeDepth };

package/dist/types/accordion/accordion-defaults.d.ts

@@ -0,0 +1,10 @@
+import type { AccordionDefaults, AccordionDefaultsProviderProps } from './accordion.types';
+/** What an accordion renders as here, before it states anything of its own. */
+export declare function useAccordionDefaults(): AccordionDefaults;
+/**
+ * An application decides once how its accordions look and behave, rather than
+ * repeating the same ten props on every set in a product. A set that states any
+ * of them itself still wins.
+ */
+export declare function AccordionDefaultsProvider({ children, ...defaults }: AccordionDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=accordion-defaults.d.ts.map

package/dist/types/accordion/accordion-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accordion-defaults.d.ts","sourceRoot":"","sources":["../../../src/accordion/accordion-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,8BAA8B,EAAE,MAAM,mBAAmB,CAAC;AAiB3F,+EAA+E;AAC/E,wBAAgB,oBAAoB,IAAI,iBAAiB,CAExD;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,EACR,GAAG,QAAQ,EACZ,EAAE,8BAA8B,+BAqBhC"}

package/dist/types/accordion/accordion.d.ts

@@ -0,0 +1,38 @@
+
+import type { AccordionContextValue, AccordionProps } from './accordion.types';
+/**
+ * The header of every item this set owns, and of no set nested inside it.
+ * `:scope` is what stops a nested accordion's headers from joining the outer
+ * one's arrow ring: root, item, header, trigger is exactly four levels.
+ */
+export declare const ACCORDION_TRIGGER_SELECTOR = ":scope > * > [data-part=\"header\"] > [data-part=\"trigger\"]";
+/**
+ * The set around this disclosure, or `undefined` for one standing on its own.
+ *
+ * It is `undefined` rather than a throw because a `Collapsible` outside an
+ * accordion is a complete component: it owns its own `open`, and the group is
+ * one of three places that value can come from.
+ */
+export declare function useAccordion(): AccordionContextValue | undefined;
+/**
+ * A set of disclosures that share a value.
+ *
+ * **The keyboard is the pattern's, plus four keys that are not.** `Enter`,
+ * `Space`, `Tab` and `Shift + Tab` are the platform's, and every header stays in
+ * the page tab sequence — `w3c/aria-practices#3434` removed the roving
+ * alternative from the pattern, and Base UI deprecated its own `loopFocus` and
+ * `orientation` in the same change. `ArrowDown`, `ArrowUp`, `Home` and `End` are
+ * shipped on top of that sequence, because Radix and Ark both ship them and
+ * readers have learned them; they move focus and write no `tabindex`.
+ *
+ * **`requireOpen` marks the header it holds.** The pattern asks an accordion
+ * that does not permit a panel to be collapsed to write `aria-disabled="true"`
+ * on that header, and the APG's own example is the only surveyed source that
+ * ships it.
+ *
+ * **The items are `collapsible`s, and nothing here selects into them.** The set
+ * hands each one its appearance as a value, which is the rule `checkbox-group`
+ * set for every group family in the library.
+ */
+export declare function Accordion({ children, className, defaultValue, disabled, handle, headingLevel, indicator, loop, mount, multiple, onValueChange, ref, render, requireOpen, size, style, togglePlacement, truncate, value, variant, ...nativeProps }: AccordionProps): import("react").JSX.Element;
+//# sourceMappingURL=accordion.d.ts.map

package/dist/types/accordion/accordion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accordion.d.ts","sourceRoot":"","sources":["../../../src/accordion/accordion.tsx"],"names":[],"mappings":"AAAA,OAAO,yCAAyC,CAAC;AAQjD,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EAIf,MAAM,mBAAmB,CAAC;AAE3B;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,kEACsB,CAAC;AAyB9D;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,qBAAqB,GAAG,SAAS,CAEhE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,CAAC,EACxB,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,YAAY,EACZ,SAAS,EACT,IAAI,EACJ,KAAK,EACL,QAAQ,EACR,aAAa,EACb,GAAG,EACH,MAAM,EACN,WAAW,EACX,IAAI,EACJ,KAAK,EACL,eAAe,EACf,QAAQ,EACR,KAAK,EACL,OAAO,EACP,GAAG,WAAW,EACf,EAAE,cAAc,+BA2IhB"}

package/dist/types/accordion/accordion.types.d.ts

@@ -0,0 +1,124 @@
+import type { ChangeRequest } from '@slotted/core/state';
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode, Ref } from 'react';
+/** The type step the set and its items sit at. */
+export type AccordionSize = 'sm' | 'md' | 'lg';
+/**
+ * How the set is drawn. `plain` paints nothing, `ruled` puts one hairline per
+ * seam, `framed` wraps the ruled set in one frame, and `separated` gives every
+ * item a card of its own.
+ */
+export type AccordionVariant = 'plain' | 'ruled' | 'framed' | 'separated';
+/** The mark each header carries. Handed to every item. */
+export type AccordionIndicator = 'chevron' | 'plus-minus' | 'none';
+/** Which side of the words that mark stands on. Handed to every item. */
+export type AccordionTogglePlacement = 'end' | 'start';
+/**
+ * The heading level every item's header renders as. `3` is the default, which
+ * is the level the APG's own example uses for a set inside a section.
+ */
+export type AccordionHeadingLevel = 'none' | '1' | '2' | '3' | '4' | '5' | '6';
+/** When each panel exists. Handed to every item. */
+export type AccordionMount = 'active' | 'lazy' | 'eager' | 'until-found';
+/** Why the set of open panels moved. */
+export type AccordionSelectionReason = Extract<ChangeRequest<readonly string[]>['reason'], 'pointer' | 'keyboard' | 'select' | 'programmatic'>;
+/** The request the family emits before the value moves. */
+export type AccordionChangeRequest = ChangeRequest<readonly string[]>;
+/** What an application sets once for every accordion under it. */
+export interface AccordionDefaults {
+    headingLevel: AccordionHeadingLevel;
+    indicator: AccordionIndicator;
+    loop: boolean;
+    mount: AccordionMount;
+    multiple: boolean;
+    requireOpen: boolean;
+    size: AccordionSize;
+    togglePlacement: AccordionTogglePlacement;
+    truncate: boolean;
+    variant: AccordionVariant;
+}
+export interface AccordionDefaultsProviderProps extends Partial<AccordionDefaults> {
+    children?: ReactNode | undefined;
+}
+/**
+ * What the set hands every disclosure inside it.
+ *
+ * The appearance is handed over as a value rather than reached for with a
+ * descendant rule: a stylesheet selecting `[data-ui='collapsible']` from the
+ * group would make one family's DOM part of another's contract.
+ */
+export interface AccordionContextValue {
+    disabled: boolean;
+    indicator: AccordionIndicator;
+    /** The heading level, under the name the item reads it by. */
+    level: AccordionHeadingLevel;
+    mount: AccordionMount;
+    size: AccordionSize;
+    togglePlacement: AccordionTogglePlacement;
+    truncate: boolean;
+    /** The item's own variant, which is not always the set's. */
+    variant: 'plain' | 'ruled' | 'framed';
+    /** Whether this value is one of the open ones. */
+    isOpen: (value: string) => boolean;
+    /** Whether this value is open and the set refuses to let it close. */
+    isHeld: (value: string) => boolean;
+    /** Asks the set to open or close one value. */
+    toggle: (value: string, reason: AccordionSelectionReason, source: unknown) => void;
+}
+/** What `render` receives for the set's root. */
+export interface AccordionRootProps extends HTMLAttributes<HTMLElement> {
+    'data-disabled'?: '' | undefined;
+    'data-part': string;
+    'data-size': AccordionSize;
+    'data-ui': string;
+    'data-variant': AccordionVariant;
+}
+/** The two moves an array cannot express while the family owns the array. */
+export interface AccordionHandle {
+    /** Opens every item that is not disabled, with the reason `programmatic`. */
+    openAll: () => void;
+    /** Closes every item, unless `requireOpen` holds the last one. */
+    closeAll: () => void;
+}
+export interface AccordionProps extends Omit<ComponentPropsWithRef<'div'>, 'defaultValue'> {
+    /** The set an uncontrolled accordion starts from, read once. */
+    defaultValue?: readonly string[] | undefined;
+    /** Reaches every item, and every trigger as the native attribute. */
+    disabled?: boolean | undefined;
+    /**
+     * The two moves an array cannot express while the family owns the array.
+     * They are on a handle of their own so `ref` keeps reaching the element,
+     * which is the library's rule for every other family.
+     */
+    handle?: Ref<AccordionHandle> | undefined;
+    /** Defaults to the provider, then to `3`. */
+    headingLevel?: AccordionHeadingLevel | undefined;
+    /** Defaults to the provider, then to `chevron`. */
+    indicator?: AccordionIndicator | undefined;
+    /** Whether the arrow keys wrap past the ends of the set. */
+    loop?: boolean | undefined;
+    /** Defaults to the provider, then to `eager`. */
+    mount?: AccordionMount | undefined;
+    /** Whether more than one panel may be open at once. */
+    multiple?: boolean | undefined;
+    /** Called before the value moves, with the request that carries the reason. */
+    onValueChange?: ((value: readonly string[], request: AccordionChangeRequest) => void) | undefined;
+    /**
+     * Whether the set refuses to empty. The one open header then carries
+     * `aria-disabled="true"`, which is what the pattern asks of an accordion that
+     * does not permit its panel to be collapsed.
+     */
+    requireOpen?: boolean | undefined;
+    /** Renders the set's root into another element. */
+    render?: ((props: AccordionRootProps) => ReactNode) | undefined;
+    /** Defaults to the provider, then to `md`. */
+    size?: AccordionSize | undefined;
+    /** Defaults to the provider, then to `end`. */
+    togglePlacement?: AccordionTogglePlacement | undefined;
+    /** Clips every title to one line instead of letting the row grow. */
+    truncate?: boolean | undefined;
+    /** Present means controlled, for the life of the component. */
+    value?: readonly string[] | undefined;
+    /** Defaults to the provider, then to `ruled`. */
+    variant?: AccordionVariant | undefined;
+}
+//# sourceMappingURL=accordion.types.d.ts.map

package/dist/types/accordion/accordion.types.d.ts.map

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

package/dist/types/accordion/index.d.ts

@@ -0,0 +1,4 @@
+export { Accordion, ACCORDION_TRIGGER_SELECTOR, useAccordion } from './accordion';
+export { AccordionDefaultsProvider, useAccordionDefaults } from './accordion-defaults';
+export type { AccordionChangeRequest, AccordionContextValue, AccordionDefaults, AccordionDefaultsProviderProps, AccordionHandle, AccordionHeadingLevel, AccordionIndicator, AccordionMount, AccordionProps, AccordionRootProps, AccordionSelectionReason, AccordionSize, AccordionTogglePlacement, AccordionVariant, } from './accordion.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/accordion/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/accordion/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,0BAA0B,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAClF,OAAO,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACvF,YAAY,EACV,sBAAsB,EACtB,qBAAqB,EACrB,iBAAiB,EACjB,8BAA8B,EAC9B,eAAe,EACf,qBAAqB,EACrB,kBAAkB,EAClB,cAAc,EACd,cAAc,EACd,kBAAkB,EAClB,wBAAwB,EACxB,aAAa,EACb,wBAAwB,EACxB,gBAAgB,GACjB,MAAM,mBAAmB,CAAC"}

package/dist/types/action-bar/action-bar-context.d.ts

@@ -0,0 +1,68 @@
+import type { ReactNode } from 'react';
+import type { ActionBarPriority } from './action-bar.types';
+/**
+ * One action the surface holds, in the order the bar holds it.
+ *
+ * `separatorBefore` is derived rather than declared: the bar is the participant
+ * that hid the units, so it is the only one that knows which of its own rules
+ * are now dividing two things that are both in the surface.
+ */
+export interface ActionBarSurfaceUnit {
+    readonly id: string;
+    readonly separatorBefore: boolean;
+}
+export interface ActionBarOverflowValue {
+    /**
+     * Records what an action becomes in the surface. It is called during render
+     * and keyed by an identifier rather than by the element, because the element
+     * is not known until the ref callback runs and a consumer may put the trigger
+     * anywhere in the run — including before an action, where a registration made
+     * in an effect would be one render behind.
+     */
+    declare: (id: string, counterpart: ReactNode) => void;
+    release: (id: string) => void;
+    /** What the action with this identifier becomes. */
+    counterpart: (id: string) => ReactNode;
+    /** The control that opens what did not fit. The bar measures it. */
+    registerTrigger: (element: HTMLElement | null) => void;
+    /** The run, which is the box the collapse measures rather than the root. */
+    registerActions: (element: HTMLElement | null) => void;
+    /** What the surface holds: the collapsed actions and every `always` one. */
+    surface: readonly ActionBarSurfaceUnit[];
+}
+export declare const ActionBarOverflowContext: import("react").Context<ActionBarOverflowValue>;
+/**
+ * What an action and the trigger both read. A part rendered outside a bar takes
+ * the empty value rather than throwing: an `ActionBar.Action` around a control
+ * in a page that is not a bar is a box, and a box is a reasonable thing to be.
+ */
+export declare function useActionBarOverflow(): ActionBarOverflowValue;
+/** The attribute that says an action has somewhere to go. */
+export declare const UNIT_ATTRIBUTE = "data-unit";
+/** The attribute the measurement reads a rank from. */
+export declare const PRIORITY_ATTRIBUTE = "data-priority";
+/**
+ * The custom property the stacking query raises, read back by the measurement.
+ *
+ * The breakpoint is literal because `@container (width < var(--x))` is invalid,
+ * and it is written once — in the stylesheet. The binding asks CSS what it
+ * decided rather than comparing widths of its own, so the layout and the
+ * measurement cannot disagree about where the bar becomes a column.
+ */
+export declare const STACK_PROPERTY = "--_stacked";
+/**
+ * Where each rank stands in the order of giving way: the lowest goes first, and
+ * position decides inside one rank. `pinned` is absent because a pinned unit
+ * never gives way at all, and `always` because it is never in the bar to give.
+ */
+export declare const RANK: Readonly<Record<ActionBarPriority, number>>;
+/**
+ * The rank an action ends up at.
+ *
+ * A rank that needs somewhere to go and has nowhere behaves as `pinned`. It is a
+ * consumer error, and failing where it can be seen — the control stays in the
+ * bar — is the choice `docs/build-briefing.md` asks for when two answers are
+ * defensible.
+ */
+export declare function resolvePriority(stated: ActionBarPriority | undefined, hasCounterpart: boolean): ActionBarPriority;
+//# sourceMappingURL=action-bar-context.d.ts.map

package/dist/types/action-bar/action-bar-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-bar-context.d.ts","sourceRoot":"","sources":["../../../src/action-bar/action-bar-context.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AAED,MAAM,WAAW,sBAAsB;IACrC;;;;;;OAMG;IACH,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,KAAK,IAAI,CAAC;IACtD,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,oDAAoD;IACpD,WAAW,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,SAAS,CAAC;IACvC,oEAAoE;IACpE,eAAe,EAAE,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IACvD,4EAA4E;IAC5E,eAAe,EAAE,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IACvD,4EAA4E;IAC5E,OAAO,EAAE,SAAS,oBAAoB,EAAE,CAAC;CAC1C;AAWD,eAAO,MAAM,wBAAwB,iDAAiD,CAAC;AAEvF;;;;GAIG;AACH,wBAAgB,oBAAoB,2BAEnC;AAED,6DAA6D;AAC7D,eAAO,MAAM,cAAc,cAAc,CAAC;AAE1C,uDAAuD;AACvD,eAAO,MAAM,kBAAkB,kBAAkB,CAAC;AAElD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,eAAe,CAAC;AAE3C;;;;GAIG;AACH,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAM3D,CAAC;AAEH;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,iBAAiB,GAAG,SAAS,EACrC,cAAc,EAAE,OAAO,GACtB,iBAAiB,CAInB"}

package/dist/types/action-bar/action-bar-defaults.d.ts

@@ -0,0 +1,11 @@
+import type { ActionBarDefaults, ActionBarDefaultsProviderProps } from './action-bar.types';
+/** What a bar renders as here, before it states anything of its own. */
+export declare function useActionBarDefaults(): ActionBarDefaults;
+/**
+ * An application decides once how its action bars are drawn — a product whose
+ * bars are all raised, compact and stuck to the bottom of the page says so in
+ * one place rather than on every bar. A bar that states any of them itself
+ * still wins.
+ */
+export declare function ActionBarDefaultsProvider({ children, ...defaults }: ActionBarDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=action-bar-defaults.d.ts.map

package/dist/types/action-bar/action-bar-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-bar-defaults.d.ts","sourceRoot":"","sources":["../../../src/action-bar/action-bar-defaults.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAW5F,wEAAwE;AACxE,wBAAgB,oBAAoB,IAAI,iBAAiB,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,EACR,GAAG,QAAQ,EACZ,EAAE,8BAA8B,+BAehC"}

package/dist/types/action-bar/action-bar-demo.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+/**
+ * A panel that scrolls, so a sticky bar has something to stick inside.
+ *
+ * `.slotted-demo-viewport` carries `contain: paint`, which makes it the
+ * containing block a sticky element resolves against — so the bar sticks to the
+ * bottom of this box rather than to the Storybook canvas.
+ */
+export declare function ScrollingPanel({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * A selection a reader can turn on and off, for the bar a selection brings.
+ *
+ * The count is the consumer's — `table` owns the selection and says so in its
+ * own contract — and what the bar supplies is the place it goes and the entry it
+ * makes.
+ */
+export declare function Selection({ children, }: {
+    children: (state: {
+        count: number;
+        toggle: () => void;
+    }) => ReactNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=action-bar-demo.d.ts.map

package/dist/types/action-bar/action-bar-demo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-bar-demo.d.ts","sourceRoot":"","sources":["../../../src/action-bar/action-bar-demo.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,+BAMnE;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,EACxB,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,IAAI,CAAA;KAAE,KAAK,SAAS,CAAC;CACvE,+BAGA"}

package/dist/types/action-bar/action-bar-overflow.d.ts

@@ -0,0 +1,26 @@
+import type { ActionBarOverflowProps } from './action-bar.types';
+/**
+ * The control that opens what did not fit, and the surface holding it.
+ *
+ * It is `menu`'s trigger wearing this family's geometry, so the surface, its
+ * keyboard, its dismissal and its focus return are `menu`'s and are not written
+ * twice. What this family adds is the measurement: the bar decides which actions
+ * give way, by rank, and the counterparts they declared are rendered here in the
+ * order the bar holds them — with a separator wherever one of the bar's own
+ * rules sits between two of them.
+ *
+ * The surface also holds every action ranked `always`, which was never drawn in
+ * the bar at all. A reader opening the menu sees one list, so the two sources
+ * are read together and in the bar's own order.
+ *
+ * **The `hidden` attribute on the trigger belongs to the bar.** It is written by
+ * `createCollapse` rather than by this component, because the same measurement
+ * that decides whether the control is needed is the one that has to reveal it to
+ * read its width. React writes no `hidden` here, so the two never disagree.
+ *
+ * A bar with no `ActionBarOverflow` in it collapses nothing and wraps to a
+ * second row instead — including its `hide` actions, which need a bar that
+ * collapses in order to give way at all.
+ */
+export declare function ActionBarOverflow({ align, label, menuRef, ref, render, side, size, ...nativeProps }: ActionBarOverflowProps): import("react").JSX.Element;
+//# sourceMappingURL=action-bar-overflow.d.ts.map

package/dist/types/action-bar/action-bar-overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-bar-overflow.d.ts","sourceRoot":"","sources":["../../../src/action-bar/action-bar-overflow.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAA0B,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAgBzF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,KAAK,EACL,KAAK,EACL,OAAO,EACP,GAAG,EACH,MAAM,EACN,IAAI,EACJ,IAAI,EACJ,GAAG,WAAW,EACf,EAAE,sBAAsB,+BA6DxB"}

package/dist/types/action-bar/action-bar-parts.d.ts

@@ -0,0 +1,50 @@
+import type { ActionBarActionProps, ActionBarActionsProps, ActionBarSeparatorProps, ActionBarStatusProps } from './action-bar.types';
+/**
+ * The sentence at the start of the bar: a dirty-state marker, a timestamp, the
+ * count of what is selected and the control that selects the rest.
+ *
+ * It is a slot rather than a component. The library already has
+ * `inline-message`, `status-indicator` and `badge`, and `table` already owns the
+ * selection and its count; what this family supplies is the place, and the
+ * guarantee that filling it does not move the action that confirms.
+ */
+export declare function ActionBarStatus({ children, ref, render, ...nativeProps }: ActionBarStatusProps): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+/**
+ * The run of actions, and the box the collapse measures.
+ *
+ * It is the run rather than the root, because the root is the query container
+ * and a container is a container for its descendants and not for itself — so the
+ * rule that turns the run into a column has to reach a descendant. Measuring the
+ * root would also count the status region, which is not something the bar may
+ * give away.
+ */
+export declare function ActionBarActions({ children, ref, render, ...nativeProps }: ActionBarActionsProps): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+/**
+ * One action the bar may give up, its rank, and what it becomes when it goes.
+ *
+ * A unit is a direct child of the run, which is deliberately not the same thing
+ * as the control inside it: a `ButtonGroup` in a bar is one unit and four
+ * buttons, and the bar gives up the box rather than the buttons.
+ *
+ * The rank and the counterpart are one fact seen from two sides. A control with
+ * nothing to become in the surface is pinned — it has nowhere to go, which is
+ * why the action that confirms stays visible — and a rank that needs somewhere
+ * to go and has nowhere behaves as pinned too, so a consumer error leaves the
+ * control on the bar rather than hiding it silently.
+ */
+export declare function ActionBarAction({ children, counterpart, priority, ref, render, ...nativeProps }: ActionBarActionProps): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+/**
+ * A hairline between two runs of actions.
+ *
+ * It is the answer to the one line of `docs/component-features.md` §5 that names
+ * no mechanism: a destructive action does not sit flush against a frequent one.
+ * Half a gap on each side, which is wider than the distance between two
+ * controls, so the boundary reads as a boundary.
+ *
+ * It is a part of this family rather than a `divider` because its geometry
+ * belongs to the bar: it is measured against the controls beside it, and it
+ * turns with them when the bar becomes a column. `aria-orientation` states the
+ * axis of the rule itself, perpendicular to the one the actions run along.
+ */
+export declare function ActionBarSeparator({ ref, render, ...nativeProps }: ActionBarSeparatorProps): string | number | bigint | boolean | Iterable<import("react").ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+//# sourceMappingURL=action-bar-parts.d.ts.map

package/dist/types/action-bar/action-bar-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-bar-parts.d.ts","sourceRoot":"","sources":["../../../src/action-bar/action-bar-parts.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,oBAAoB,EACpB,qBAAqB,EAErB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,oBAAoB,+VAQ9F;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,qBAAqB,+VA2BhG;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,EAC9B,QAAQ,EACR,WAAW,EACX,QAAQ,EACR,GAAG,EACH,MAAM,EACN,GAAG,WAAW,EACf,EAAE,oBAAoB,+VA8BtB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,uBAAuB,+VAS1F"}

package/dist/types/action-bar/action-bar.d.ts

@@ -0,0 +1,31 @@
+
+import type { ActionBarProps } from './action-bar.types';
+/**
+ * The actions that finish a task on a page or in a panel.
+ *
+ * **It is not a composite.** `Tab` reaches every action, in the order the author
+ * wrote them, and the arrows are not bound. The controls here are the page's own
+ * form actions, and a reader walking a form expects to arrive at Cancel and then
+ * at Save; roving focus would make the whole bar one tab stop and put Save
+ * behind an arrow key that announces nothing. A strip of ten icon buttons is a
+ * `toolbar`, and that family binds the arrows against the APG. The cost of the
+ * departure is written in the contract.
+ *
+ * **What gives way is decided by rank, not by position.** `toolbar` refuses a
+ * priority in its own contract and is right to: in a bar of tools the first
+ * control is the most used, so giving way from the end gives up the least used
+ * one. Here the action that confirms is at the **end** of the line, so giving
+ * way from the end would give up Save first.
+ *
+ * **The action that confirms does not move.** The run carries an `auto` margin
+ * against the bar's end edge, so a message appearing in the status, a button
+ * going busy and a permission filter removing a control all move what is
+ * *before* the last action and never the last action itself.
+ *
+ * **The bar paints itself and the one control it draws.** Every control keeps
+ * its own fill, its own states and its own step; a bar out of action is
+ * `<fieldset disabled>` around it, which is the platform disabling controls this
+ * family does not own.
+ */
+export declare function ActionBar({ align, children, className, onOverflowChange, present, ref, render, size, sticky, style, variant, ...nativeProps }: ActionBarProps): import("react").JSX.Element | null;
+//# sourceMappingURL=action-bar.d.ts.map

package/dist/types/action-bar/action-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-bar.d.ts","sourceRoot":"","sources":["../../../src/action-bar/action-bar.tsx"],"names":[],"mappings":"AAAA,OAAO,2CAA2C,CAAC;AAmBnD,OAAO,KAAK,EAAqB,cAAc,EAAsB,MAAM,oBAAoB,CAAC;AA2EhG;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS,CAAC,EACxB,KAAK,EACL,QAAQ,EACR,SAAS,EACT,gBAAgB,EAChB,OAAO,EACP,GAAG,EACH,MAAM,EACN,IAAI,EACJ,MAAM,EACN,KAAK,EACL,OAAO,EACP,GAAG,WAAW,EACf,EAAE,cAAc,sCAyLhB"}

package/dist/types/action-bar/action-bar.types.d.ts

@@ -0,0 +1,146 @@
+import type { MenuAlign, MenuHandle, MenuSide, MenuSize } from '../menu';
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode, Ref } from 'react';
+/** Whether the bar paints a ground and a rule of its own. */
+export type ActionBarVariant = 'plain' | 'raised';
+/** The step the bar's own inset, gap and separator sit at. */
+export type ActionBarSize = 'sm' | 'md' | 'lg';
+/** Where the run of actions sits in the room left after the status. */
+export type ActionBarAlign = 'end' | 'start' | 'center';
+/**
+ * Where an action stands in the order of giving way.
+ *
+ * The five are adapted from `sap.m.OverflowToolbarPriority`, and they exist here
+ * and not in `toolbar` because the two bars read in opposite directions. In a
+ * bar of tools the first control is the most used, so giving way from the end
+ * gives up the least used one. In a bar of actions the action that confirms is
+ * at the **end** of the line — Polaris, Salesforce and SAP's own page footer all
+ * put it there — so giving way from the end gives up Save first.
+ *
+ * - `pinned` never gives way. It is what the action that confirms takes.
+ * - `high` gives way after `low` and `hide`, into the surface.
+ * - `low` is the first rank to reach the surface, and the default for an action
+ *   that declares a counterpart.
+ * - `hide` gives way before every other rank and is **not** offered in the
+ *   surface: a draft marker, a timestamp, a preview link — a control that is not
+ *   worth a row in a menu. SAP calls it `Disappear` and no other surveyed
+ *   implementation ships it.
+ * - `always` is never drawn in the bar; its counterpart is in the surface from
+ *   the start.
+ */
+export type ActionBarPriority = 'pinned' | 'high' | 'low' | 'hide' | 'always';
+/**
+ * The accessible name of the control that holds what did not fit. A string is
+ * used verbatim; a function is given the number of actions behind the control,
+ * because three dots say nothing about how much is behind them.
+ */
+export type ActionBarOverflowLabel = string | ((hidden: number) => string);
+/** What an application sets once for every bar under it. */
+export interface ActionBarDefaults {
+    align: ActionBarAlign;
+    size: ActionBarSize;
+    sticky: boolean;
+    variant: ActionBarVariant;
+}
+export interface ActionBarDefaultsProviderProps extends Partial<ActionBarDefaults> {
+    children?: ReactNode | undefined;
+}
+/** What `render` receives for the bar. */
+export interface ActionBarRootProps extends HTMLAttributes<HTMLElement> {
+    'data-align': ActionBarAlign;
+    'data-collapsed'?: string | undefined;
+    'data-part': string;
+    'data-size': ActionBarSize;
+    'data-status'?: string | undefined;
+    'data-sticky'?: '' | undefined;
+    'data-ui': string;
+    'data-variant': ActionBarVariant;
+    role?: string | undefined;
+}
+export interface ActionBarProps extends ComponentPropsWithRef<'div'> {
+    /** Defaults to the provider, then to `end`. */
+    align?: ActionBarAlign | undefined;
+    /**
+     * Reports how many actions gave way, once per change. The collapsed set is a
+     * measurement rather than a value, so there is no controlled pair over it: a
+     * consumer who owned it could assert that a bar fits when the layout says it
+     * does not.
+     */
+    onOverflowChange?: ((hidden: number) => void) | undefined;
+    /**
+     * Whether the bar belongs on screen at all. A bulk bar exists while there is a
+     * selection and a contextual save bar while there are unsaved changes; both
+     * enter from below and leave the same way, and the bar leaves the DOM once it
+     * has left the view. Defaults to `true`.
+     *
+     * It is an input rather than a state model: the bar never asks to appear or to
+     * leave, so there is nothing to cancel.
+     */
+    present?: boolean | undefined;
+    /** Renders the bar into another element. */
+    render?: ((props: ActionBarRootProps) => ReactNode) | undefined;
+    /** Defaults to the provider, then to `md`. Sizes the bar and the buttons in it. */
+    size?: ActionBarSize | undefined;
+    /**
+     * Whether the bar sticks to the end of the region that scrolls. It stops above
+     * whatever `page` publishes as its own chrome rather than covering it.
+     * Defaults to the provider, then to `false`.
+     */
+    sticky?: boolean | undefined;
+    /** Defaults to the provider, then to `plain`. */
+    variant?: ActionBarVariant | undefined;
+}
+export interface ActionBarStatusProps extends ComponentPropsWithRef<'div'> {
+    /** Renders the status region into another element. */
+    render?: ((props: HTMLAttributes<HTMLElement>) => ReactNode) | undefined;
+}
+export interface ActionBarActionsProps extends ComponentPropsWithRef<'div'> {
+    /** Renders the run into another element. */
+    render?: ((props: HTMLAttributes<HTMLElement>) => ReactNode) | undefined;
+}
+export interface ActionBarActionProps extends ComponentPropsWithRef<'div'> {
+    /**
+     * What the action becomes in the surface when the bar has no room for it.
+     *
+     * It is deliberately not called `overflow`: that word names what a container
+     * does with more content than it has room for, and one term with two meanings
+     * is the ambiguity the contract exists to prevent.
+     */
+    counterpart?: ReactNode | undefined;
+    /**
+     * Where this action stands in the order of giving way. Defaults to `low` when
+     * a counterpart is declared and to `pinned` when none is — a unit with nowhere
+     * to go cannot give way, which is how the action that confirms stays visible.
+     */
+    priority?: ActionBarPriority | undefined;
+    /** Renders the unit into another element. */
+    render?: ((props: HTMLAttributes<HTMLElement>) => ReactNode) | undefined;
+}
+export interface ActionBarSeparatorProps extends ComponentPropsWithRef<'div'> {
+    /** Renders the rule into another element. */
+    render?: ((props: HTMLAttributes<HTMLElement>) => ReactNode) | undefined;
+}
+export interface ActionBarOverflowProps extends Omit<ComponentPropsWithRef<'button'>, 'children' | 'ref'> {
+    /** Where the surface sits against the trigger. */
+    align?: MenuAlign | undefined;
+    /**
+     * The accessible name. Defaults to a count — "3 more actions" — because the
+     * mark says nothing about how much is behind it. A bar in another language
+     * replaces the sentence rather than translating three dots.
+     */
+    label?: ActionBarOverflowLabel | undefined;
+    /** Reaches the surface's imperative actions: `open`, `close`, `focus`. */
+    menuRef?: Ref<MenuHandle> | undefined;
+    ref?: Ref<HTMLElement> | undefined;
+    /** Renders the trigger as the consumer's own control. */
+    render?: ((props: ActionBarOverflowRootProps) => ReactNode) | undefined;
+    side?: MenuSide | undefined;
+    /** The surface's own measure, which is `menu`'s axis rather than the bar's. */
+    size?: MenuSize | undefined;
+}
+/** What `render` receives for the control that opens what did not fit. */
+export type ActionBarOverflowRootProps = Omit<ComponentPropsWithRef<'button'>, 'ref'> & {
+    children: ReactNode;
+    'data-part': string;
+    ref?: Ref<HTMLElement> | undefined;
+};
+//# sourceMappingURL=action-bar.types.d.ts.map

package/dist/types/action-bar/action-bar.types.d.ts.map

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

package/dist/types/action-bar/index.d.ts

@@ -0,0 +1,8 @@
+export { ActionBar } from './action-bar';
+export { useActionBarOverflow } from './action-bar-context';
+export type { ActionBarOverflowValue, ActionBarSurfaceUnit } from './action-bar-context';
+export { ActionBarDefaultsProvider, useActionBarDefaults } from './action-bar-defaults';
+export { ActionBarOverflow } from './action-bar-overflow';
+export { ActionBarAction, ActionBarActions, ActionBarSeparator, ActionBarStatus, } from './action-bar-parts';
+export type { ActionBarActionProps, ActionBarActionsProps, ActionBarAlign, ActionBarDefaults, ActionBarDefaultsProviderProps, ActionBarOverflowLabel, ActionBarOverflowProps, ActionBarOverflowRootProps, ActionBarPriority, ActionBarProps, ActionBarRootProps, ActionBarSeparatorProps, ActionBarSize, ActionBarStatusProps, ActionBarVariant, } from './action-bar.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/action-bar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/action-bar/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC5D,YAAY,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACzF,OAAO,EAAE,yBAAyB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AACxF,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,cAAc,EACd,iBAAiB,EACjB,8BAA8B,EAC9B,sBAAsB,EACtB,sBAAsB,EACtB,0BAA0B,EAC1B,iBAAiB,EACjB,cAAc,EACd,kBAAkB,EAClB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC"}