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

package/dist/types/segmented-control/segmented-control.types.d.ts

@@ -0,0 +1,116 @@
+import type { ChangeRequest } from '@slotted/core/state';
+import type { ComponentPropsWithRef, HTMLAttributes, ReactNode } from 'react';
+/** The type step the control and every segment inside it sit at. */
+export type SegmentedControlSize = 'sm' | 'md' | 'lg';
+/** How the segments flow. The thumb travels along the same axis. */
+export type SegmentedControlOrientation = 'horizontal' | 'vertical';
+/**
+ * What the control does when it is narrower than its labels need. `icons`
+ * keeps the marks and hides the words — hidden, never removed, so the
+ * accessible name of every segment is the same at every width.
+ */
+export type SegmentedControlCondense = 'none' | 'icons';
+/** Why the value moved. A segmented control can produce exactly these two. */
+export type SegmentedControlSelectionReason = Extract<ChangeRequest<string>['reason'], 'pointer' | 'keyboard'>;
+/**
+ * The request the control emits. Its `previous` is `undefined` while nothing
+ * has been chosen, which is the state a radio group is allowed to start in and
+ * which a request typed over `string` alone could not say.
+ */
+export type SegmentedControlChangeRequest = ChangeRequest<string | undefined>;
+/** What an application sets once for every segmented control under it. */
+export interface SegmentedControlDefaults {
+    condense: SegmentedControlCondense;
+    fullWidth: boolean;
+    orientation: SegmentedControlOrientation;
+    size: SegmentedControlSize;
+}
+export interface SegmentedControlDefaultsProviderProps extends Partial<SegmentedControlDefaults> {
+    children?: ReactNode | undefined;
+}
+/** What the control hands every segment inside it. */
+export interface SegmentedControlContextValue {
+    disabled: boolean | undefined;
+    invalid: boolean | undefined;
+    /**
+     * The submission name every segment shares, and the reason the platform
+     * treats the set as one radio group. It is generated when none is written.
+     */
+    name: string;
+    readOnly: boolean | undefined;
+    required: boolean | undefined;
+    select: (value: string, reason: SegmentedControlSelectionReason, source: unknown) => boolean;
+    size: SegmentedControlSize;
+    value: string | undefined;
+}
+/** What `render` receives for the control's root. */
+export interface SegmentedControlRootProps extends HTMLAttributes<HTMLElement> {
+    'data-condense': SegmentedControlCondense;
+    'data-disabled'?: '' | undefined;
+    'data-full-width'?: '' | undefined;
+    'data-invalid'?: '' | undefined;
+    'data-orientation': SegmentedControlOrientation;
+    'data-part': string;
+    'data-readonly'?: '' | undefined;
+    'data-size': SegmentedControlSize;
+    'data-ui': string;
+}
+/** What `render` receives for one segment. */
+export interface SegmentRootProps extends HTMLAttributes<HTMLElement> {
+    'data-checked'?: '' | undefined;
+    'data-disabled'?: '' | undefined;
+    'data-part': string;
+}
+export interface SegmentedControlProps extends Omit<ComponentPropsWithRef<'div'>, 'defaultValue'> {
+    /** Defaults to the provider, then to `none`. */
+    condense?: SegmentedControlCondense | undefined;
+    /** The value an uncontrolled control starts from, read once. */
+    defaultValue?: string | undefined;
+    /**
+     * Unstated rather than `false`, so the control defers to the field around
+     * it. Stated, it wins, and it reaches every segment's radio as the native
+     * attribute.
+     */
+    disabled?: boolean | undefined;
+    /** Defaults to the provider, then to `false`. */
+    fullWidth?: boolean | undefined;
+    /** Unstated rather than `false`. Writes `aria-invalid` and `data-invalid`. */
+    invalid?: boolean | undefined;
+    /**
+     * The submission name the set shares. Generated when it is not written,
+     * because grouping is by name within the form owner and an unnamed set is
+     * not a set — the price is that an unnamed control inside a form submits
+     * under a generated key.
+     */
+    name?: string | undefined;
+    /** Called before the value moves, with the request that carries the reason. */
+    onValueChange?: ((value: string, request: SegmentedControlChangeRequest) => void) | undefined;
+    /** Defaults to the provider, then to `horizontal`. */
+    orientation?: SegmentedControlOrientation | undefined;
+    /**
+     * Unstated rather than `false`. Every segment keeps its tab stop and its
+     * contrast, the control announces `aria-readonly`, and every change is
+     * refused — a radio ignores `readonly`, so the family enforces it.
+     */
+    readOnly?: boolean | undefined;
+    /** Renders the control's root into another element. */
+    render?: ((props: SegmentedControlRootProps) => ReactNode) | undefined;
+    /** Unstated rather than `false`. Writes `aria-required` on the control. */
+    required?: boolean | undefined;
+    /** Defaults to the field, then to the provider, then to `md`. */
+    size?: SegmentedControlSize | undefined;
+    /** Present means controlled, for the life of the component. */
+    value?: string | undefined;
+}
+export interface SegmentProps extends Omit<ComponentPropsWithRef<'input'>, 'children' | 'size' | 'type' | 'value'> {
+    children?: ReactNode | undefined;
+    /** Unstated rather than `false`, so the segment defers to the control. */
+    disabled?: boolean | undefined;
+    /** The mark, drawn before the words. Absent on a segment that is only words. */
+    icon?: ReactNode | undefined;
+    /** Renders the segment's own box into another element. The radio is fixed. */
+    render?: ((props: SegmentRootProps) => ReactNode) | undefined;
+    /** What this segment selects. It is what the control's value holds. */
+    value: string;
+}
+//# sourceMappingURL=segmented-control.types.d.ts.map

