@bigbinary/neeto-atoms 1.0.133-beta1 → 1.0.133-beta2

package/dist/components/RadioGroup.js

@@ -0,0 +1,50 @@
+export { R as RadioGroup } from '../RadioGroup-CBXByAMW.js';
+import 'react/jsx-runtime';
+import 'react';
+import '../utils-BJnb9o5c.js';
+import '../primitives/RadioGroup.js';
+import '../index-DNzunGHb.js';
+import '../index-BtkPdosV.js';
+import '../index-CiyxEyB0.js';
+import '../index-DhnfW8wQ.js';
+import 'react-dom';
+import '../index-DT56XkyA.js';
+import '../index-Dd1i1d2M.js';
+import '../index-zW4GjM5L.js';
+import '../index-DOzu5J1s.js';
+import '../index-CSUSJzOJ.js';
+import '../index-Cor698lu.js';
+import '../index-d0BBQf5t.js';
+import '../index-BYZaLNq1.js';
+import '../index-30QpKM0j.js';
+import '../index-yFgkK_AM.js';
+import '../primitives/Label.js';
+import '../label-YEsizr2c.js';
+import '../primitives/Field.js';
+import '../HelpIcon-CB6wsVSF.js';
+import '../primitives/Tooltip.js';
+import '../tooltip-BUYRFmEv.js';
+import '../index-BNPynZWM.js';
+import '../index-XvwNqU74.js';
+import '../floating-ui.react-dom-BtFUJRfb.js';
+import '../floating-ui.utils.dom-Bw_Rc4bg.js';
+import '../index-fV_U4ZJM.js';
+import '../index-CSggBaQF.js';
+import '../renderIcon-C6twJSqH.js';
+import '../createLucideIcon-C8ycilSN.js';
+import '../Popover-BHGvcdV2.js';
+import '../index-Bo3AAQJp.js';
+import '../primitives/HoverCard.js';
+import '../Typography-CmILccNh.js';
+import '../index-CfriMyrd.js';
+import '../Button-ZssOVkG0.js';
+import 'react-router-dom';
+import '../primitives/Button.js';
+import '../button-DTkEk06V.js';
+import '../primitives/Spinner.js';
+import 'react-i18next';
+import '../loader-circle-DycHUAWN.js';
+import '../separator-ByRsc-y-.js';
+import '../fieldIds-VpluAAMl.js';
+import '../hyphenize-TRhMI0tl.js';
+//# sourceMappingURL=RadioGroup.js.map

package/dist/components/RadioGroup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RadioGroup.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/components/Select/MultiSelectCombobox.d.ts

@@ -0,0 +1,2 @@
+import type { MultiSelectComboboxProps } from "./MultiSelectCombobox.types";
+export declare const MultiSelectCombobox: import("react").ForwardRefExoticComponent<MultiSelectComboboxProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/components/Select/MultiSelectCombobox.types.d.ts

@@ -0,0 +1,51 @@
+import type React from "react";
+import type { ComboboxContent } from "src/primitives/Combobox";
+import type { DropdownPassthroughProps } from "./dropdown.types";
+export type { DropdownPassthroughProps };
+export interface MultiSelectComboboxProps {
+    name?: string;
+    id: string;
+    /** ID of the field label, used to label the trigger in content-search mode. */
+    labelId?: string;
+    effectiveItems?: string[] | {
+        label: string;
+        items: string[];
+    }[];
+    labelForValue: (val: string) => string;
+    renderOption: (val: string) => React.ReactNode;
+    isSearchable: boolean;
+    /** Whether search happens in the control or inside the dropdown. */
+    searchPosition: "trigger" | "content";
+    /** Placeholder for the in-dropdown search field. */
+    searchPlaceholder: string;
+    isAsync: boolean;
+    /** Matches options against the query the Select tracks itself. */
+    optionFilter: (v: string, q: string, fn?: (v: string) => string) => boolean;
+    isControlled: boolean;
+    valueProp?: string[];
+    defaultValue?: string[];
+    selectedValues: string[];
+    handleValueChange: (...args: unknown[]) => void;
+    handleInputValueChange: (...args: unknown[]) => void;
+    onOpenChange?: (open: boolean) => void;
+    isDisabled: boolean;
+    autoHighlight: boolean;
+    required: boolean;
+    sizeConfig: {
+        chips: string;
+        input: string;
+        chip: string;
+        icon: string;
+        clearIcon: string;
+    };
+    error: string;
+    chipsClassName?: string;
+    inputClassName?: string;
+    placeholder: string;
+    hideChipRemove: boolean;
+    ariaDescribedBy?: string;
+    testIdPrefix?: string;
+    contentProps?: Omit<React.ComponentProps<typeof ComboboxContent>, "anchor" | "children">;
+    dropdownProps: DropdownPassthroughProps;
+    children?: React.ReactNode;
+}

