@nxgt/material 2.1.0 → 2.2.0

package/dist/lib/components/ui/fields/password-field/password-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { PasswordFieldProps } from './password-field';
+export declare function PasswordFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<PasswordFieldProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/percent-field/index.d.ts

@@ -0,0 +1,3 @@
+export type { PercentFieldProps } from './percent-field';
+export { PercentField } from './percent-field';
+export * from './percent-form-field';

package/dist/lib/components/ui/fields/percent-field/percent-field.d.ts

@@ -0,0 +1,3 @@
+import { NumberFieldProps } from '../number-field/number-field';
+export type PercentFieldProps = Omit<NumberFieldProps, 'suffix'>;
+export declare function PercentField({ min, max, step, ...props }: PercentFieldProps): import("react").JSX.Element;

package/dist/lib/components/ui/fields/percent-field/percent-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { PercentFieldProps } from './percent-field';
+export declare function PercentFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<PercentFieldProps, 'name' | 'value' | 'onChange'>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/phone-field/index.d.ts

@@ -0,0 +1,7 @@
+export type { PhoneCountry } from './countries';
+export { findCountry, flagEmoji, PHONE_COUNTRIES } from './countries';
+export type { ParsedPhone } from './parse-phone';
+export { exampleNational, formatInternational, formatNational, isPossiblePhoneNumber, isValidPhoneNumber, parsePhoneInput, toE164, } from './parse-phone';
+export type { PhoneFieldProps } from './phone-field';
+export { PhoneField } from './phone-field';
+export * from './phone-form-field';

package/dist/lib/components/ui/fields/phone-field/phone-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { PhoneFieldProps } from './phone-field';
+export declare function PhoneFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<PhoneFieldProps, 'name' | 'value' | 'onChange'>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/rating-field/index.d.ts

@@ -0,0 +1,4 @@
+export { clampRating } from './clamp-rating';
+export type { RatingFieldProps } from './rating-field';
+export { RatingField } from './rating-field';
+export * from './rating-form-field';

package/dist/lib/components/ui/fields/rating-field/rating-field.d.ts