package/dist/types/segmented-control/segmented-control.types.d.ts.map

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

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

@@ -0,0 +1,7 @@
+export { Select, useSelect } from './select';
+export type { SelectContextValue, SelectEntry } from './select';
+export { SELECT_FALLBACK, SelectDefaultsProvider, useSelectDefaults } from './select-defaults';
+export { SelectContent, SelectSearch, SelectTrigger, SelectValue } from './select-parts';
+export { SelectGroup, SelectItem, SelectSeparator } from './select-items';
+export type { SelectAlign, SelectContentProps, SelectDefaults, SelectDefaultsProviderProps, SelectFilter, SelectGroupProps, SelectHandle, SelectHighlightReason, SelectItemProps, SelectItems, SelectMount, SelectOpenReason, SelectOption, SelectOptionGroup, SelectOptionValue, SelectPositionerProps, SelectProps, SelectSearchProps, SelectSearchReason, SelectSearchRootProps, SelectSelection, SelectSide, SelectSize, SelectStrategy, SelectTriggerProps, SelectTriggerRootProps, SelectValueProps, SelectValueReason, SelectVariant, SelectWidth, } from './select.types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/select/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC7C,YAAY,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC/F,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACzF,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAC1E,YAAY,EACV,WAAW,EACX,kBAAkB,EAClB,cAAc,EACd,2BAA2B,EAC3B,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,qBAAqB,EACrB,eAAe,EACf,WAAW,EACX,WAAW,EACX,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EACf,UAAU,EACV,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EACjB,aAAa,EACb,WAAW,GACZ,MAAM,gBAAgB,CAAC"}

package/dist/types/select/select-collection.d.ts