package/dist/components/Select/MultiSelectDropdown.d.ts

@@ -0,0 +1,9 @@
+import type React from "react";
+import type { DropdownPassthroughProps } from "./MultiSelectCombobox.types";
+interface MultiSelectDropdownProps extends DropdownPassthroughProps {
+    renderOption: (val: string) => React.ReactNode;
+    testIdPrefix?: string;
+    children?: React.ReactNode;
+}
+export declare function MultiSelectDropdown({ resolvedOptions, flatOptionsMap, isGrouped, isLoading, loadingMessage, emptyMessage, showCreateOption, renderOption, testIdPrefix, hasMoreLazy, loaderCallbackRef, children, }: MultiSelectDropdownProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Select/OptionItem.d.ts

@@ -0,0 +1,10 @@
+import type React from "react";
+import type { OptionBase } from "./types";
+interface OptionItemProps {
+    val: string;
+    flatOptionsMap: Map<string, OptionBase>;
+    renderOption: (val: string) => React.ReactNode;
+    testIdPrefix?: string;
+}
+export declare function OptionItem({ val, flatOptionsMap, renderOption, testIdPrefix, }: OptionItemProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Select/Select.d.ts

@@ -0,0 +1,4 @@
+import type { SelectProps } from "./types";
+export type { SelectProps, SelectOption, SelectOptionBase, SelectOptionGroup, } from "./types";
+declare const Select: import("react").ForwardRefExoticComponent<SelectProps & import("react").RefAttributes<HTMLInputElement>>;
+export { Select };

package/dist/components/Select/SelectAnchor.d.ts

@@ -0,0 +1,26 @@
+interface SelectAnchorProps {
+    /**
+     * Render the anchor as a `Combobox.Trigger` instead of a plain wrapper. Used
+     * when the control itself is not a search input — either because search is
+     * off, or because the search field lives inside the dropdown. Base UI then
+     * treats this element as the combobox: it gets `role="combobox"`,
+     * `tabIndex=0` and the expanded/haspopup state.
+     */
+    renderAsTrigger: boolean;
+    className?: string;
+    dataTestId?: string;
+    /**
+     * Accessibility props applied only when the trigger, rather than a hidden
+     * input, is the form control (`searchPosition="content"`).
+     */
+    triggerFieldProps?: {
+        id?: string;
+        "aria-labelledby"?: string;
+        "aria-describedby"?: string;
+        "aria-required"?: boolean;
+        "aria-invalid"?: boolean;
+    };
+    children: React.ReactNode;
+}
+export declare const SelectAnchor: import("react").ForwardRefExoticComponent<SelectAnchorProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/Select/SelectCombobox.d.ts

@@ -0,0 +1,2 @@
+import type { SelectComboboxProps } from "./SelectCombobox.types";
+export declare const SelectCombobox: import("react").ForwardRefExoticComponent<SelectComboboxProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/components/Select/SelectCombobox.types.d.ts

@@ -0,0 +1,87 @@
+import type React from "react";
+import type { ComboboxContent } from "src/primitives/Combobox";
+import type { DropdownPassthroughProps } from "./dropdown.types";
+export type { DropdownPassthroughProps };
+export interface SelectComboboxProps {
+    /** Name attribute forwarded to the underlying input. */
+    name?: string;
+    /** ID for the combobox input, forwarded from the field wrapper. */
+    id: string;
+    /** ID of the field label, used to label the trigger in content-search mode. */
+    labelId?: string;
+    /** Base-UI items array for filtering (derived from options). */
+    effectiveItems?: string[] | {
+        label: string;
+        items: string[];
+    }[];
+    /** Returns the display label for a given value string. */
+    labelForValue: (val: string) => string;
+    /** Returns the ReactNode for rendering a value (dropdown rows). */
+    renderOption: (val: string) => React.ReactNode;
+    /** Returns the ReactNode for rendering the selected value in the trigger. */
+    renderTrigger: (val: string) => React.ReactNode;
+    /** Whether the search input is visible. */
+    isSearchable: boolean;
+    /** Whether search happens in the control or inside the dropdown. */
+    searchPosition: "trigger" | "content";
+    /** Placeholder for the in-dropdown search field. */
+    searchPlaceholder: string;
+    /** The current search query. Empty unless the user is typing. */
+    inputValue: string;
+    /** Whether options are loaded asynchronously. */
+    isAsync: boolean;
+    /** Matches options against the query the Select tracks itself. */
+    optionFilter: (v: string, q: string, fn?: (v: string) => string) => boolean;
+    /** Whether the component is in controlled mode. */
+    isControlled: boolean;
+    /** Controlled value (only when isControlled=true). */
+    valueProp?: string;
+    /** Default value for uncontrolled mode. */
+    defaultValue?: string;
+    /** The currently selected value string. */
+    currentValue: string;
+    /** Called by the combobox when the selected value changes. */
+    handleValueChange: (next: string | null) => void;
+    /** Called by the combobox when the search input value changes. */
+    handleInputValueChange: (value: string, details?: {
+        reason?: string;
+    }) => void;
+    /** Called when the clear button is clicked. */
+    handleClear: () => void;
+    /** Callback when the dropdown opens or closes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Whether the component is disabled. */
+    isDisabled: boolean;
+    /** Whether the first matching item is highlighted automatically. */
+    autoHighlight: boolean;
+    /** Whether the field is required. */
+    required: boolean;
+    /** Whether to show a clear button when a value is selected. */
+    isClearable: boolean;
+    /** Whether the clear button is currently visible. */
+    showClearButton: boolean;
+    /** Tailwind size classes for the trigger container. */
+    sizeConfig: {
+        chips: string;
+        input: string;
+        chip: string;
+        icon: string;
+        clearIcon: string;
+    };
+    /** Error string (non-empty triggers error styling). */
+    error: string;
+    /** Placeholder text for the input. */
+    placeholder: string;
+    /** aria-describedby value for the input. */
+    ariaDescribedBy?: string;
+    /** data-testid prefix for the component tree. */
+    testIdPrefix?: string;
+    /** Additional CSS class names for the input/trigger. */
+    inputClassName?: string;
+    /** Props forwarded to ComboboxContent. */
+    contentProps?: Omit<React.ComponentProps<typeof ComboboxContent>, "anchor" | "children">;
+    /** Dropdown state props passed through to MultiSelectDropdown. */
+    dropdownProps: DropdownPassthroughProps;
+    /** Children rendered inside the dropdown (overrides options). */
+    children?: React.ReactNode;
+}

package/dist/components/Select/SelectFieldWrapper.d.ts

@@ -0,0 +1,24 @@
+import type React from "react";
+import { FieldLabel } from "src/primitives/Field";
+interface SelectFieldWrapperProps {
+    id: string;
+    label: string;
+    error: string;
+    helpText: React.ReactNode;
+    errorId: string;
+    helpTextId: string;
+    labelId?: string;
+    isDisabled: boolean;
+    required: boolean;
+    testIdPrefix?: string;
+    /**
+     * Focus the element with `id` when the label is clicked. Needed when the
+     * control is the combobox trigger (a `div`), which `htmlFor` cannot target.
+     */
+    focusTargetOnLabelClick?: boolean;
+    labelProps?: Omit<React.ComponentProps<typeof FieldLabel>, "htmlFor" | "children">;
+    className?: string;
+    children: React.ReactNode;
+}
+export declare function SelectFieldWrapper({ id, label, error, helpText, errorId, helpTextId, labelId, isDisabled, required, testIdPrefix, focusTargetOnLabelClick, labelProps, className, children, }: SelectFieldWrapperProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Select/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const INPUT_CHANGE_REASON = "input-change";
+export declare const SIZE_CONFIG: Record<"small" | "medium" | "large", {
+    chips: string;
+    input: string;
+    chip: string;
+    icon: string;
+    clearIcon: string;
+}>;

package/dist/components/Select/dropdown.types.d.ts

@@ -0,0 +1,12 @@
+import type { SelectOption, SelectOptionBase } from "./types";
+export interface DropdownPassthroughProps {
+    resolvedOptions: SelectOption[];
+    flatOptionsMap: Map<string, SelectOptionBase>;
+    isGrouped: boolean;
+    isLoading: boolean;
+    loadingMessage: string;
+    emptyMessage: string;
+    showCreateOption: boolean;
+    hasMoreLazy: boolean;
+    loaderCallbackRef: (node: HTMLDivElement | null) => void;
+}

package/dist/components/Select/hooks/useAsyncOptions.d.ts

@@ -0,0 +1,13 @@
+import type { SelectOptionBase } from "src/components/Select/types";
+interface UseAsyncOptionsConfig {
+    loadOptions?: (inputValue: string) => Promise<SelectOptionBase[]>;
+    defaultOptions?: boolean | SelectOptionBase[];
+    cacheOptions?: boolean;
+}
+interface UseAsyncOptionsReturn {
+    asyncOptions: SelectOptionBase[];
+    isLoading: boolean;
+    handleAsyncInputChange: (value: string) => void;
+}
+export declare function useAsyncOptions({ loadOptions, defaultOptions, cacheOptions, }: UseAsyncOptionsConfig): UseAsyncOptionsReturn;
+export {};

package/dist/components/Select/hooks/useCreatableItems.d.ts

@@ -0,0 +1,33 @@
+import React from "react";
+import type { SelectOptionBase as MultiSelectOptionBase } from "src/components/Select/types";
+export declare const CREATE_PREFIX = "__create__:";
+export declare const isCreateValue: (val: unknown) => val is string;
+interface UseCreatableItemsConfig {
+    isCreatable: boolean;
+    isGrouped: boolean;
+    flatOptions: MultiSelectOptionBase[];
+    selectedValues: string[];
+    baseUiItems?: string[] | {
+        label: string;
+        items: string[];
+    }[];
+    onCreateOption?: (inputValue: string) => void;
+    onChange?: (values: string[]) => void;
+    onAsyncInputChange?: (value: string) => void;
+    children?: React.ReactNode;
+}
+interface UseCreatableItemsReturn {
+    inputValue: string;
+    showCreateOption: boolean;
+    effectiveItems: string[] | {
+        label: string;
+        items: string[];
+    }[] | undefined;
+    optionFilter: (itemValue: string, query: string, itemToString?: (v: string) => string) => boolean;
+    handleInputValueChange: (value: string, details?: {
+        reason?: string;
+    }) => void;
+    handleValueChange: (next: string[] | null) => void;
+}
+export declare function useCreatableItems({ isCreatable, isGrouped, flatOptions, selectedValues, baseUiItems, onCreateOption, onChange, onAsyncInputChange, children, }: UseCreatableItemsConfig): UseCreatableItemsReturn;
+export {};

package/dist/components/Select/hooks/useLazyLoadSentinel.d.ts

@@ -0,0 +1,6 @@
+interface UseLazyLoadSentinelConfig {
+    fetchMore?: () => void;
+    isEnabled: boolean;
+}
+export declare function useLazyLoadSentinel({ fetchMore, isEnabled, }: UseLazyLoadSentinelConfig): (node: HTMLDivElement | null) => void;
+export {};

package/dist/components/Select/hooks/useMultiSelectOptions.d.ts

@@ -0,0 +1,33 @@
+import type { SelectOption as MultiSelectOption } from "src/components/Select/types";
+interface UseMultiSelectOptionsConfig {
+    options?: MultiSelectOption[];
+    loadOptions?: (inputValue: string) => Promise<{
+        label: string;
+        value: string;
+        disabled?: boolean;
+    }[]>;
+    defaultOptions?: boolean | {
+        label: string;
+        value: string;
+        disabled?: boolean;
+    }[];
+    cacheOptions?: boolean;
+    isAsyncLoadOptionEnabled?: boolean;
+    fetchMore?: () => void;
+    totalOptionsCount?: number;
+}
+export declare function useMultiSelectOptions(props: UseMultiSelectOptionsConfig): {
+    isAsync: boolean;
+    resolvedOptions: import("src/components/Select/types").Option[];
+    flatOptions: import("src/components/Select/types").OptionBase[];
+    isGrouped: boolean;
+    isLoading: boolean;
+    handleAsyncInputChange: (value: string) => void;
+    baseUiItems: string[] | {
+        label: string;
+        items: string[];
+    }[] | undefined;
+    hasMoreLazy: boolean;
+    loaderCallbackRef: (node: HTMLDivElement | null) => void;
+};
+export {};

package/dist/components/Select/hooks/useMultiSelectState.d.ts

@@ -0,0 +1,50 @@
+import type React from "react";
+import type { MultiSelectProps } from "src/components/Select/types";
+export declare function useMultiSelectState(props: MultiSelectProps): {
+    id: string;
+    errorId: string;
+    helpTextId: string;
+    labelId: string;
+    sizeConfig: {
+        chips: string;
+        input: string;
+        chip: string;
+        icon: string;
+        clearIcon: string;
+    };
+    isControlled: boolean;
+    selectedValues: string[];
+    isSearchable: boolean;
+    searchPosition: "content" | "trigger";
+    searchPlaceholder: string;
+    effectiveItems: string[] | {
+        label: string;
+        items: string[];
+    }[] | undefined;
+    optionFilter: (itemValue: string, query: string, itemToString?: (v: string) => string) => boolean;
+    handleInputValueChange: (value: string, details?: {
+        reason?: string;
+    }) => void;
+    handleValueChange: (next: string[] | null) => void;
+    showCreateOption: boolean;
+    ariaDescribedBy: string | undefined;
+    testIdPrefix: string;
+    labelForValue: (val: string) => string;
+    renderOption: (val: string) => React.ReactNode;
+    flatOptionsMap: Map<string, import("src/components/Select/types").OptionBase>;
+    label: string;
+    error: string;
+    helpText: string | number | bigint | boolean | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null;
+    isAsync: boolean;
+    resolvedOptions: import("src/components/Select/types").Option[];
+    flatOptions: import("src/components/Select/types").OptionBase[];
+    isGrouped: boolean;
+    isLoading: boolean;
+    handleAsyncInputChange: (value: string) => void;
+    baseUiItems: string[] | {
+        label: string;
+        items: string[];
+    }[] | undefined;
+    hasMoreLazy: boolean;
+    loaderCallbackRef: (node: HTMLDivElement | null) => void;
+};

package/dist/components/Select/hooks/useSelectState.d.ts

@@ -0,0 +1,63 @@
+import type React from "react";
+import type { SelectProps } from "src/components/Select/types";
+type SingleSelectProps = Extract<SelectProps, {
+    isMulti?: false;
+}>;
+export declare function useSelectState(props: SingleSelectProps): {
+    id: string;
+    errorId: string;
+    helpTextId: string;
+    labelId: string;
+    sizeConfig: {
+        chips: string;
+        input: string;
+        chip: string;
+        icon: string;
+        clearIcon: string;
+    };
+    isControlled: boolean;
+    currentValue: string;
+    effectiveItems: string[] | {
+        label: string;
+        items: string[];
+    }[] | undefined;
+    optionFilter: (itemValue: string, _query: string, itemToString?: (v: string) => string) => boolean;
+    handleValueChange: (next: string | null) => void;
+    handleInputValueChange: (value: string, details?: {
+        reason?: string;
+    }) => void;
+    handleClear: () => void;
+    showCreateOption: boolean;
+    showClearButton: boolean;
+    ariaDescribedBy: string | undefined;
+    testIdPrefix: string;
+    labelForValue: (val: string) => string;
+    renderOption: (val: string) => React.ReactNode;
+    renderTrigger: (val: string) => React.ReactNode;
+    flatOptionsMap: Map<string, import("src/components/Select/types").OptionBase>;
+    label: string;
+    error: string;
+    helpText: string | number | bigint | boolean | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null;
+    isDisabled: boolean;
+    required: boolean;
+    isSearchable: boolean;
+    searchPosition: "content" | "trigger";
+    searchPlaceholder: string;
+    inputValue: string;
+    autoHighlight: boolean;
+    onOpenChange: ((open: boolean) => void) | undefined;
+    isClearable: boolean;
+    isAsync: boolean;
+    resolvedOptions: import("src/components/Select/types").Option[];
+    flatOptions: import("src/components/Select/types").OptionBase[];
+    isGrouped: boolean;
+    isLoading: boolean;
+    handleAsyncInputChange: (value: string) => void;
+    baseUiItems: string[] | {
+        label: string;
+        items: string[];
+    }[] | undefined;
+    hasMoreLazy: boolean;
+    loaderCallbackRef: (node: HTMLDivElement | null) => void;
+};
+export {};

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

@@ -0,0 +1,2 @@
+export { Select } from "./Select";
+export type { SelectProps, SelectOption, SelectOptionBase, SelectOptionGroup, } from "./types";