@spark-ui/components 17.2.2 → 17.2.3-beta.1

package/dist/src/rating-display/RatingDisplay.d.ts

@@ -0,0 +1,31 @@
+import { ComponentPropsWithRef, PropsWithChildren } from 'react';
+import { RatingDisplayStarProps } from './RatingDisplayStar';
+export interface RatingDisplayProps extends PropsWithChildren<ComponentPropsWithRef<'div'>> {
+    /**
+     * When true, merges props onto the single child element instead of rendering a div.
+     * Use to render the root as a link or another custom element.
+     */
+    asChild?: boolean;
+    /**
+     * The rating value to display, on a scale from 0 to 5.
+     */
+    value?: number;
+    /**
+     * Sets the size of the stars.
+     * @default 'md'
+     */
+    size?: RatingDisplayStarProps['size'];
+    /**
+     * Optional count value available to `RatingDisplay.Count`.
+     */
+    count?: number;
+    /**
+     * Accessible description of the rating content.
+     */
+    'aria-label': string;
+}
+export type RatingDisplayRootProps = RatingDisplayProps;
+export declare const RatingDisplay: {
+    ({ value, size, count, asChild, ref, children, ...rest }: RatingDisplayProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/rating-display/RatingDisplayContext.d.ts

@@ -0,0 +1,12 @@
+import { PropsWithChildren } from 'react';
+import { RatingDisplayStarProps } from './RatingDisplayStar';
+interface RatingDisplayContextValue {
+    value: number;
+    size: RatingDisplayStarProps['size'];
+    count?: number;
+}
+interface RatingDisplayProviderProps extends PropsWithChildren<RatingDisplayContextValue> {
+}
+export declare const RatingDisplayProvider: ({ value, size, count, children, }: RatingDisplayProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useRatingDisplay: () => RatingDisplayContextValue;
+export {};

package/dist/src/rating-display/RatingDisplayCount.d.ts

@@ -0,0 +1,12 @@
+import { ComponentPropsWithRef, ReactNode } from 'react';
+export interface RatingDisplayCountProps extends Omit<ComponentPropsWithRef<'span'>, 'children'> {
+    /**
+     * Custom count content.
+     * Pass a render function to receive the count value and return the content to render.
+     */
+    children?: ReactNode | ((count: number) => ReactNode);
+}
+export declare const RatingDisplayCount: {
+    ({ className, children, ...rest }: RatingDisplayCountProps): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};

package/dist/src/rating-display/RatingDisplayStar.d.ts

@@ -0,0 +1,16 @@
+import { VariantProps } from 'class-variance-authority';
+import { StarValue } from './types';
+declare const ratingDisplayStarStyles: (props?: ({
+    gap?: "sm" | "md" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+declare const ratingDisplayStarIconStyles: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    design?: "filled" | "outlined" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+type RatingDisplayStarstylesProps = Omit<VariantProps<typeof ratingDisplayStarStyles>, never>;
+type RatingDisplayStarIconStylesProps = Omit<VariantProps<typeof ratingDisplayStarIconStyles>, 'design'>;
+export interface RatingDisplayStarProps extends RatingDisplayStarstylesProps, RatingDisplayStarIconStylesProps {
+    value: StarValue;
+}
+export declare const RatingDisplayStar: ({ value, size }: RatingDisplayStarProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/rating-display/RatingDisplayStars.d.ts

@@ -0,0 +1,22 @@
+import { RatingDisplayStarProps } from './RatingDisplayStar';
+import { StarValue } from './types';
+export interface RatingDisplayStarsProps {
+    size?: RatingDisplayStarProps['size'];
+    /**
+     * Sets the rendering mode for stars.
+     * @default 'default'
+     */
+    variant?: 'default' | 'single-star';
+    /**
+     * Custom fill algorithm for each star.
+     * By default, stars are rounded to the nearest 0.5.
+     */
+    getFillMode?: ({ value, index }: {
+        value?: number;
+        index: number;
+    }) => StarValue;
+}
+export declare const RatingDisplayStars: {
+    ({ size, variant, getFillMode, }: RatingDisplayStarsProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/rating-display/RatingDisplayValue.d.ts

@@ -0,0 +1,13 @@
+import { ComponentPropsWithRef, ReactNode } from 'react';
+export interface RatingDisplayValueProps extends Omit<ComponentPropsWithRef<'span'>, 'children'> {
+    /**
+     * Custom value content.
+     * Pass a render function to receive the formatted value (first arg) and raw value (second arg),
+     * then return the content to render.
+     */
+    children?: ReactNode | ((formattedValue: string, value: number) => ReactNode);
+}
+export declare const RatingDisplayValue: {
+    ({ className, children, ...rest }: RatingDisplayValueProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/rating-display/index.d.mts

@@ -0,0 +1,14 @@
+import { RatingDisplay as Root } from './RatingDisplay';
+import { RatingDisplayCount as Count } from './RatingDisplayCount';
+import { RatingDisplayStars as Stars } from './RatingDisplayStars';
+import { RatingDisplayValue as Value } from './RatingDisplayValue';
+export declare const RatingDisplay: typeof Root & {
+    Stars: typeof Stars;
+    Value: typeof Value;
+    Count: typeof Count;
+};
+export { type RatingDisplayProps, type RatingDisplayRootProps } from './RatingDisplay';
+export { type RatingDisplayStarsProps } from './RatingDisplayStars';
+export { type RatingDisplayValueProps } from './RatingDisplayValue';
+export { type RatingDisplayCountProps } from './RatingDisplayCount';
+export type { StarValue } from './types';

package/dist/src/rating-display/index.d.ts

@@ -0,0 +1,14 @@
+import { RatingDisplay as Root } from './RatingDisplay';
+import { RatingDisplayCount as Count } from './RatingDisplayCount';
+import { RatingDisplayStars as Stars } from './RatingDisplayStars';
+import { RatingDisplayValue as Value } from './RatingDisplayValue';
+export declare const RatingDisplay: typeof Root & {
+    Stars: typeof Stars;
+    Value: typeof Value;
+    Count: typeof Count;
+};
+export { type RatingDisplayProps, type RatingDisplayRootProps } from './RatingDisplay';
+export { type RatingDisplayStarsProps } from './RatingDisplayStars';
+export { type RatingDisplayValueProps } from './RatingDisplayValue';
+export { type RatingDisplayCountProps } from './RatingDisplayCount';
+export type { StarValue } from './types';

package/dist/src/rating-display/types.d.ts

@@ -0,0 +1 @@
+export type StarValue = 0 | 0.5 | 1;

package/dist/src/rating-display/utils.d.ts

@@ -0,0 +1,10 @@
+import { StarValue } from './types';
+declare function getNearestHalfDecimal(num: number): number;
+declare function formatRatingValue(value: number): string;
+declare function getStarValue({ value, index }: {
+    value?: number;
+    index: number;
+}): StarValue;
+declare function getSingleStarValue(value?: number): StarValue;
+declare function splitAt<T>(arr: T[], index: number): [T[], T[]];
+export { formatRatingValue, getNearestHalfDecimal, getSingleStarValue, getStarValue, splitAt };

package/dist/src/scrolling-list/ScrollingList.d.ts

@@ -0,0 +1,57 @@
+import { ScrollOverflow } from '../../../../hooks/dist/use-scroll-overflow/index';
+import { ComponentPropsWithRef, ReactNode, RefObject } from 'react';
+import { SnapCarouselResult } from 'react-snap-carousel';
+type SnapType = 'mandatory' | 'proximity' | 'none';
+type ScrollBehavior = 'smooth' | 'instant';
+type SnapStop = 'normal' | 'always';
+interface Props extends ComponentPropsWithRef<'div'> {
+    /**
+     * CSS scroll snap behavior.
+     * - `mandatory` to force snapping on each "page".
+     * - `proximity` to force snapping only when scroll position is near the edge of a "page". Behavior can change depending on each browser.
+     * - `none` to disabled scroll snapping.
+     */
+    snapType?: SnapType;
+    /**
+     * Defines whether or not the scroll container is allowed to "pass over" possible snap positions.
+     */
+    snapStop?: SnapStop;
+    scrollBehavior?: ScrollBehavior;
+    /**
+     * Add a fade effect to indicate content overflow.
+     */
+    withFade?: boolean;
+    children?: ReactNode;
+    /**
+     * When `true`, allow previous and next buttons to be used when reaching the edges of the list.
+     */
+    loop?: boolean;
+    /**
+     * Space (in pixels) between items.
+     */
+    gap?: number;
+    /**
+     * Offset (in pixels) of the left of the optimal viewing region of the list.
+     */
+    scrollPadding?: number;
+    className?: string;
+}
+interface ScrollingListContextState extends SnapCarouselResult {
+    snapType: SnapType;
+    snapStop: SnapStop;
+    scrollBehavior: ScrollBehavior;
+    visibleItemsRange: readonly [number, number];
+    loop: boolean;
+    gap: number;
+    withFade: boolean;
+    scrollPadding: number;
+    scrollAreaRef: RefObject<HTMLDivElement | null>;
+    overflow: ScrollOverflow;
+    skipKeyboardNavigation: () => void;
+}
+export declare const ScrollingListContext: import('react').Context<ScrollingListContextState>;
+export declare const ScrollingList: {
+    ({ snapType, snapStop, scrollBehavior, loop, gap, withFade, scrollPadding, children, className, ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/src/scrolling-list/ScrollingListControls.d.ts

@@ -0,0 +1,18 @@
+import { ComponentPropsWithoutRef, ReactNode } from 'react';
+interface ScrollingListControls extends ComponentPropsWithoutRef<'div'> {
+    /**
+     * Visibility behavior of the control buttons:
+     * - `always`: buttons are always visible.
+     * - `hover`: buttons only appear on hover.
+     *
+     * a11y: `hover` is dangerous for accessibility as it disabled controls for touch screen users.
+     * When using it, you must provide an alternative control outside of the list to replace them.
+     */
+    visibility?: 'hover' | 'always';
+    children: ReactNode;
+}
+export declare const ScrollingListControls: {
+    ({ children, visibility, className, ...rest }: ScrollingListControls): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/src/scrolling-list/ScrollingListItem.d.ts

@@ -0,0 +1,17 @@
+import { ComponentPropsWithoutRef, ReactNode } from 'react';
+export interface ScrollingListItemProps extends ComponentPropsWithoutRef<'div'> {
+    /**
+     * Change the default rendered element for the one passed as a child, merging their props and behavior.
+     */
+    asChild?: boolean;
+    children?: ReactNode;
+    /**
+     * DO NOT USE. This prop is automatically managed by the parent ScrollingList.ListItems
+     */
+    index?: number;
+    className?: string;
+}
+export declare const ScrollingListItem: {
+    ({ asChild, children, index, className, ...rest }: ScrollingListItemProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/scrolling-list/ScrollingListItems.d.ts

@@ -0,0 +1,11 @@
+import { ComponentPropsWithRef, ReactNode, Ref } from 'react';
+interface Props extends ComponentPropsWithRef<'div'> {
+    children?: ReactNode;
+    className?: string;
+}
+export declare function mergeRefs<T>(...refs: (Ref<T> | undefined | null)[]): Ref<T>;
+export declare const ScrollingListItems: {
+    ({ children, ref, className, ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/src/scrolling-list/ScrollingListNextButton.d.ts

@@ -0,0 +1,5 @@
+import { IconButtonProps } from '../icon-button';
+export declare const ScrollingListNextButton: {
+    ({ "aria-label": ariaLabel, ...rest }: IconButtonProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/scrolling-list/ScrollingListPrevButton.d.ts

@@ -0,0 +1,5 @@
+import { IconButtonProps } from '../icon-button';
+export declare const ScrollingListPrevButton: {
+    ({ "aria-label": ariaLabel, ...rest }: IconButtonProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/scrolling-list/ScrollingListSkipButton.d.ts

@@ -0,0 +1,9 @@
+import { ComponentPropsWithoutRef } from 'react';
+interface Props extends ComponentPropsWithoutRef<'button'> {
+    children: string;
+}
+export declare const ScrollingListSkipButton: {
+    ({ children, ...rest }: Props): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export {};

package/dist/src/scrolling-list/index.d.mts

@@ -0,0 +1,15 @@
+import { ScrollingList as Root } from './ScrollingList';
+import { ScrollingListControls as Controls } from './ScrollingListControls';
+import { ScrollingListItem as Item } from './ScrollingListItem';
+import { ScrollingListItems as Items } from './ScrollingListItems';
+import { ScrollingListNextButton as NextButton } from './ScrollingListNextButton';
+import { ScrollingListPrevButton as PrevButton } from './ScrollingListPrevButton';
+import { ScrollingListSkipButton as SkipButton } from './ScrollingListSkipButton';
+export declare const ScrollingList: typeof Root & {
+    Controls: typeof Controls;
+    NextButton: typeof NextButton;
+    PrevButton: typeof PrevButton;
+    Item: typeof Item;
+    Items: typeof Items;
+    SkipButton: typeof SkipButton;
+};

package/dist/src/scrolling-list/index.d.ts

@@ -0,0 +1,15 @@
+import { ScrollingList as Root } from './ScrollingList';
+import { ScrollingListControls as Controls } from './ScrollingListControls';
+import { ScrollingListItem as Item } from './ScrollingListItem';
+import { ScrollingListItems as Items } from './ScrollingListItems';
+import { ScrollingListNextButton as NextButton } from './ScrollingListNextButton';
+import { ScrollingListPrevButton as PrevButton } from './ScrollingListPrevButton';
+import { ScrollingListSkipButton as SkipButton } from './ScrollingListSkipButton';
+export declare const ScrollingList: typeof Root & {
+    Controls: typeof Controls;
+    NextButton: typeof NextButton;
+    PrevButton: typeof PrevButton;
+    Item: typeof Item;
+    Items: typeof Items;
+    SkipButton: typeof SkipButton;
+};

package/dist/src/scrolling-list/useFocusWithinScroll.d.ts

@@ -0,0 +1,3 @@
+import { RefObject } from 'react';
+export declare function useFocusWithinScroll<T extends HTMLElement | null>(ref: RefObject<T>, // The container to detect focus within
+scrollRef: RefObject<HTMLDivElement | null>): boolean;

package/dist/src/segmented-control/SegmentedControl.d.ts

@@ -0,0 +1,22 @@
+import { RadioGroup } from '@base-ui/react/radio-group';
+import { ComponentProps, Ref } from 'react';
+import { SegmentedControlStylesProps } from './SegmentedControl.styles';
+export interface SegmentedControlProps extends Omit<ComponentProps<typeof RadioGroup>, 'value' | 'defaultValue' | 'onValueChange'>, SegmentedControlStylesProps {
+    /**
+     * The controlled selected value.
+     */
+    value?: string;
+    /**
+     * The uncontrolled default selected value.
+     */
+    defaultValue?: string;
+    /**
+     * Callback fired when the selected value changes.
+     */
+    onValueChange?: (value: string) => void;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare const SegmentedControl: {
+    ({ value, defaultValue, onValueChange, className, children, ref, ...rest }: SegmentedControlProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/segmented-control/SegmentedControl.styles.d.ts

@@ -0,0 +1,5 @@
+import { VariantProps } from 'class-variance-authority';
+export declare const rootStyles: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const itemStyles: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export declare const indicatorStyles: (props?: import('class-variance-authority/types').ClassProp | undefined) => string;
+export type SegmentedControlStylesProps = VariantProps<typeof itemStyles>;

package/dist/src/segmented-control/SegmentedControlContext.d.ts

@@ -0,0 +1,7 @@
+import { RefObject } from 'react';
+export interface SegmentedControlContextInterface {
+    checkedValue: string | null;
+    containerRef: RefObject<HTMLDivElement | null>;
+}
+export declare const SegmentedControlContext: import('react').Context<SegmentedControlContextInterface>;
+export declare const useSegmentedControlContext: () => SegmentedControlContextInterface;

package/dist/src/segmented-control/SegmentedControlIndicator.d.ts

@@ -0,0 +1,8 @@
+import { ComponentProps, Ref } from 'react';
+export interface SegmentedControlIndicatorProps extends ComponentProps<'span'> {
+    ref?: Ref<HTMLSpanElement>;
+}
+export declare const SegmentedControlIndicator: {
+    ({ className, ref, ...rest }: SegmentedControlIndicatorProps): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};

package/dist/src/segmented-control/SegmentedControlItem.d.ts

@@ -0,0 +1,18 @@
+import { Radio } from '@base-ui/react/radio';
+import { ComponentProps, Ref } from 'react';
+export interface SegmentedControlItemProps extends Omit<ComponentProps<typeof Radio.Root>, 'value'> {
+    /**
+     * A unique value that identifies this item within the segmented control.
+     */
+    value: string;
+    /**
+     * When true, prevents the user from interacting with this item.
+     * @default false
+     */
+    disabled?: boolean;
+    ref?: Ref<HTMLElement>;
+}
+export declare const SegmentedControlItem: {
+    ({ value, disabled, children, className, ref, ...rest }: SegmentedControlItemProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/segmented-control/index.d.mts

@@ -0,0 +1,10 @@
+import { SegmentedControl as Root } from './SegmentedControl';
+import { SegmentedControlIndicator as Indicator } from './SegmentedControlIndicator';
+import { SegmentedControlItem as Item } from './SegmentedControlItem';
+export declare const SegmentedControl: typeof Root & {
+    Item: typeof Item;
+    Indicator: typeof Indicator;
+};
+export type { SegmentedControlProps } from './SegmentedControl';
+export type { SegmentedControlItemProps } from './SegmentedControlItem';
+export type { SegmentedControlIndicatorProps } from './SegmentedControlIndicator';

package/dist/src/segmented-control/index.d.ts

@@ -0,0 +1,10 @@
+import { SegmentedControl as Root } from './SegmentedControl';
+import { SegmentedControlIndicator as Indicator } from './SegmentedControlIndicator';
+import { SegmentedControlItem as Item } from './SegmentedControlItem';
+export declare const SegmentedControl: typeof Root & {
+    Item: typeof Item;
+    Indicator: typeof Indicator;
+};
+export type { SegmentedControlProps } from './SegmentedControl';
+export type { SegmentedControlItemProps } from './SegmentedControlItem';
+export type { SegmentedControlIndicatorProps } from './SegmentedControlIndicator';

package/dist/src/segmented-gauge/SegmentedGauge.d.ts

@@ -0,0 +1,66 @@
+import { Ref } from 'react';
+export interface SegmentedGaugeProps {
+    /**
+     * The current value of the gauge
+     */
+    value?: number;
+    /**
+     * Minimum value of the gauge (aria-valuemin)
+     */
+    min: number;
+    /**
+     * Maximum value of the gauge (aria-valuemax)
+     */
+    max: number;
+    /**
+     * Description text for the gauge (aria-describedby)
+     */
+    description?: string;
+    /**
+     * Size of the gauge
+     */
+    size?: 'sm' | 'md';
+    /**
+     * Intent of the gauge - predefined color intent
+     */
+    intent?: 'main' | 'support' | 'accent' | 'success' | 'alert' | 'danger' | 'info' | 'neutral';
+    /**
+     * Custom color for the gauge (hex, CSS variable, etc.)
+     */
+    customColor?: string;
+    /**
+     * ID of the gauge element
+     */
+    id?: string;
+    /**
+     * Accessible label for the gauge (required if no id is provided)
+     */
+    'aria-label'?: string;
+    /**
+     * Textual representation of the current value (aria-valuetext)
+     * By default, percentage is used (e.g. "33%")
+     */
+    'aria-valuetext'?: string;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+    /**
+     * Ref to the root element
+     */
+    ref?: Ref<HTMLDivElement>;
+    /**
+     * Children render prop for custom rendering
+     */
+    children?: (props: {
+        segments: {
+            isActive: boolean;
+            isCurrent: boolean;
+        }[];
+        currentIndex: number;
+    }) => React.ReactNode;
+}
+export declare const SegmentedGauge: {
+    ({ value, min, max, description, size, intent, customColor, id, "aria-label": ariaLabel, className, ref, children, ...props }: SegmentedGaugeProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/segmented-gauge/SegmentedGaugeContext.d.ts

@@ -0,0 +1,14 @@
+export interface SegmentedGaugeContextValue {
+    value?: number;
+    min: number;
+    max: number;
+    segments: number;
+    currentIndex: number;
+    size: 'sm' | 'md';
+    intent: 'main' | 'support' | 'accent' | 'success' | 'alert' | 'danger' | 'info' | 'neutral';
+    customColor?: string;
+    labelId: string;
+    gaugeId: string;
+}
+export declare const SegmentedGaugeContext: import('react').Context<SegmentedGaugeContextValue | null>;
+export declare const useSegmentedGaugeContext: () => SegmentedGaugeContextValue;

package/dist/src/segmented-gauge/SegmentedGaugeLabel.d.ts

@@ -0,0 +1,9 @@
+import { ComponentProps, Ref } from 'react';
+export interface SegmentedGaugeLabelProps extends ComponentProps<'span'> {
+    ref?: Ref<HTMLSpanElement>;
+    id?: string;
+}
+export declare const SegmentedGaugeLabel: {
+    ({ className, children, ref, id, ...props }: SegmentedGaugeLabelProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/segmented-gauge/SegmentedGaugeSegment.d.ts

@@ -0,0 +1,12 @@
+import { ComponentProps, Ref } from 'react';
+export interface SegmentedGaugeSegmentProps extends ComponentProps<'div'> {
+    /**
+     * Index of this segment (0-based)
+     */
+    index?: number;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare const SegmentedGaugeSegment: {
+    ({ index, className, children, ref, ...props }: SegmentedGaugeSegmentProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/segmented-gauge/SegmentedGaugeTrack.d.ts

@@ -0,0 +1,8 @@
+import { ComponentProps, Ref } from 'react';
+export interface SegmentedGaugeTrackProps extends ComponentProps<'div'> {
+    ref?: Ref<HTMLDivElement>;
+}
+export declare const SegmentedGaugeTrack: {
+    ({ className, children, ref, ...props }: SegmentedGaugeTrackProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/segmented-gauge/index.d.mts

@@ -0,0 +1,13 @@
+import { SegmentedGauge as Root } from './SegmentedGauge';
+import { SegmentedGaugeLabel } from './SegmentedGaugeLabel';
+import { SegmentedGaugeSegment } from './SegmentedGaugeSegment';
+import { SegmentedGaugeTrack } from './SegmentedGaugeTrack';
+export declare const SegmentedGauge: typeof Root & {
+    Track: typeof SegmentedGaugeTrack;
+    Segment: typeof SegmentedGaugeSegment;
+    Label: typeof SegmentedGaugeLabel;
+};
+export { type SegmentedGaugeProps } from './SegmentedGauge';
+export { type SegmentedGaugeTrackProps } from './SegmentedGaugeTrack';
+export { type SegmentedGaugeSegmentProps } from './SegmentedGaugeSegment';
+export { type SegmentedGaugeLabelProps } from './SegmentedGaugeLabel';

package/dist/src/segmented-gauge/index.d.ts

@@ -0,0 +1,13 @@
+import { SegmentedGauge as Root } from './SegmentedGauge';
+import { SegmentedGaugeLabel } from './SegmentedGaugeLabel';
+import { SegmentedGaugeSegment } from './SegmentedGaugeSegment';
+import { SegmentedGaugeTrack } from './SegmentedGaugeTrack';
+export declare const SegmentedGauge: typeof Root & {
+    Track: typeof SegmentedGaugeTrack;
+    Segment: typeof SegmentedGaugeSegment;
+    Label: typeof SegmentedGaugeLabel;
+};
+export { type SegmentedGaugeProps } from './SegmentedGauge';
+export { type SegmentedGaugeTrackProps } from './SegmentedGaugeTrack';
+export { type SegmentedGaugeSegmentProps } from './SegmentedGaugeSegment';
+export { type SegmentedGaugeLabelProps } from './SegmentedGaugeLabel';

package/dist/src/select/Select.d.ts

@@ -0,0 +1,6 @@
+import { SelectContextProps } from './SelectContext';
+export type SelectProps = Omit<SelectContextProps, 'itemsComponent'>;
+export declare const Select: {
+    ({ children, ...props }: SelectProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};

package/dist/src/select/SelectContext.d.ts

@@ -0,0 +1,59 @@
+import { Dispatch, PropsWithChildren, ReactElement, SetStateAction } from 'react';
+import { ItemsMap, SelectItem } from './types';
+export interface SelectContextState {
+    itemsMap: ItemsMap;
+    disabled: boolean;
+    readOnly: boolean;
+    state?: 'error' | 'alert' | 'success';
+    itemsComponent: ReactElement | undefined;
+    selectedItem: SelectItem | undefined;
+    setValue: (value: string) => void;
+    isControlled: boolean;
+    onValueChange?: (value: string) => void;
+    ariaLabel: string | undefined;
+    setAriaLabel: Dispatch<SetStateAction<string | undefined>>;
+    fieldId: string;
+    fieldLabelId: string | undefined;
+    name: string | undefined;
+    required: boolean;
+    placeholder: string | undefined;
+    setPlaceholder: Dispatch<SetStateAction<string | undefined>>;
+}
+export type SelectContextProps = PropsWithChildren<{
+    /**
+     * Use `state` prop to assign a specific state to the select, choosing from: `error`, `alert` and `success`. By doing so, the outline styles will be updated.
+     */
+    state?: 'error' | 'alert' | 'success';
+    /**
+     * When true, prevents the user from interacting with the select.
+     */
+    disabled?: boolean;
+    /**
+     * Sets the select as interactive or not.
+     */
+    readOnly?: boolean;
+    /**
+     * The value of the select when initially rendered. Use when you do not need to control the state of the select.
+     */
+    defaultValue?: string;
+    /**
+     * The controlled value of the select. Should be used in conjunction with `onValueChange`.
+     */
+    value?: string;
+    /**
+     * Event handler called when the value changes.
+     */
+    onValueChange?: (value: string) => void;
+    itemsComponent: ReactElement | undefined;
+    /**
+     * This attribute is used to specify the name of the control.
+     * If wrapped with a FormField with a name, will be inherited from it.
+     */
+    name?: string;
+    /**
+     * A Boolean attribute indicating that an option with a non-empty string value must be selected.
+     */
+    required?: boolean;
+}>;
+export declare const SelectProvider: ({ children, defaultValue, value: valueProp, onValueChange, disabled: disabledProp, readOnly: readOnlyProp, state: stateProp, itemsComponent, name: nameProp, required: requiredProp, }: SelectContextProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useSelectContext: () => SelectContextState;