@@ -0,0 +1,59 @@
+import type { MoveIntent } from '@slotted/core/collection';
+import type { SelectOptionValue } from './select.types';
+/**
+ * The collection, read from the DOM of the open popup.
+ *
+ * The options are the consumer's own JSX, so the list the reader sees is the
+ * only place their order, their labels and their disabled set all exist at
+ * once. `menu` reads its items the same way, and the alternative — every option
+ * registering itself into a context on mount — re-renders the whole popup once
+ * per option on the first open and gets the order wrong the moment a consumer
+ * renders one conditionally.
+ *
+ * Nothing here decides anything. `moveIndex` in `packages/core/src/collection`
+ * does the arithmetic; this module only says what the arithmetic is about.
+ */
+export declare const OPTION_SELECTOR = "[data-part='item']";
+export declare function options(content: HTMLElement | null): HTMLElement[];
+export declare const valueOf: (option: HTMLElement) => SelectOptionValue;
+export declare const isEnabled: (option: HTMLElement) => boolean;
+/** What typeahead matches on: what the option says instead, or what it reads as. */
+export declare const labelOf: (option: HTMLElement) => string;
+/**
+ * The options typeahead searches: the enabled ones, and only those.
+ *
+ * Arrow movement already steps over a disabled option, so a typeahead that
+ * landed on one would let a reader reach by typing what they cannot reach by
+ * arrowing — and then refuse to commit it. Radix and React Aria both skip them
+ * here for the same reason. `menu` does not, because its pattern requires a
+ * disabled command to stay reachable; the listbox pattern says nothing, and
+ * consistency inside this family is what settles it.
+ */
+export declare function searchable(content: HTMLElement | null): {
+    elements: HTMLElement[];
+    labels: string[];
+};
+/**
+ * The value the highlight moves to, or `null` when nothing is reachable — an
+ * empty list, a list still loading, and a list whose every option is disabled
+ * all answer the same way, and the caller's response to all three is the same:
+ * write no `aria-activedescendant`.
+ */
+export declare function moveHighlight(content: HTMLElement | null, from: SelectOptionValue | null, intent: MoveIntent, loop: boolean): SelectOptionValue | null;
+/** Where the highlight lands when the popup opens, given what is selected. */
+export declare function entryHighlight(content: HTMLElement | null, selection: readonly SelectOptionValue[], entry: 'selected' | 'first' | 'last' | 'none', loop: boolean): SelectOptionValue | null;
+/**
+ * Brings the highlighted option into view without moving the page: the nearest
+ * scrolling box between the option and the popup is scrolled, by the least
+ * distance that shows the whole row, and nothing past it. `scrollIntoView`
+ * would scroll every ancestor too, and on the first open it runs before the
+ * popup is positioned — a select far down a page sent the page to its top.
+ *
+ * A browser scrolls a *focused* element into view on its own; nothing here is
+ * focused, which is the price of the `aria-activedescendant` model and the
+ * reason this exists.
+ */
+export declare function revealOption(content: HTMLElement | null, value: SelectOptionValue | null): void;
+/** Scrolls the nearest scrolling box between `option` and `surface` to show the row. */
+export declare function revealWithin(option: HTMLElement, surface: HTMLElement): void;
+//# sourceMappingURL=select-collection.d.ts.map

package/dist/types/select/select-collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-collection.d.ts","sourceRoot":"","sources":["../../../src/select/select-collection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,eAAe,uBAAuB,CAAC;AAEpD,wBAAgB,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,WAAW,EAAE,CAElE;AAED,eAAO,MAAM,OAAO,GAAI,QAAQ,WAAW,KAAG,iBAAkD,CAAC;AAEjG,eAAO,MAAM,SAAS,GAAI,QAAQ,WAAW,YAA6C,CAAC;AAE3F,oFAAoF;AACpF,eAAO,MAAM,OAAO,GAAI,QAAQ,WAAW,KAAG,MAI1C,CAAC;AAEL;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;;;EAGrD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,WAAW,GAAG,IAAI,EAC3B,IAAI,EAAE,iBAAiB,GAAG,IAAI,EAC9B,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,OAAO,GACZ,iBAAiB,GAAG,IAAI,CAW1B;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAC5B,OAAO,EAAE,WAAW,GAAG,IAAI,EAC3B,SAAS,EAAE,SAAS,iBAAiB,EAAE,EACvC,KAAK,EAAE,UAAU,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,EAC7C,IAAI,EAAE,OAAO,GACZ,iBAAiB,GAAG,IAAI,CAS1B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,EAAE,KAAK,EAAE,iBAAiB,GAAG,IAAI,QAIxF;AAED,wFAAwF;AACxF,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,QAkBrE"}

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