@@ -0,0 +1,23 @@
+import { VariantProps } from 'class-variance-authority';
+import { ReactNode } from 'react';
+declare const ratingColor: (props?: ({
+    color?: "error" | "success" | "default" | "info" | "warning" | "primary" | "secondary" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type RatingFieldProps = {
+    label?: ReactNode;
+    helperText?: ReactNode;
+    error?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+    name?: string;
+    id?: string;
+    max?: number;
+    value?: number;
+    defaultValue?: number;
+    allowClear?: boolean;
+    onChange?: (value: number) => void;
+} & VariantProps<typeof ratingColor>;
+export declare function RatingField({ label, helperText, error, required, disabled, readOnly, className, name, id, max, value, defaultValue, allowClear, color, onChange, }: RatingFieldProps): import("react").JSX.Element;
+export {};

package/dist/lib/components/ui/fields/rating-field/rating-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { RatingFieldProps } from './rating-field';
+export declare function RatingFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<RatingFieldProps, 'name' | 'value' | 'onChange'>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/search-field/index.d.ts

@@ -0,0 +1,5 @@
+export type { Debounced } from './debounce';
+export { debounce } from './debounce';
+export type { SearchFieldProps } from './search-field';
+export { SearchField } from './search-field';
+export * from './search-form-field';

package/dist/lib/components/ui/fields/search-field/search-field.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { InputProps } from '../../primitives/input/input';
+export type SearchFieldProps = Omit<InputProps, 'type'> & {
+    label?: ReactNode;
+    helperText?: ReactNode;
+    error?: boolean;
+    loading?: boolean;
+    debounceMs?: number;
+    onValueChange?: (value: string) => void;
+};
+export declare function SearchField({ id, value: valueProp, defaultValue, onChange, onValueChange, debounceMs, loading, placeholder, label, helperText, error, disabled, required, name, className, onKeyDown, ...props }: SearchFieldProps): import("react").JSX.Element;

package/dist/lib/components/ui/fields/search-field/search-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { SearchFieldProps } from './search-field';
+export declare function SearchFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<SearchFieldProps, 'name' | 'value' | 'onValueChange'>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/slider/index.d.ts

@@ -0,0 +1,2 @@
+export * from './slider';
+export * from './slider-form-field';

package/dist/lib/components/ui/fields/slider/slider-control.d.ts

@@ -0,0 +1,12 @@
+import { Slider as SliderPrimitive } from 'radix-ui';
+import { ComponentProps, ReactNode } from 'react';
+export type SliderControlProps = ComponentProps<typeof SliderPrimitive.Root> & {
+    ticks?: boolean | number;
+    /** Sets `aria-required` on every thumb. */
+    required?: boolean;
+    /** The id of the field's label: it names every thumb. */
+    labelId?: string;
+    /** Names every thumb when no `Label` is shown (a vertical `Slider`'s `label`). */
+    hiddenLabel?: ReactNode;
+};
+export declare function SliderControl({ className, defaultValue, value, min, max, step, ticks, required, labelId, 'aria-label': ariaLabel, 'aria-labelledby': ariaLabelledBy, 'aria-invalid': ariaInvalid, hiddenLabel, ...props }: SliderControlProps): import("react").JSX.Element;

package/dist/lib/components/ui/fields/slider/slider-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { SliderProps } from './slider';
+export declare function SliderFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<SliderProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/slider/slider-thumb-names.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+/**
+ * What names every thumb of a slider. A thumb is the `slider`; the root is a
+ * plain `span`, where a name is neither allowed nor read. So every thumb is
+ * labelled by: your `aria-labelledby`, else your `aria-label` (or a vertical
+ * slider's `hiddenLabel`), held in a hidden element `nameTextId`, else the
+ * field's Label. `nameText` is `undefined` when nothing points at it.
+ */
+export declare function sliderThumbNames({ thumbId, labelId, ariaLabel, ariaLabelledBy, hiddenLabel, }: {
+    thumbId: string;
+    labelId?: string;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    hiddenLabel?: ReactNode;
+}): {
+    nameIds: string | undefined;
+    nameText: ReactNode;
+    nameTextId: string | undefined;
+};

package/dist/lib/components/ui/fields/slider/slider.d.ts

@@ -0,0 +1,13 @@
+import { ComponentProps, ReactNode } from 'react';
+import { SliderControl } from './slider-control';
+export type SliderProps = {
+    label?: ReactNode;
+    helperText?: ReactNode;
+    error?: boolean;
+    required?: boolean;
+    leading?: ReactNode;
+    trailing?: ReactNode;
+    ticks?: boolean | number;
+    showReadout?: boolean;
+} & Omit<ComponentProps<typeof SliderControl>, 'hiddenLabel' | 'labelId'>;
+export declare function Slider({ leading, trailing, label, helperText, error, required, ticks, showReadout, value, defaultValue, onValueChange, min, max, step, orientation, disabled, className, ref, ...props }: SliderProps): import("react").JSX.Element;

package/dist/lib/components/ui/fields/switch/index.d.ts

@@ -0,0 +1,2 @@
+export * from './switch';
+export * from './switch-form-field';

package/dist/lib/components/ui/fields/switch/partials/switch-control.d.ts

@@ -0,0 +1,4 @@
+import { Switch as SwitchPrimitive } from 'radix-ui';
+import { ComponentProps } from 'react';
+/** The bare Radix switch with its track and thumb. */
+export declare function SwitchControl({ className, ...props }: ComponentProps<typeof SwitchPrimitive.Root>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/switch/partials/switch-row.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode, Ref } from 'react';
+export type SwitchRowProps = {
+    /** The switch's id: the row text is its `<label for>`. */
+    id: string;
+    rowTextId?: string;
+    text: ReactNode;
+    isChecked: boolean;
+    error?: boolean;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+    /** The switch itself. */
+    children: ReactNode;
+};
+/** The bordered row: its text, tinted while checked, then the switch. */
+export declare function SwitchRow({ id, rowTextId, text, isChecked, error, className, ref, children, }: SwitchRowProps): import("react").JSX.Element;

package/dist/lib/components/ui/fields/switch/switch-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { SwitchProps } from './switch';
+export declare function SwitchFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<SwitchProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/switch/switch.utils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * With both a `label` and a `placeholder`, the label above the row names the
+ * switch and the row text describes it. The row text stays a `<label for>` so
+ * clicking it toggles, and `aria-labelledby` (which outranks `<label for>`)
+ * keeps it out of the name. The helper text (a validation message from a form
+ * wrapper, too) describes it as well. A name the caller gives wins; a
+ * description it gives is kept beside these.
+ */
+export declare function switchNameProps({ id, label, placeholder, helperText, props, }: {
+    id: string;
+    label?: unknown;
+    placeholder?: unknown;
+    helperText?: unknown;
+    props: {
+        'aria-label'?: string;
+        'aria-labelledby'?: string;
+        'aria-describedby'?: string;
+    };
+}): {
+    labelId: string;
+    rowTextId?: string;
+    helperId?: string;
+    nameProps: {
+        'aria-labelledby'?: string;
+        'aria-describedby'?: string;
+    };
+};

package/dist/lib/components/ui/fields/switch/use-switch-checked.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The switch's real state, for tinting the row: `checked` when controlled,
+ * else `defaultChecked` and what the switch reports as it toggles. The row
+ * used to read `value`, the submitted form value, which says nothing about it.
+ */
+export declare function useSwitchChecked(props: {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}): {
+    isChecked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+};

package/dist/lib/components/ui/fields/switch/use-switch-state.d.ts

@@ -0,0 +1,32 @@
+import { ReactNode, Ref } from 'react';
+/** What `Switch` renders around the control, and the ids that name it. */
+export declare function useSwitchState({ label, placeholder, helperText, props, }: {
+    label?: ReactNode;
+    placeholder?: ReactNode;
+    helperText?: ReactNode;
+    props: {
+        id?: string;
+        ref?: Ref<HTMLButtonElement>;
+        checked?: boolean;
+        defaultChecked?: boolean;
+        onCheckedChange?: (checked: boolean) => void;
+        'aria-label'?: string;
+        'aria-labelledby'?: string;
+        'aria-describedby'?: string;
+    };
+}): {
+    isChecked: boolean;
+    onCheckedChange: (checked: boolean) => void;
+    labelId: string;
+    rowTextId?: string;
+    helperId?: string;
+    nameProps: {
+        "aria-labelledby"?: string;
+        "aria-describedby"?: string;
+    };
+    blurRoot: import('react').RefCallback<Element> | undefined;
+    bareRoot: Ref<HTMLButtonElement> | undefined;
+    hasRow: boolean;
+    hasField: boolean;
+    id: string;
+};

package/dist/lib/components/ui/fields/text-field/index.d.ts

@@ -0,0 +1,2 @@
+export * from './text-field';
+export * from './text-form-field';

package/dist/lib/components/ui/fields/text-field/text-field.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { InputProps } from '../../primitives/input/input';
+export type TextFieldProps = {
+    label?: ReactNode;
+    helperText?: ReactNode;
+    leading?: ReactNode;
+    trailing?: ReactNode;
+    error?: boolean;
+} & InputProps;
+export declare function TextField({ error, helperText, label, className, leading, trailing, ...props }: TextFieldProps): import("react").JSX.Element;

package/dist/lib/components/ui/fields/text-field/text-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { TextFieldProps } from './text-field';
+export declare function TextFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<TextFieldProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/textarea-field/index.d.ts

@@ -0,0 +1,2 @@
+export * from './textarea-field';
+export * from './textarea-form-field';

package/dist/lib/components/ui/fields/textarea-field/textarea-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { TextareaProps } from './textarea-field';
+export declare function TextareaFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<TextareaProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/timezone-field/index.d.ts

@@ -0,0 +1,5 @@
+export type { TimezoneFieldProps } from './timezone-field';
+export { TimezoneField } from './timezone-field';
+export * from './timezone-form-field';
+export type { TimezoneId } from './timezones';
+export { TIMEZONES, timezoneLabel } from './timezones';

package/dist/lib/components/ui/fields/timezone-field/timezone-field.d.ts

@@ -0,0 +1,5 @@
+import { ComboboxFieldProps } from '../../selection/combobox-field/combobox-field';
+export type TimezoneFieldProps = Omit<ComboboxFieldProps, 'options'> & {
+    timezones?: readonly string[];
+};
+export declare function TimezoneField({ timezones, placeholder, ...props }: TimezoneFieldProps): import("react").JSX.Element;

package/dist/lib/components/ui/fields/timezone-field/timezone-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { TimezoneFieldProps } from './timezone-field';
+export declare function TimezoneFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<TimezoneFieldProps, 'name' | 'value' | 'onChange'>): import("react").JSX.Element;

package/dist/lib/components/ui/fields/url-field/index.d.ts

@@ -0,0 +1,4 @@
+export { isUrl, normalizeUrl } from './parse-url';
+export type { UrlFieldProps } from './url-field';
+export { UrlField } from './url-field';
+export * from './url-form-field';

package/dist/lib/components/ui/fields/url-field/url-field.d.ts

@@ -0,0 +1,3 @@
+import { TextFieldProps } from '../text-field/text-field';
+export type UrlFieldProps = Omit<TextFieldProps, 'type' | 'leading' | 'trailing'>;
+export declare function UrlField({ value, defaultValue, onChange, onBlur, error, helperText, autoComplete, disabled, ...props }: UrlFieldProps): import("react").JSX.Element;

package/dist/lib/components/ui/fields/url-field/url-form-field.d.ts

@@ -0,0 +1,3 @@
+import { UseControllerProps } from 'react-hook-form';
+import { UrlFieldProps } from './url-field';
+export declare function UrlFormField<T extends Record<string, any>>({ control, name, ...props }: Pick<UseControllerProps<T>, 'control' | 'name'> & Omit<UrlFieldProps, 'name'>): import("react").JSX.Element;

package/dist/lib/components/ui/forms/array-error-message.d.ts

@@ -0,0 +1,7 @@
+import { FieldErrors } from 'react-hook-form';
+/**
+ * The message of an array field's own error. An array-level rule
+ * (`z.array().min()`) lands on `errors.<name>.message`, a `useFieldArray`
+ * rule on `errors.<name>.root.message`: this returns whichever is set.
+ */
+export declare function arrayErrorMessage(errors: FieldErrors, name: string): string | undefined;

package/dist/lib/components/ui/forms/field-blur-context.d.ts

@@ -0,0 +1,19 @@
+import { Ref, RefCallback } from 'react';
+/**
+ * The ref callback of the `FieldBlur` around a component, if any. A component
+ * whose field is more than one control (a picker and its popover, a list and
+ * its buttons, a drop zone) puts it on its root element, so that leaving the
+ * whole field — not one of its controls — marks it touched.
+ */
+export declare const FieldBlurContext: import('react').Context<RefCallback<Element> | null>;
+/**
+ * The blur ref joined with an element's own `ref`, so that neither is lost:
+ * the own ref alone when there is no blur ref, and the other way round.
+ */
+export declare function useJoinedRef<T extends Element>(blur: RefCallback<Element> | null | undefined, own: Ref<T> | undefined): Ref<T> | undefined;
+/**
+ * The ref for a field's root element, joined with the root's own `ref` if it
+ * has one. Outside a `FieldBlur` it is that own ref, unchanged.
+ */
+export declare function useFieldBlurRoot(): RefCallback<Element> | undefined;
+export declare function useFieldBlurRoot<T extends Element>(own: Ref<T> | undefined): Ref<T> | undefined;

package/dist/lib/components/ui/forms/field-blur-layers.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The top-level layer a node is in: its ancestor that is a child of `<body>`.
+ * An overlay rendered into `<body>` (a popover, a listbox, a dialog) is a
+ * layer of its own; the page is another. `null` for a node no longer in the
+ * document.
+ */
+export declare function layerOf(node: Node): Node | null;
+/** What a field knows about the layers of the page since focus entered it. */
+export type FieldLayers = {
+    /** The layers of the page when focus entered the field. */
+    before: Set<Node>;
+    /** The layers the field itself is in (the page, or the sheet it is in). */
+    home: Set<Node | null>;
+    /** The layers focus reached since entering that are the field's overlays. */
+    opened: Set<Node>;
+};
+/**
+ * Who opened `layer`, going by the controls that name an element of it as
+ * the popup they control (`aria-controls`, `aria-owns`), as a select, a
+ * popover or a dialog trigger does:
+ * - `'ours'`: a control of the field (inside `roots`), or a control inside
+ *   an overlay of the field — one focus already reached, or one mounted since
+ *   focus entered that nothing else opened (the field's dialog, which leaves
+ *   focus on the button that opened it, and the select inside it). Such a
+ *   layer is the field's even when it was mounted before focus entered the
+ *   field: a mouse-opened select mounts its list before its trigger has focus.
+ * - `'theirs'`: only a control of something else — another field whose
+ *   overlay opened while focus was still here (a mouse-opened select, a
+ *   Safari button that takes no focus on click).
+ * - `null`: nothing names it.
+ * A control inside `layer` itself (a tab naming its panel) says nothing about
+ * who opened it.
+ */
+export declare function openerOf(roots: Element[], layers: FieldLayers, layer: Node, seen?: Set<Node>): 'ours' | 'theirs' | null;

package/dist/lib/components/ui/forms/field-blur.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+/**
+ * Calls `onBlur` (React Hook Form's `field.onBlur`) when focus leaves the
+ * field rendered inside it and whatever overlay that field opened. The field
+ * marks its root with `useFieldBlurRoot()`. Renders no element of its own, so
+ * the form's layout is untouched. Not exported: the wrappers use it.
+ */
+export declare function FieldBlur({ onBlur, children, }: {
+    onBlur: () => void;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/lib/components/ui/forms/form-field.d.ts

@@ -1,5 +1,5 @@
 import { UseControllerProps } from 'react-hook-form';
-import { FieldConfig } from '../field/types';
+import { FieldConfig } from '../fields/field/types';
 export type FormFieldProps<T extends Record<string, any>> = {
     config: FieldConfig;
 } & Pick<UseControllerProps<T>, 'control' | 'name'>;

package/dist/lib/components/ui/forms/form-field.wiring.d.ts

@@ -0,0 +1,11 @@
+import { ControllerRenderProps, FieldValues } from 'react-hook-form';
+import { FieldType } from '../fields/field/types';
+type Field = ControllerRenderProps<FieldValues, string>;
+type Wire = (field: Field) => Record<string, unknown>;
+/**
+ * How each config `type` reads and writes the form value. Blur is not here:
+ * `FormField` wraps every type in `FieldBlur`. `upload` and
+ * `network-upload` are not here: `FormField` hands them to their own wrappers.
+ */
+export declare const FIELD_WIRING: Partial<Record<FieldType, Wire>>;
+export {};

package/dist/lib/components/ui/forms/index.d.ts

@@ -1,45 +1 @@
-export * from './autocomplete-form-field';
-export * from './check-card-form-field';
-export * from './checkbox-form-field';
-export * from './checkbox-group-form-field';
-export * from './code-editor-form-field';
-export * from './color-form-field';
-export * from './combobox-form-field';
-export * from './country-form-field';
-export * from './currency-form-field';
-export * from './date-form-field';
-export * from './date-range-form-field';
-export * from './duration-form-field';
-export * from './email-form-field';
-export * from './file-list-form-field';
-export * from './file-list-s3-form-field';
-export * from './files-form-field';
 export * from './form-field';
-export * from './image-form-field';
-export * from './image-s3-form-field';
-export * from './inline-edit-form-field';
-export * from './input-group-form-field';
-export * from './network-upload-form-field';
-export * from './number-form-field';
-export * from './otp-form-field';
-export * from './password-form-field';
-export * from './percent-form-field';
-export * from './phone-form-field';
-export * from './radio-group-form-field';
-export * from './rating-form-field';
-export * from './rich-text-editor-form-field';
-export * from './s3-upload-form-field';
-export * from './search-form-field';
-export * from './select-card-form-field';
-export * from './select-chip-form-field';
-export * from './select-form-field';
-export * from './slider-form-field';
-export * from './sortable-list-form-field';
-export * from './switch-form-field';
-export * from './text-form-field';
-export * from './textarea-form-field';
-export * from './time-form-field';
-export * from './timezone-form-field';
-export * from './transfer-list-form-field';
-export * from './upload-form-field';
-export * from './url-form-field';

package/dist/lib/components/ui/forms/select-choice.utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The form value of `SelectChipFormField` / `SelectCardFormField` as the
+ * `string[]` their field renders from.
+ *
+ * In `mode="single"` the form holds `string | null` (`''` or `null` when
+ * nothing is chosen); in `mode="multiple"` it holds `string[]`. The field
+ * always wants an array, and matches options against it by equality.
+ */
+export declare function toSelectChoiceArray(value: unknown): string[];

package/dist/lib/components/ui/forms/use-field-blur.d.ts

@@ -0,0 +1,27 @@
+import { RefCallback } from 'react';
+/**
+ * Calls React Hook Form's `field.onBlur` when focus LEAVES a form field, the
+ * way a native `blur` does for a single `<input>` — so `touchedFields` flips,
+ * and `mode: 'onBlur'` / `'onTouched'` validate. It never validates by itself:
+ * when that happens is the form's `mode`.
+ *
+ * "Leaving" covers every field shape with one rule (the same as
+ * `@nxgt/material-vue`'s `useFieldBlur`):
+ * - focus moving between the field's own controls (the stars of a rating, the
+ *   buttons of an upload) is not leaving;
+ * - focus moving into an overlay the field opened — a popover, a listbox, a
+ *   dialog, portalled to `<body>` — is not leaving either. "Opened" means a
+ *   child of `<body>` that a control of the field names as its popup
+ *   (`aria-controls`), or one mounted after focus entered the field that no
+ *   other control names. It is left when focus then reaches the field's own
+ *   layer (the page, or the sheet the form is in), a layer that was already
+ *   there (a side panel, a banner), nothing (a click on a blank area), or an
+ *   overlay another control opened — the next field's `Select`, opened by the
+ *   mouse while focus was still here, leaves this one as it opens, not when
+ *   it hands focus back.
+ *
+ * Returns a ref callback for the field's root element(s): every element it is
+ * given counts as the field. `FieldBlur` hands it to the component through
+ * context (`useFieldBlurRoot`). Browser-only: nothing runs on the server.
+ */
+export declare function useFieldBlur(onBlur: () => void): RefCallback<Element>;

package/dist/lib/components/ui/layout/app-shell/app-breadcrumb.d.ts

@@ -0,0 +1,24 @@
+import { ComponentProps } from 'react';
+import { LinkProps } from 'react-router';
+import { Breadcrumb, BreadcrumbItem, BreadcrumbSeparator } from '../breadcrumb/breadcrumb';
+export type AppBreadcrumbItemProps = {
+    last: boolean;
+} & LinkProps & ComponentProps<typeof BreadcrumbItem>;
+/**
+ * The last crumb is the current page, so it is text rather than a link.
+ * The link sits inside the `<li>`: an `<ol>` may only hold `<li>`s. Router
+ * and anchor-only props (`replace`, `state`, `target`, …) go to the link;
+ * the rest (`className`, `data-*`, …) to the `<li>`.
+ */
+export declare function AppBreadcrumbItem({ to, children, last, ...props }: AppBreadcrumbItemProps): import("react").JSX.Element;
+export type AppBreadcrumbSeparatorProps = Omit<ComponentProps<typeof BreadcrumbSeparator>, 'children'>;
+export declare function AppBreadcrumbSeparator({ className, ...props }: AppBreadcrumbSeparatorProps): import("react").JSX.Element;
+export type AppBreadcrumbProps = ComponentProps<typeof Breadcrumb>;
+/**
+ * Breadcrumbs built from the matched routes' `handle.breadcrumb`.
+ *
+ * A route opts in by exporting `handle = { breadcrumb: (match) => ... }`;
+ * routes without one contribute nothing, so intermediate layouts stay out of
+ * the trail. Hidden on mobile, where there is no room for it.
+ */
+export declare function AppBreadcrumb({ className, ...props }: AppBreadcrumbProps): import("react").JSX.Element;

package/dist/lib/components/ui/layout/app-shell/app-breadcrumb.utils.d.ts

@@ -0,0 +1,14 @@
+import { LinkProps } from 'react-router';
+/**
+ * The `LinkProps` an `<li>` has no use for: React Router's own options and
+ * the attributes only an `<a>` understands. `AppBreadcrumbItem` takes both
+ * link and item props in one object, so these go to the link and the rest,
+ * `className`, `data-*` and event handlers included, to the item.
+ */
+declare const LINK_ONLY_KEYS: readonly ["defaultShouldRevalidate", "discover", "download", "hrefLang", "mask", "media", "ping", "prefetch", "preventScrollReset", "referrerPolicy", "rel", "relative", "reloadDocument", "replace", "state", "target", "type", "viewTransition"];
+type LinkOnlyKey = (typeof LINK_ONLY_KEYS)[number];
+export declare function splitLinkProps<P extends Partial<Pick<LinkProps, LinkOnlyKey>>>(props: P): {
+    link: Pick<P, LinkOnlyKey & keyof P>;
+    item: Omit<P, LinkOnlyKey>;
+};
+export {};

package/dist/lib/components/ui/layout/app-shell/app-sidebar.d.ts

@@ -0,0 +1,17 @@
+import { SidebarProps } from '../sidebar/sidebar';
+import { MenuItem } from './types';
+export type AppSidebarProps = {
+    items: MenuItem[];
+    /** Replaces the header block entirely — a logo, a product name, both. */
+    brand?: React.ReactNode;
+} & SidebarProps;
+/**
+ * The application sidebar: a navigation entry per {@link MenuItem}, with the
+ * ones marked `footer` pinned to the bottom.
+ *
+ * Exactly one entry reads as active — the most specific one covering the
+ * current path, resolved across the whole menu rather than per entry. See
+ * {@link findActiveMenuItem} for why that cannot be decided one entry at a
+ * time once a menu is mounted anywhere but `/`.
+ */
+export declare function AppSidebar({ items, brand, className, withToggleIcon, expanded, onExpandedChange, ...props }: AppSidebarProps): import("react").JSX.Element;

package/dist/lib/components/ui/layout/app-shell/types.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { IconName } from '../../primitives/icon/icon';
+/**
+ * One entry in the application sidebar.
+ *
+ * `label` is a `ReactNode`, already translated, rather than a translation key:
+ * menu labels belong to the consuming app's namespace, and this package can
+ * only resolve its own reserved `material.*` one. The app's `useMenuItems()`
+ * translates, and this component renders.
+ */
+export type MenuItem = {
+    label: ReactNode;
+    url: string;
+    icon: IconName;
+    /**
+     * Pins the entry to the sidebar footer — where "settings" and the like
+     * belong.
+     *
+     * Explicit on purpose. The apps this was extracted from footered whichever
+     * entry happened to be *last*, so appending one silently moved the previous
+     * one out of the footer.
+     */
+    footer?: boolean;
+};

package/dist/lib/components/ui/layout/background/index.d.ts

@@ -0,0 +1 @@
+export * from './background';

package/dist/lib/components/ui/layout/breadcrumb/index.d.ts

@@ -0,0 +1 @@
+export * from './breadcrumb';