@datum-cloud/datum-ui 1.3.2 → 1.5.0

package/dist/components/features/form/types/inputs.d.ts

@@ -0,0 +1,157 @@
+import type { ButtonProps } from '../../..';
+import type { NormalizedFieldMeta, NormalizedFormInstance } from '../adapter-types';
+import type { FormActions, FormStateFields } from './core';
+export interface FormInputProps extends Omit<React.ComponentProps<'input'>, 'name'> {
+    /** Input type */
+    type?: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url' | 'search' | 'date' | 'time' | 'datetime-local';
+}
+export interface FormTextareaProps extends Omit<React.ComponentProps<'textarea'>, 'name'> {
+    /** Number of visible rows */
+    rows?: number;
+}
+export interface FormSelectProps {
+    /** Placeholder text when no value selected */
+    placeholder?: string;
+    /** Disable the select */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Select options as children */
+    children: React.ReactNode;
+}
+export interface FormSelectItemProps {
+    /** Option value */
+    value: string;
+    /** Option label */
+    children: React.ReactNode;
+    /** Disable this option */
+    disabled?: boolean;
+}
+export interface FormCheckboxProps {
+    /** Inline label next to checkbox */
+    label?: string;
+    /** Disable the checkbox */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface FormSwitchProps {
+    /** Inline label next to switch */
+    label?: string;
+    /** Disable the switch */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface FormRadioGroupProps {
+    /** Layout orientation */
+    orientation?: 'horizontal' | 'vertical';
+    /** Disable all radio items */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Radio items as children */
+    children: React.ReactNode;
+}
+export interface FormRadioItemProps {
+    /** Radio value */
+    value: string;
+    /** Radio label */
+    label: string;
+    /** Optional description */
+    description?: string;
+    /** Disable this radio item */
+    disabled?: boolean;
+}
+export interface FormCopyBoxProps {
+    /** Display variant: 'default' shows Copy button, 'icon-only' shows icon */
+    variant?: 'default' | 'icon-only';
+    /** Custom className for the wrapper */
+    className?: string;
+    /** Custom className for the content area */
+    contentClassName?: string;
+    /** Custom className for the button */
+    buttonClassName?: string;
+    /** Placeholder text when value is empty */
+    placeholder?: string;
+}
+export interface FormSubmitProps extends ButtonProps {
+    /** Button content */
+    children: React.ReactNode;
+    /** Text to show while loading */
+    loadingText?: string;
+}
+export interface FormButtonProps {
+    /** Button content */
+    children: React.ReactNode;
+    /** Click handler */
+    onClick?: () => void;
+    /** Button variant */
+    type?: ButtonProps['type'];
+    /** Button theme */
+    theme?: ButtonProps['theme'];
+    /** Button size */
+    size?: ButtonProps['size'];
+    /** Disable the button */
+    disabled?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Whether to disable the button when form is submitting (default: true) */
+    disableOnSubmit?: boolean;
+}
+export interface FormErrorProps {
+    /** Error message or render function */
+    children?: React.ReactNode | ((errors: string[]) => React.ReactNode);
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface FormDescriptionProps {
+    /** Description content */
+    children: React.ReactNode;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface FormWhenProps {
+    /** Field name to watch */
+    field: string;
+    /** Render when field equals this value */
+    is?: unknown;
+    /** Render when field does not equal this value */
+    isNot?: unknown;
+    /** Render when field value is in array */
+    in?: unknown[];
+    /** Render when field value is not in array */
+    notIn?: unknown[];
+    /** Children to render conditionally */
+    children: React.ReactNode;
+}
+export interface FormFieldArrayProps {
+    /** Array field name */
+    name: string;
+    /** Render function with array helpers */
+    children: (props: FormFieldArrayRenderProps) => React.ReactNode;
+}
+export interface FormFieldArrayRenderProps {
+    /** Array of field items with id and key */
+    fields: Array<{
+        id: string;
+        key: string;
+        name: string;
+    }>;
+    /** Add a new item to the array */
+    append: (value?: Record<string, unknown>) => void;
+    /** Remove an item at index */
+    remove: (index: number) => void;
+    /** Move an item from one index to another */
+    move: (from: number, to: number) => void;
+}
+export interface FormCustomProps {
+    /** Render function with form context */
+    children: (context: FormCustomRenderProps) => React.ReactNode;
+}
+export interface FormCustomRenderProps extends FormStateFields, FormActions {
+    /** Normalized form instance */
+    form: NormalizedFormInstance;
+    /** All field metadata */
+    fields: Record<string, NormalizedFieldMeta>;
+}

package/dist/components/features/form/types/root.d.ts

@@ -0,0 +1,86 @@
+import type { z } from 'zod';
+import type { NormalizedFieldMeta, NormalizedFormInstance } from '../adapter-types';
+import type { FormActions, FormStateFields } from './core';
+import type { FormTelemetry } from './telemetry';
+/**
+ * Render props passed to Form.Root when using render function pattern
+ */
+export interface FormRootRenderProps extends FormStateFields, FormActions {
+    /** Normalized form instance */
+    form: NormalizedFormInstance;
+    /** All form fields with their normalized metadata */
+    fields: Record<string, NormalizedFieldMeta>;
+    /** Validation mode controlling when errors are displayed */
+    mode: 'onChange' | 'onBlur' | 'onSubmit';
+}
+export interface FormRootProps<T extends z.ZodType> {
+    /** Zod schema for validation */
+    schema: T;
+    /**
+     * Form children - can be either:
+     * - ReactNode: Standard form content
+     * - Render function: For accessing form state (form, fields, isSubmitting, etc.)
+     *
+     * @example Standard usage
+     * ```tsx
+     * <Form.Root schema={schema}>
+     *   <Form.Field name="email"><Form.Input /></Form.Field>
+     *   <Form.Submit>Save</Form.Submit>
+     * </Form.Root>
+     * ```
+     *
+     * @example Render function for form state access
+     * ```tsx
+     * <Form.Root schema={schema}>
+     *   {({ form, fields, isSubmitting }) => (
+     *     <>
+     *       <Form.Field name="email"><Form.Input /></Form.Field>
+     *       <Button disabled={isSubmitting} onClick={() => form.update({...})}>
+     *         Cancel
+     *       </Button>
+     *     </>
+     *   )}
+     * </Form.Root>
+     * ```
+     */
+    children: React.ReactNode | ((props: FormRootRenderProps) => React.ReactNode);
+    /** Client-side submit handler */
+    onSubmit?: (data: z.infer<T>) => void | Promise<void>;
+    /** React Router action path for server-side submission */
+    action?: string;
+    /** HTTP method for form submission */
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    /**
+     * Custom form component to render (defaults to native `<form>`).
+     * Use to integrate with framework-specific forms (e.g. React Router's `<Form>`).
+     */
+    formComponent?: React.ElementType;
+    /** Unique form ID */
+    id?: string;
+    /**
+     * Form name for analytics and error tracking.
+     * Used in telemetry callbacks to identify which form the user interacted with.
+     * @example "http-proxy-create", "dns-zone-edit", "project-settings"
+     */
+    name?: string;
+    /**
+     * Optional telemetry callbacks for form lifecycle tracking.
+     * When omitted, forms work silently without any tracking.
+     */
+    telemetry?: FormTelemetry;
+    /** Default values for form fields */
+    defaultValues?: Partial<z.infer<T>>;
+    /** When to validate: onBlur, onChange, or onSubmit */
+    mode?: 'onBlur' | 'onChange' | 'onSubmit';
+    /**
+     * External submitting state - use when submission is handled externally (e.g., with useFetcher)
+     * When provided, this overrides the internal isSubmitting state
+     */
+    isSubmitting?: boolean;
+    /** Called when validation fails */
+    onError?: (errors: z.ZodError<z.infer<T>>) => void;
+    /** Called after successful submission */
+    onSuccess?: (data: z.infer<T>) => void;
+    /** Additional CSS classes */
+    className?: string;
+}

package/dist/components/features/form/types/stepper.d.ts

@@ -0,0 +1,98 @@
+import type { z } from 'zod';
+export interface StepConfig {
+    /** Unique step identifier */
+    id: string;
+    /** Step label displayed in navigation */
+    label: string;
+    /** Optional step description */
+    description?: string;
+    /** Zod schema for this step's validation */
+    schema: z.ZodType;
+}
+/**
+ * Shared stepper navigation state. Both the render-prop surface
+ * ({@link FormStepperRenderProps}) and the context value
+ * ({@link StepperContextValue}) compose this base so the navigation shape is
+ * defined once.
+ */
+export interface StepperState {
+    /** All step configurations */
+    steps: StepConfig[];
+    /** Current step config */
+    current: StepConfig;
+    /** Current step index (0-based) */
+    currentIndex: number;
+    /** Go to next step (triggers validation) */
+    next: () => void;
+    /** Go to previous step (no validation) */
+    prev: () => void;
+    /** Go to specific step by ID (only backwards without validation) */
+    goTo: (stepId: string) => void;
+    /** Whether current step is first */
+    isFirst: boolean;
+    /** Whether current step is last */
+    isLast: boolean;
+}
+/**
+ * Render props context passed to Form.Stepper children function
+ */
+export interface FormStepperRenderProps extends StepperState {
+    /** Get data from a specific step by ID */
+    getStepData: (stepId: string) => Record<string, unknown> | undefined;
+    /** Get all data from all completed steps */
+    getAllStepData: () => Record<string, unknown>;
+}
+export interface FormStepperProps {
+    /** Step configurations */
+    steps: StepConfig[];
+    /** Form children - can be ReactNode or render function for accessing stepper context */
+    children: React.ReactNode | ((props: FormStepperRenderProps) => React.ReactNode);
+    /** Called when all steps are completed */
+    onComplete: (data: Record<string, unknown>) => void | Promise<void>;
+    /** Called when step changes */
+    onStepChange?: (stepId: string, direction: 'next' | 'prev') => void;
+    /** Initial step ID */
+    initialStep?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface FormStepProps {
+    /** Step ID - must match a step in steps array */
+    id: string;
+    /** Step content */
+    children: React.ReactNode;
+}
+export interface StepperNavigationProps {
+    /** Navigation variant */
+    variant?: 'horizontal' | 'vertical';
+    /** Label orientation */
+    labelOrientation?: 'horizontal' | 'vertical';
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface StepperControlsProps {
+    /** Previous button label */
+    prevLabel?: string | ((isFirst: boolean) => string);
+    /** Next button label */
+    nextLabel?: string | ((isLast: boolean) => string);
+    /** Loading text shown when submitting (only on last step) */
+    loadingText?: string;
+    /** Whether to show previous button */
+    showPrev?: boolean;
+    /** External loading state - overrides internal isSubmitting */
+    loading?: boolean;
+    /** Disable both buttons */
+    disabled?: boolean;
+    /** Callback when previous button is clicked (not on first step) */
+    onPrev?: () => void;
+    /** Callback when cancel is clicked (first step only) */
+    onCancel?: () => void;
+    /** Additional CSS classes */
+    className?: string;
+}
+export interface StepperContextValue extends StepperState {
+    /** Stepperize utils */
+    utils: {
+        getIndex: (id: string) => number;
+    };
+}

package/dist/components/features/form/types/telemetry.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Optional telemetry interface for form lifecycle tracking.
+ * When provided, callbacks fire on form events (submit, success, error, etc.).
+ * When omitted, forms work silently without any tracking.
+ *
+ * @example Wiring Sentry in the consuming app
+ * ```tsx
+ * const sentryTelemetry: FormTelemetry = {
+ *   onSubmit: ({ formName, formId }) => trackFormSubmit({ formName, formId }),
+ *   onSuccess: ({ formName, formId }) => trackFormSuccess({ formName, formId }),
+ *   onError: ({ formName, formId, error }) => trackFormError({ formName, formId, error }),
+ *   onValidationError: ({ formName, formId, fieldErrors }) => trackFormValidationError({ formName, formId, fieldErrors }),
+ *   captureError: (error, context) => Sentry.captureException(error, { extra: context }),
+ * };
+ *
+ * <Form.Root schema={schema} telemetry={sentryTelemetry} onSubmit={handleSubmit} />
+ * ```
+ */
+export interface FormTelemetry {
+    /** Called when a form submission is attempted */
+    onSubmit?: (info: {
+        formName: string;
+        formId?: string;
+    }) => void;
+    /** Called after a successful form submission */
+    onSuccess?: (info: {
+        formName: string;
+        formId?: string;
+    }) => void;
+    /** Called when a form submission throws an error */
+    onError?: (info: {
+        formName: string;
+        formId?: string;
+        error: Error;
+    }) => void;
+    /** Called when form validation fails */
+    onValidationError?: (info: {
+        formName: string;
+        formId?: string;
+        fieldErrors: Record<string, string[]>;
+    }) => void;
+    /** Called to capture an error with additional context (e.g. Sentry) */
+    captureError?: (error: Error, context: Record<string, unknown>) => void;
+}

package/dist/components/features/form/utils/get-field-constraints.d.ts

@@ -30,4 +30,3 @@ export declare function getFieldConstraints(schema: z.ZodType): Record<string, F
  * This API may change in future Zod versions.
  */
 export declare function getFieldConstraintsSingle(schema: z.ZodTypeAny): FieldConstraints;
-//# sourceMappingURL=get-field-constraints.d.ts.map

package/dist/components/features/form/utils/get-schema-defaults.d.ts

@@ -21,4 +21,3 @@ import type { z } from 'zod';
  * - `.default()` -> use the provided default value
  */
 export declare function getSchemaDefaults(schema: z.ZodType): Record<string, unknown>;
-//# sourceMappingURL=get-schema-defaults.d.ts.map

package/dist/components/features/form/utils/zod-helpers.d.ts

@@ -9,4 +9,3 @@ import type { z } from 'zod';
  * - `.and()` creates ZodIntersection (def.type = 'intersection', with def.left / def.right)
  */
 export declare function getObjectShape(schema: z.ZodType): Record<string, z.ZodType> | null;
-//# sourceMappingURL=zod-helpers.d.ts.map

package/dist/components/features/grid/components/col.d.ts

@@ -2,4 +2,3 @@ import type { ColProps } from '../types/grid.types';
 import * as React from 'react';
 declare const Col: React.FC<ColProps>;
 export default Col;
-//# sourceMappingURL=col.d.ts.map

package/dist/components/features/grid/components/index.d.ts

@@ -4,4 +4,3 @@ export { Col, Row };
 export type { ColProps, ColSize } from '../types/grid.types';
 export type { Gutter, RowProps } from '../types/grid.types';
 export { RowContext } from './row';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/features/grid/components/row.d.ts

@@ -3,4 +3,3 @@ import * as React from 'react';
 export declare const RowContext: React.Context<RowContextType | null>;
 declare const Row: React.FC<RowProps>;
 export default Row;
-//# sourceMappingURL=row.d.ts.map

package/dist/components/features/grid/constants/grid.constants.d.ts

@@ -19,4 +19,3 @@ export declare const RESPONSIVE_MAP: {
 };
 export type Breakpoint = keyof typeof GRID_BREAKPOINTS;
 export type ResponsiveArray = typeof RESPONSIVE_ARRAY;
-//# sourceMappingURL=grid.constants.d.ts.map

package/dist/components/features/grid/index.d.ts

@@ -4,4 +4,3 @@ export type { Breakpoint } from './constants/grid.constants';
 export type { ColProps, ColSize, Gutter, RowContextType, RowProps, RowState, } from './types/grid.types';
 export { getGutter, getResponsiveValue, registerMediaQuery } from './utils/responsive';
 export type { MediaQueryCallback } from './utils/responsive';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/features/grid/types/grid.types.d.ts

@@ -40,4 +40,3 @@ export interface RowContextType {
 export interface RowState {
     screens: Partial<Record<Breakpoint, boolean>>;
 }
-//# sourceMappingURL=grid.types.d.ts.map

package/dist/components/features/grid/utils/responsive.d.ts

@@ -5,6 +5,14 @@ export interface MediaQueryCallback {
     unmatch: () => void;
 }
 export declare function registerMediaQuery(query: string, callback: MediaQueryCallback): () => void;
+/**
+ * Whether a gutter needs viewport tracking (i.e. it contains a responsive
+ * breakpoint object). True for the object form (`{ md: 16 }`) AND for the array
+ * form (`[{ md: 16 }, 8]`). Row uses this to decide whether to register media
+ * queries; without it, array-form responsive gutters never track the viewport
+ * and `getGutter` resolves them against the all-true initial `screens`, i.e. the
+ * largest breakpoint (BUG-084).
+ */
+export declare function isResponsiveGutter(gutter: Gutter | [Gutter, Gutter]): boolean;
 export declare function getGutter(gutter: (Gutter | [Gutter, Gutter]) | undefined, screens: Partial<Record<Breakpoint, boolean>>): [number, number];
 export declare function getResponsiveValue<T>(value: T | Partial<Record<Breakpoint, T>>, screens: Partial<Record<Breakpoint, boolean>>): T | undefined;
-//# sourceMappingURL=responsive.d.ts.map

package/dist/components/features/grouped-table/components/grouped-skeleton.d.ts

@@ -4,4 +4,3 @@ export interface GroupedSkeletonProps {
     rowsPerGroup?: number;
 }
 export declare function GroupedSkeleton({ columns, groups, rowsPerGroup }: GroupedSkeletonProps): import("react").JSX.Element;
-//# sourceMappingURL=grouped-skeleton.d.ts.map

package/dist/components/features/grouped-table/components/grouped-toolbar.d.ts

@@ -6,4 +6,3 @@ export interface GroupedToolbarProps {
     className?: string;
 }
 export declare function GroupedToolbar({ search, onSearchChange, placeholder, debounceMs, className, }: GroupedToolbarProps): import("react").JSX.Element;
-//# sourceMappingURL=grouped-toolbar.d.ts.map

package/dist/components/features/grouped-table/grouped-table.d.ts

@@ -1,3 +1,2 @@
 import type { GroupedTableProps } from './types';
 export declare function GroupedTable<TData>(props: GroupedTableProps<TData>): import("react").JSX.Element;
-//# sourceMappingURL=grouped-table.d.ts.map

package/dist/components/features/grouped-table/index.d.ts

@@ -1,3 +1,2 @@
 export { GroupedTable } from './grouped-table';
 export type { DefaultExpanded, GroupedTableGroup, GroupedTableProps } from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/features/grouped-table/lib/bucket-rows.d.ts

@@ -11,4 +11,3 @@ interface GroupLike {
  */
 export declare function bucketRows<TData>(groups: GroupLike[], coreRows: Row<TData>[], filteredRows: Row<TData>[]): Map<string, Row<TData>[]>;
 export {};
-//# sourceMappingURL=bucket-rows.d.ts.map

package/dist/components/features/grouped-table/lib/compose-columns.d.ts

@@ -1,11 +1,10 @@
 import type { ColumnDef } from '@tanstack/react-table';
-import type { SelectionColumnOptions } from '../../data-table/types';
-import type { ActionItem } from '../../more-actions/types';
+import type { SelectionColumnOptions } from '../../data-table';
+import type { ActionItem } from '../../more-actions';
 export interface ComposeOptions<TData> {
-    enableRowSelection?: boolean | SelectionColumnOptions;
+    enableRowSelection?: boolean | SelectionColumnOptions<TData>;
     enableSorting?: boolean;
     rowActions?: (row: TData) => ActionItem<TData>[];
     rowActionsSheetTitle?: string;
 }
 export declare function composeColumns<TData>(columns: ColumnDef<TData, unknown>[], options: ComposeOptions<TData>): ColumnDef<TData, unknown>[];
-//# sourceMappingURL=compose-columns.d.ts.map

package/dist/components/features/grouped-table/lib/sort-rows.d.ts

@@ -4,4 +4,3 @@ import type { Row, SortingState } from '@tanstack/react-table';
  * Returns the same reference when there is no sort, so React can skip re-renders.
  */
 export declare function sortRows<TData>(rows: Row<TData>[], sorting: SortingState): Row<TData>[];
-//# sourceMappingURL=sort-rows.d.ts.map

package/dist/components/features/grouped-table/lib/use-controllable-state.d.ts

@@ -1,8 +1,9 @@
-export type Updater<T> = T | ((prev: T) => T);
 /**
- * Uncontrolled-by-default state with an optional controlled override.
- * When `controlled` is undefined the hook owns the value; otherwise the prop wins.
- * `onChange` always fires. Accepts TanStack-style updater functions.
+ * Re-export of the shared controllable-state hook.
+ *
+ * The implementation now lives in `base/hooks` so every value-bearing
+ * component can consume the same `(value?, defaultValue, onValueChange)`
+ * contract. This module is kept for backward compatibility.
  */
-export declare function useControllableState<T>(controlled: T | undefined, defaultValue: T, onChange?: (value: T) => void): readonly [T, (next: Updater<T>) => void];
-//# sourceMappingURL=use-controllable-state.d.ts.map
+export type { Updater } from '../../../base/hooks';
+export { useControllableState } from '../../../base/hooks';

package/dist/components/features/grouped-table/types.d.ts

@@ -1,7 +1,7 @@
 import type { Cell, ColumnDef, Row, RowSelectionState, SortingState } from '@tanstack/react-table';
 import type { ReactNode } from 'react';
-import type { SelectionColumnOptions } from '../data-table/types';
-import type { ActionItem } from '../more-actions/types';
+import type { SelectionColumnOptions } from '../data-table';
+import type { ActionItem } from '../more-actions';
 export type DefaultExpanded = 'all' | 'none' | string[];
 export interface GroupedTableGroup<TData> {
     /** Stable key used for expand state. */
@@ -30,7 +30,7 @@ export interface GroupedTableProps<TData> {
      */
     getRowId?: (row: TData, index: number) => string;
     /** Prepend a checkbox column; pass options to customize. */
-    enableRowSelection?: boolean | SelectionColumnOptions;
+    enableRowSelection?: boolean | SelectionColumnOptions<TData>;
     rowSelection?: RowSelectionState;
     onRowSelectionChange?: (selection: RowSelectionState) => void;
     /** Append a "⋯" actions column. Receives the row to allow conditional actions. */
@@ -71,4 +71,3 @@ export interface GroupedTableProps<TData> {
     /** Each data `<td>`; receives the cell for per-cell styling. */
     cellClassName?: string | ((cell: Cell<TData, unknown>) => string);
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/components/features/grouped-table/use-grouped-expansion.d.ts

@@ -7,4 +7,3 @@ export declare function useGroupedExpansion<TData>(groups: GroupedTableGroup<TDa
     isOpen: (id: string) => boolean;
     toggle: (id: string) => void;
 };
-//# sourceMappingURL=use-grouped-expansion.d.ts.map

package/dist/components/features/index.d.ts

@@ -5,15 +5,19 @@
  */
 export * from './app-navigation';
 export * from './autocomplete';
+export * from './autosearch';
 export * from './avatar-stack';
 export * from './calendar-date-picker';
 export * from './code-editor';
+export * from './data-table';
+export * from './date-time-picker';
 export * from './dropdown';
 export * from './dropzone';
 export * from './empty-content';
 export * from './file-input-button';
 export * from './form';
 export * from './grid';
+export * from './grouped-table';
 export * from './input-number';
 export * from './input-with-addons';
 export * from './loader-overlay';
@@ -26,6 +30,7 @@ export * from './rich-text-editor';
 export * from './stepper';
 export * from './tag-input';
 export * from './task-queue';
+export * from './time-picker';
 export * from './time-range-picker';
 export * from './toast';
-//# sourceMappingURL=index.d.ts.map
+export * from './transfer';

package/dist/components/features/input-number/index.d.ts

@@ -1,2 +1 @@
 export * from './input-number';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/features/input-number/input-number.d.ts

@@ -19,4 +19,3 @@ export declare function InputNumber({ ref, stepper, thousandSeparator, placehold
 export declare namespace InputNumber {
     var displayName: string;
 }
-//# sourceMappingURL=input-number.d.ts.map

package/dist/components/features/input-with-addons/index.d.ts

@@ -1,2 +1 @@
 export * from './input-with-addons';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/features/input-with-addons/input-with-addons.d.ts

@@ -11,4 +11,3 @@ declare namespace InputWithAddons {
     var displayName: string;
 }
 export { InputWithAddons };
-//# sourceMappingURL=input-with-addons.d.ts.map

package/dist/components/features/loader-overlay/index.d.ts

@@ -1,2 +1 @@
 export { LoaderOverlay } from './loader-overlay';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/features/loader-overlay/loader-overlay.d.ts

@@ -1,5 +1,6 @@
-export declare function LoaderOverlay({ message, className, }: {
-    message?: string | React.ReactNode;
-    className?: string;
-}): import("react").JSX.Element;
-//# sourceMappingURL=loader-overlay.d.ts.map
+/**
+ * LoaderOverlay now lives in the base layer (`base/loader-overlay`) so lower
+ * tiers such as `base/option-picker` can depend on it without inverting the
+ * base -> feature layering. This module re-exports it for backward compatibility.
+ */
+export { LoaderOverlay } from '../../base/loader-overlay';

package/dist/components/features/logo/index.d.ts

@@ -4,4 +4,3 @@ export { LogoIcon, type LogoIconProps } from './logo-icon';
 export { LogoStacked, type LogoStackedProps } from './logo-stacked';
 export { LogoText, type LogoTextProps } from './logo-text';
 export { logoStyles, type LogoTone } from './logo.styles';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/features/logo/logo-flat.d.ts

@@ -25,4 +25,3 @@ export declare function LogoFlat({ tone, decorative, className, 'aria-label': ar
 export declare namespace LogoFlat {
     var displayName: string;
 }
-//# sourceMappingURL=logo-flat.d.ts.map

package/dist/components/features/logo/logo-icon.d.ts

@@ -24,4 +24,3 @@ export declare function LogoIcon({ tone, decorative, className, 'aria-label': ar
 export declare namespace LogoIcon {
     var displayName: string;
 }
-//# sourceMappingURL=logo-icon.d.ts.map

package/dist/components/features/logo/logo-stacked.d.ts

@@ -21,4 +21,3 @@ export declare function LogoStacked({ tone, decorative, className, 'aria-label':
 export declare namespace LogoStacked {
     var displayName: string;
 }
-//# sourceMappingURL=logo-stacked.d.ts.map