@@ -0,0 +1,41 @@
+import type { SelectDefaults, SelectDefaultsProviderProps } from './select.types';
+/**
+ * The numbers, and why they are these numbers.
+ *
+ * `side` and `align` hang the popup from the start edge of its own control, so
+ * the value in the control and the labels in the list share one edge.
+ * `sideOffset` is four where `menu`'s is zero: a menu's gap is its layer's own
+ * padding, needed so a pointer travelling into a submenu never crosses page,
+ * and this family has no submenu and no grace area to protect. Four is enough
+ * for the popup's shadow to read as a separate surface and small enough that
+ * the two still belong to each other.
+ *
+ * `loop` is `false` where `menu`'s is `true`. A menu is a short list of
+ * commands and a wrap is a convenience; a list of a hundred options that jumps
+ * from the last to the first loses the reader's place, and the APG's own
+ * select-only example does not wrap.
+ *
+ * `clearable` is `false` where `combobox`'s is `true`. A select always holds one
+ * of its own options once a reader has chosen; a combobox holds whatever was
+ * typed, and taking it back is the commonest thing a reader does to one.
+ *
+ * `width` is `content`: the popup is never narrower than its control and grows
+ * when an option needs it, so a narrow control does not wrap its option labels.
+ *
+ * `search` is `false`. It is the one capability here that changes the popup's
+ * role, moves DOM focus into the layer and takes three keys back from the key
+ * table, and a select of six options is worse for having a field above them.
+ * `highlightMatch` is `true` beside it: a reader who asked for a search asked
+ * to be shown what matched, and `combobox` marks by default for the same
+ * reason.
+ */
+export declare const SELECT_FALLBACK: SelectDefaults;
+/** The defaults in force here. A select reads it; a consumer rarely needs to. */
+export declare function useSelectDefaults(): SelectDefaults;
+/**
+ * The decisions an application takes once, in its bootstrap, rather than on
+ * every select it renders. A select that states one of them itself still wins,
+ * which is what lets a dense table's filter differ from a form's field.
+ */
+export declare function SelectDefaultsProvider({ children, container, ...overrides }: SelectDefaultsProviderProps): import("react").JSX.Element;
+//# sourceMappingURL=select-defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"select-defaults.d.ts","sourceRoot":"","sources":["../../../src/select/select-defaults.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,2BAA2B,EAAE,MAAM,gBAAgB,CAAC;AAElF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,eAAe,EAAE,cA+B7B,CAAC;AAIF,iFAAiF;AACjF,wBAAgB,iBAAiB,IAAI,cAAc,CAElD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,QAAQ,EACR,SAAS,EACT,GAAG,SAAS,EACb,EAAE,2BAA2B,+BA2C7B"}

package/dist/types/select/select-items.d.ts

@@ -0,0 +1,46 @@
+import type { Ref } from 'react';
+import type { SelectGroupProps, SelectItemProps } from './select.types';
+/**
+ * One option.
+ *
+ * A `div` with `role="option"` rather than a `button`, which is where this
+ * family parts company with `menu`. The listbox pattern's option is not a
+ * button: it is not separately focusable — DOM focus stays on the control for
+ * the whole interaction — and a `button` here would put a widget inside a
+ * widget and add a tab stop the pattern excludes by name.
+ *
+ * **The highlight is set by the pointer as well as by the keyboard.** Entering
+ * an option with the pointer moves `aria-activedescendant` to it, so exactly one
+ * option is highlighted whichever device is driving, and the state a screen
+ * reader announces is the state the eye sees. `data-highlighted` in Radix and
+ * Ark exists to paper over the case where those two disagree; there is no such
+ * case here.
+ *
+ * **Under `search`, each option decides whether it belongs in the results.**
+ * The family holds the query and the comparison; the option holds its own
+ * label, which is the only place the two meet without the consumer handing the
+ * whole collection over twice. An option that does not match renders nothing,
+ * so the popup's DOM *is* the result set — which is what makes the count, the
+ * keyboard and the empty row read one answer. `combobox` filters itself the
+ * same way, in the same place.
+ */
+export declare function SelectItem({ children, description, disabled, icon, position, ref, textValue, value, ...nativeProps }: SelectItemProps): import("react").JSX.Element | null;
+/**
+ * A set of options under a heading.
+ *
+ * The group names itself by `aria-labelledby` pointing at its own label, which
+ * the listbox pattern requires of every option group. The label is a prop
+ * rather than a child part, because a group with no accessible name is a
+ * pattern violation the type system can refuse.
+ */
+export declare function SelectGroup({ children, label, ...nativeProps }: SelectGroupProps): import("react").JSX.Element;
+/**
+ * A line between two sets of options. `role="separator"` inside a listbox is a
+ * structural element and takes no orientation: the line is horizontal because
+ * the list is vertical, and saying so twice is how two families came to
+ * disagree about which axis the word names.
+ */
+export declare function SelectSeparator(props: {
+    ref?: Ref<HTMLDivElement>;
+}): import("react").JSX.Element;
+//# sourceMappingURL=select-items.d.ts.map

package/dist/types/select/select-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-items.d.ts","sourceRoot":"","sources":["../../../src/select/select-items.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAuC,GAAG,EAAE,MAAM,OAAO,CAAC;AAKtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,WAAW,EACX,QAAgB,EAChB,IAAI,EACJ,QAAQ,EACR,GAAG,EACH,SAAS,EACT,KAAK,EACL,GAAG,WAAW,EACf,EAAE,eAAe,sCAuHjB;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,WAAW,EAAE,EAAE,gBAAgB,+BA2ChF;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE;IAAE,GAAG,CAAC,EAAE,GAAG,CAAC,cAAc,CAAC,CAAA;CAAE,+BAEnE"}

package/dist/types/select/select-parts.d.ts

@@ -0,0 +1,54 @@
+import type { SelectContentProps, SelectOptionValue, SelectSearchProps, SelectTriggerProps, SelectValueProps } from './select.types';
+/**
+ * The frame, the button, the chevron and the clear button.
+ *
+ * Four elements from one component, as `text-field` renders its frame, its
+ * input and its two buttons: the frame draws the border and the focus ring, and
+ * the ring can only be drawn by an ancestor of the thing that took focus. The
+ * chevron and the clear button are siblings of the button rather than children
+ * of it, because a focusable descendant of a `combobox` is a widget inside a
+ * widget, and the stylesheet places both against the frame's inline end.
+ *
+ * `render` replaces the **frame**, which is the element a consumer has a reason
+ * to change — a `label` wrapping the whole control, for instance. The button
+ * itself carries the role, the wiring and every key in the pattern, and
+ * replacing it would replace all three.
+ */
+export declare function SelectTrigger({ children, ref, render, ...nativeProps }: SelectTriggerProps): 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;
+/**
+ * What the control shows: the chosen label, the summary of several, or the
+ * placeholder.
+ *
+ * `children` is a function rather than a node, because the only thing a
+ * consumer needs to change here is how a *value* becomes words — "three
+ * selected", a chip count, a formatted date. It receives the values and the
+ * labels the family could resolve, so a consumer who has the records already
+ * does not have to resolve them twice.
+ */
+export declare function SelectValue({ children, placeholder, ...nativeProps }: SelectValueProps): import("react").JSX.Element;
+/**
+ * The field the reader filters the options with, at the top of the popup.
+ *
+ * It is `role="combobox"` over the `list` below it, and it holds DOM focus for
+ * the whole time the popup is open — which is what the combobox pattern
+ * requires of a dialog popup: "dialogs do not support `aria-activedescendant`
+ * so DOM focus moves into the dialog from the combobox". The trigger becomes
+ * the outer combobox, over the dialog; this is the inner one, over the listbox.
+ *
+ * It is rendered by `SelectContent` rather than placed by the consumer, because
+ * the two elements it sits between — the dialog and the listbox — are wiring
+ * the family owns. `searchProps` on `SelectContent` reaches every native
+ * attribute of it, its glyph and its `render`.
+ */
+export declare function SelectSearch({ icon, ref, render, ...nativeProps }: SelectSearchProps): 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 layer and the surface it paints.
+ *
+ * The layer is what the positioner writes `left` and `top` onto and what scales
+ * and fades; the surface is the painted panel, and it is the element carrying
+ * `role="listbox"`. Two boxes rather than one, as `tooltip`, `popover` and
+ * `menu` are built, because the positioner leaves `transform` alone on purpose.
+ */
+export declare function SelectContent({ children, empty, ref, render, searchProps, status: statusMessage, ...nativeProps }: SelectContentProps): 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;
+export type { SelectOptionValue };
+//# sourceMappingURL=select-parts.d.ts.map

package/dist/types/select/select-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-parts.d.ts","sourceRoot":"","sources":["../../../src/select/select-parts.tsx"],"names":[],"mappings":"AAwBA,OAAO,KAAK,EACV,kBAAkB,EAClB,iBAAiB,EAEjB,iBAAiB,EAEjB,kBAAkB,EAElB,gBAAgB,EACjB,MAAM,gBAAgB,CAAC;AAoDxB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,kBAAkB,+VAgV1F;AAqED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,EAAE,gBAAgB,+BAiCtF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAAW,EAAE,EAAE,iBAAiB,+VAuHpF;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,KAAK,EACL,GAAG,EACH,MAAM,EACN,WAAW,EACX,MAAM,EAAE,aAAa,EACrB,GAAG,WAAW,EACf,EAAE,kBAAkB,+VAmYpB;AAED,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/types/select/select-tags.d.ts

@@ -0,0 +1,47 @@
+
+import type { MouseEvent } from 'react';
+import type { SelectOptionValue } from './select.types';
+/**
+ * The preview of a multiple selection: the chosen values as the chips they
+ * are, and one more chip counting what did not fit (SL4).
+ *
+ * Three decisions live here and nowhere else:
+ *
+ * **The chips are `tag`s.** They wear `data-ui='tag'` beside the row this
+ * family owns, so the chip a reader removes here is the chip they know from
+ * everywhere else, and the geometry — the pill, the small step, the remove
+ * control floored at the target minimum — is stated once, in `tag.css`.
+ *
+ * **What does not fit is measured, not guessed.** `createCollapse` is the same
+ * ResizeObserver arithmetic `toolbar` collapses a bar with: it hides the units
+ * that overrun and reveals the trigger from the first one that does. The
+ * trigger is the `+N` chip, so the count is whatever the collapse reports and
+ * cannot disagree with what is on screen.
+ *
+ * **Under 120px there is no chip.** A chip narrower than a word is a shape,
+ * so the control says "3 selected" instead. The width is watched by
+ * `createWidthGate`, which is a width and a callback rather than a container
+ * query: `container-type: inline-size` would stop the frame's own width
+ * depending on its contents, which is exactly how a select that is not
+ * `fullWidth` is measured.
+ */
+export interface ChipRowProps {
+    /** The chosen values, in the order the reader chose them. */
+    values: readonly SelectOptionValue[];
+    /** The label for a value, when the collection could resolve one. */
+    labelFor: (value: SelectOptionValue) => string | undefined;
+    /** The accessible name of a chip's remove control, given the value's own label. */
+    removeLabel: (label: string) => string;
+    /** Takes a value out of the selection. */
+    onRemove: (value: SelectOptionValue, event: MouseEvent<HTMLButtonElement>) => void;
+    /** The frame whose width decides whether a chip is the right answer at all. */
+    frame: HTMLElement | null;
+    /** Told whether the frame is under the width. */
+    onNarrow: (narrow: boolean) => void;
+    /** Whether the row answers the pointer at all. */
+    disabled?: boolean;
+}
+/** The width, in CSS pixels, under which a chip has no room for a word. */
+export declare const NARROW_WIDTH = 120;
+export declare function ChipRow({ disabled, frame, labelFor, onNarrow, onRemove, removeLabel, values, }: ChipRowProps): import("react").JSX.Element;
+//# sourceMappingURL=select-tags.d.ts.map

package/dist/types/select/select-tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-tags.d.ts","sourceRoot":"","sources":["../../../src/select/select-tags.tsx"],"names":[],"mappings":"AAGA,OAAO,6BAA6B,CAAC;AAErC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAGxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,YAAY;IAC3B,6DAA6D;IAC7D,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACrC,oEAAoE;IACpE,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,MAAM,GAAG,SAAS,CAAC;IAC3D,mFAAmF;IACnF,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACvC,0CAA0C;IAC1C,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,EAAE,KAAK,EAAE,UAAU,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAC;IACnF,+EAA+E;IAC/E,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;IAC1B,iDAAiD;IACjD,QAAQ,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IACpC,kDAAkD;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,2EAA2E;AAC3E,eAAO,MAAM,YAAY,MAAM,CAAC;AAEhC,wBAAgB,OAAO,CAAC,EACtB,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,MAAM,GACP,EAAE,YAAY,+BAqFd"}

package/dist/types/select/select.d.ts

@@ -0,0 +1,101 @@
+
+import { type FamilyTranslator, type SelectMessages } from '@slotted/core/i18n';
+import type { MutableRefObject } from 'react';
+import type { SelectAlign, SelectHighlightReason, SelectMount, SelectOpenReason, SelectOptionValue, SelectProps, SelectSearchReason, SelectSide, SelectSize, SelectStrategy, SelectValueReason, SelectVariant, SelectWidth } from './select.types';
+/** Where the highlight goes when the popup opens, decided by the key that opened it. */
+export type SelectEntry = 'selected' | 'first' | 'last' | 'none';
+export interface SelectContextValue {
+    align: SelectAlign;
+    alignOffset: number;
+    clear: (reason: SelectValueReason, source?: unknown) => void;
+    clearable: boolean;
+    closeOnEscape: boolean;
+    closeOnOutsidePress: boolean;
+    closeOnSelect: boolean;
+    collisionPadding: number;
+    contentId: string;
+    contentNode: HTMLElement | null;
+    disabled: boolean;
+    entry: MutableRefObject<SelectEntry>;
+    flip: boolean;
+    form: string | undefined;
+    fullWidth: boolean;
+    hideWhenDetached: boolean;
+    highlighted: SelectOptionValue | null;
+    highlightMatch: boolean;
+    invalid: boolean;
+    labelFor: (value: SelectOptionValue) => string | undefined;
+    listId: string;
+    loading: boolean;
+    /** The locale the default filter compares in: the `locale` prop, or the language in force. */
+    locale: string;
+    loop: boolean;
+    /** Whether an option's label answers the query. Always true while it is empty. */
+    matches: (label: string) => boolean;
+    mount: SelectMount;
+    multiple: boolean;
+    name: string | undefined;
+    open: boolean;
+    optionId: (value: SelectOptionValue) => string;
+    portal: boolean;
+    /** What the reader has typed into the search field. Empty when there is none. */
+    query: string;
+    readOnly: boolean;
+    registerLabel: (value: SelectOptionValue, label: string) => void;
+    required: boolean;
+    /** Returns the selection to `defaultValue`, which is what a native form reset does. */
+    restore: (source?: unknown) => void;
+    search: boolean;
+    searchId: string;
+    searchNode: HTMLInputElement | null;
+    seen: boolean;
+    selection: readonly SelectOptionValue[];
+    setContentNode: (node: HTMLElement | null) => void;
+    setHighlighted: (value: SelectOptionValue | null, reason: SelectHighlightReason, source?: unknown) => void;
+    setOpen: (next: boolean, reason: SelectOpenReason, source?: unknown) => void;
+    setQuery: (next: string, reason: SelectSearchReason, source?: unknown) => void;
+    setSearchNode: (node: HTMLInputElement | null) => void;
+    setTriggerNode: (node: HTMLElement | null) => void;
+    shift: boolean;
+    side: SelectSide;
+    sideOffset: number;
+    size: SelectSize;
+    strategy: SelectStrategy;
+    /** The family's words in the language in force, with this select's `messages` laid over them. */
+    t: FamilyTranslator<SelectMessages>;
+    toggle: (value: SelectOptionValue, reason: SelectValueReason, source?: unknown) => void;
+    total: number | undefined;
+    triggerId: string;
+    triggerNode: HTMLElement | null;
+    typeahead: boolean;
+    typeaheadTimeout: number;
+    variant: SelectVariant;
+    width: SelectWidth;
+}
+/**
+ * What the select around this part says. A trigger, a popup or an option
+ * outside one has no state to report, so this throws rather than rendering
+ * markup that looks right and never opens.
+ */
+export declare function useSelect(): SelectContextValue;
+/**
+ * A control that shows the current choice and opens a listbox of the rest.
+ *
+ * This component owns the state and **renders nothing**: the control stays
+ * where the consumer wrote it and the popup is portalled to the end of the
+ * document, so no single element could hold both. `SelectTrigger` renders the
+ * frame and the button; `SelectContent` renders the layer and the list.
+ *
+ * **Three values a consumer can own, and each one asks before it moves.** What
+ * is selected, whether the popup is open, and which option the highlight is on.
+ * The third is `aria-activedescendant` rather than focus: DOM focus stays on
+ * the trigger for the whole interaction, which is what the APG's own
+ * select-only combobox example does and what `combobox` — this family's pair —
+ * has no choice about.
+ *
+ * **Unset means ask the field.** `disabled`, `readOnly`, `invalid`, `required`
+ * and `size` default to `undefined` rather than to a value, which is what makes
+ * "not disabled" and "said nothing" different answers.
+ */
+export declare function Select({ align, alignOffset, children, clearable, closeOnEscape, closeOnOutsidePress, closeOnSelect, collisionPadding, defaultHighlightedValue, defaultOpen, defaultSearchValue, defaultValue, disabled, filter, flip, form, fullWidth, hideWhenDetached, highlightedValue, highlightMatch, invalid, items, loading, locale: localeProp, loop, messages, mount, multiple, name, onHighlightedValueChange, onOpenChange, onSearchValueChange, onValueChange, open, portal, readOnly, ref, required, search, searchValue, shift, side, sideOffset, size, strategy, total, typeahead, typeaheadTimeout, value, variant, width, }: SelectProps): import("react").JSX.Element;
+//# sourceMappingURL=select.d.ts.map

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

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