figma-kit 1.0.0-beta.22 → 1.0.0-beta.24

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

@@ -0,0 +1,24 @@
+import React from 'react';
+import { Toggle } from '@base-ui/react/toggle';
+import { ToggleGroup } from '@base-ui/react/toggle-group';
+import { type TextProps as TextPrimitiveProps } from '../text';
+type RootProps = Omit<ToggleGroup.Props<string>, 'defaultValue' | 'multiple' | 'onValueChange' | 'value'> & {
+    defaultValue?: string | undefined;
+    fullWidth?: boolean | undefined;
+    onValueChange?: ((value: string) => void) | undefined;
+    value?: string | undefined;
+};
+declare const Root: React.ForwardRefExoticComponent<Omit<RootProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ItemProps = Toggle.Props<string>;
+declare const Item: React.ForwardRefExoticComponent<Omit<ItemProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+type TextProps = TextPrimitiveProps;
+declare const Text: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & import("class-variance-authority").VariantProps<(props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+    weight?: "strong" | "default" | null | undefined;
+    align?: "center" | "end" | "start" | null | undefined;
+    block?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & {
+    render?: import("@base-ui/react").useRender.RenderProp | undefined;
+} & React.RefAttributes<HTMLSpanElement>>;
+export type { RootProps, ItemProps, TextProps };
+export { Root, Item, Text };

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

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

package/dist/components/select/select.d.ts

@@ -0,0 +1,40 @@
+import React from 'react';
+import { Select as BaseSelect } from '@base-ui/react/select';
+type RootProps<Value = unknown, Multiple extends boolean | undefined = false> = BaseSelect.Root.Props<Value, Multiple>;
+declare const Root: typeof BaseSelect.Root;
+type PortalProps = BaseSelect.Portal.Props;
+declare const Portal: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectPortalProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ValueProps = BaseSelect.Value.Props;
+declare const Value: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectValueProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+type LabelProps = BaseSelect.Label.Props;
+declare const Label: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectLabelProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ArrowProps = BaseSelect.Arrow.Props;
+declare const Arrow: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectArrowProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type TriggerProps = BaseSelect.Trigger.Props;
+declare const Trigger: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectTriggerProps, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+type IconProps = BaseSelect.Icon.Props;
+declare const Icon: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectIconProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+type PositionerProps = BaseSelect.Positioner.Props;
+declare const Positioner: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectPositionerProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type PopupProps = BaseSelect.Popup.Props;
+declare const Popup: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectPopupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ListProps = BaseSelect.List.Props;
+declare const List: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectListProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ItemProps = BaseSelect.Item.Props;
+declare const Item: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectItemProps, "ref"> & React.RefAttributes<HTMLElement>>;
+type ItemTextProps = BaseSelect.ItemText.Props;
+declare const ItemText: React.NamedExoticComponent<Omit<import("@base-ui/react").SelectItemTextProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ItemIndicatorProps = BaseSelect.ItemIndicator.Props;
+declare const ItemIndicator: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectItemIndicatorProps, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+type SeparatorProps = BaseSelect.Separator.Props;
+declare const Separator: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SeparatorProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type GroupProps = BaseSelect.Group.Props;
+declare const Group: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectGroupProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type GroupLabelProps = BaseSelect.GroupLabel.Props;
+declare const GroupLabel: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectGroupLabelProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ScrollUpArrowProps = BaseSelect.ScrollUpArrow.Props;
+declare const ScrollUpArrow: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectScrollUpArrowProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ScrollDownArrowProps = BaseSelect.ScrollDownArrow.Props;
+declare const ScrollDownArrow: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SelectScrollDownArrowProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export type { RootProps, PortalProps, ValueProps, LabelProps, TriggerProps, IconProps, PositionerProps, PopupProps, ListProps, ItemProps, ItemTextProps, ItemIndicatorProps, SeparatorProps, GroupProps, GroupLabelProps, ScrollUpArrowProps, ScrollDownArrowProps, ArrowProps, };
+export { Root, Portal, Value, Label, Trigger, Icon, Positioner, Popup, List, Item, ItemText, ItemIndicator, Separator, Group, GroupLabel, ScrollUpArrow, ScrollDownArrow, Arrow, };

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

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

package/dist/components/slider/slider.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import { Slider as BaseSlider } from '@base-ui/react/slider';
+type SliderOwnProps = {
+    range?: boolean;
+    rangeAnchor?: number;
+    baseValue?: number;
+    hints?: number[];
+};
+type SliderProps = Omit<BaseSlider.Root.Props<number | readonly number[]>, 'children' | 'defaultValue' | 'dir' | 'minStepsBetweenValues' | 'onValueChange' | 'onValueCommitted' | 'thumbAlignment' | 'value'> & SliderOwnProps & {
+    defaultValue?: number[] | undefined;
+    dir?: 'ltr' | 'rtl' | undefined;
+    inverted?: boolean | undefined;
+    minStepsBetweenThumbs?: number | undefined;
+    onValueChange?: ((value: number[]) => void) | undefined;
+    onValueCommit?: ((value: number[]) => void) | undefined;
+    value?: number[] | undefined;
+};
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export type { SliderProps };
+export { Slider };

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

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

package/dist/components/switch/switch.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { Switch as BaseSwitch } from '@base-ui/react/switch';
+type SwitchProps = BaseSwitch.Root.Props;
+declare const Switch: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").SwitchRootProps, "ref"> & React.RefAttributes<HTMLElement>>;
+export type { SwitchProps };
+export { Switch };

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

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

package/dist/components/tabs/tabs.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Tabs as BaseTabs } from '@base-ui/react/tabs';
+type RootProps = BaseTabs.Root.Props;
+declare const Root: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").TabsRootProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type ListProps = BaseTabs.List.Props;
+declare const List: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").TabsListProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+type TabProps = BaseTabs.Tab.Props;
+declare const Tab: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").TabsTabProps, "ref"> & React.RefAttributes<HTMLElement>>;
+type PanelProps = BaseTabs.Panel.Props;
+declare const Panel: React.ForwardRefExoticComponent<Omit<import("@base-ui/react").TabsPanelProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export type { RootProps, ListProps, TabProps, PanelProps };
+export { Root, List, Tab, Panel };

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

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

package/dist/components/text/text.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { useRender } from '@base-ui/react/use-render';
+import type { VariantProps } from 'class-variance-authority';
+declare const text: (props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+    weight?: "strong" | "default" | null | undefined;
+    align?: "center" | "end" | "start" | null | undefined;
+    block?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type TextProps = React.ComponentPropsWithoutRef<'span'> & VariantProps<typeof text> & {
+    render?: useRender.RenderProp | undefined;
+};
+declare const Text: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & VariantProps<(props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+    weight?: "strong" | "default" | null | undefined;
+    align?: "center" | "end" | "start" | null | undefined;
+    block?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & {
+    render?: useRender.RenderProp | undefined;
+} & React.RefAttributes<HTMLSpanElement>>;
+type LabelProps = React.ComponentPropsWithoutRef<'label'> & VariantProps<typeof text>;
+declare const Label: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & VariantProps<(props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+    weight?: "strong" | "default" | null | undefined;
+    align?: "center" | "end" | "start" | null | undefined;
+    block?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLLabelElement>>;
+type ParagraphProps = React.ComponentPropsWithoutRef<'p'> & VariantProps<typeof text>;
+declare const Paragraph: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & VariantProps<(props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+    weight?: "strong" | "default" | null | undefined;
+    align?: "center" | "end" | "start" | null | undefined;
+    block?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & React.RefAttributes<HTMLParagraphElement>>;
+type LinkProps = React.ComponentPropsWithoutRef<'a'> & VariantProps<typeof text> & {
+    render?: useRender.RenderProp | undefined;
+};
+declare const Link: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & VariantProps<(props?: ({
+    size?: "small" | "medium" | "large" | null | undefined;
+    weight?: "strong" | "default" | null | undefined;
+    align?: "center" | "end" | "start" | null | undefined;
+    block?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string> & {
+    render?: useRender.RenderProp | undefined;
+} & React.RefAttributes<HTMLAnchorElement>>;
+export type { TextProps, LabelProps, ParagraphProps, LinkProps };
+export { Text, Label, Paragraph, Link };

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

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

package/dist/components/textarea/textarea.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { TextareaAutosizeProps } from 'react-textarea-autosize';
+type TextareaProps = TextareaAutosizeProps;
+declare const Textarea: React.ForwardRefExoticComponent<TextareaAutosizeProps & React.RefAttributes<HTMLTextAreaElement>>;
+export type { TextareaProps };
+export { Textarea };

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

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

package/dist/components/tooltip/tooltip.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { Tooltip as BaseTooltip } from '@base-ui/react/tooltip';
+type TooltipProviderProps = BaseTooltip.Provider.Props & {
+    disableHoverablePopup?: boolean | undefined;
+};
+declare const TooltipProvider: (props: TooltipProviderProps) => import("react/jsx-runtime").JSX.Element;
+type TooltipPositioningProps = Pick<BaseTooltip.Positioner.Props, 'align' | 'alignOffset' | 'anchor' | 'arrowPadding' | 'collisionAvoidance' | 'collisionBoundary' | 'collisionPadding' | 'disableAnchorTracking' | 'positionMethod' | 'side' | 'sideOffset' | 'sticky'>;
+type TooltipRootProps = Pick<BaseTooltip.Root.Props, 'defaultOpen' | 'disableHoverablePopup' | 'disabled' | 'onOpenChange' | 'onOpenChangeComplete' | 'open' | 'trackCursorAxis'>;
+type TooltipTriggerProps = Pick<BaseTooltip.Trigger.Props, 'closeDelay' | 'closeOnClick' | 'delay'>;
+type TooltipProps = Omit<BaseTooltip.Popup.Props, 'children' | 'content'> & TooltipPositioningProps & TooltipRootProps & TooltipTriggerProps & {
+    children: NonNullable<BaseTooltip.Trigger.Props['render']>;
+    container?: BaseTooltip.Portal.Props['container'] | undefined;
+    content: React.ReactNode;
+    keepMounted?: BaseTooltip.Portal.Props['keepMounted'] | undefined;
+};
+declare const Tooltip: React.ForwardRefExoticComponent<Omit<TooltipProps, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { TooltipProvider, Tooltip };
+export type { TooltipProps, TooltipProviderProps };

package/dist/components/value-field/index.d.ts

@@ -0,0 +1,10 @@
+export { Multi, Root, Label } from './value-field-elements';
+export { Numeric } from './value-field-numeric';
+export { NumericSelect } from './value-field-numeric-select';
+export { Hex } from './value-field-hex';
+export { Scrubber } from './value-field-scrubber';
+export type { MultiProps, RootProps, LabelProps } from './value-field-elements';
+export type { NumericProps } from './value-field-numeric';
+export type { NumericSelectProps } from './value-field-numeric-select';
+export type { HexProps } from './value-field-hex';
+export type { ScrubberProps } from './value-field-scrubber';

package/dist/components/value-field/named-colors.d.ts

@@ -0,0 +1,2 @@
+import type { RGB } from '../../lib/color';
+export declare const namedColors: Record<string, RGB>;

package/dist/components/value-field/types.d.ts

@@ -0,0 +1,15 @@
+type ParserResult<V> = {
+    valid: true;
+    value: V;
+} | {
+    valid: false;
+};
+type IncrementTargets = Record<string, boolean> | null;
+type Formatter<V> = {
+    parse: (input: string, value: V) => ParserResult<V>;
+    format: (value: V) => string;
+    incrementBy?: (value: V, amount: number, incrementTargets: IncrementTargets) => V;
+    getIncrementTargets?: (element: HTMLInputElement) => IncrementTargets;
+    getIncrementSelection?: (incrementTargets: IncrementTargets) => [start: number, end: number];
+};
+export type { IncrementTargets, Formatter, ParserResult };

package/dist/components/value-field/value-field-base.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { InputProps } from '../input';
+import type { Formatter } from './types';
+type BaseProps<V> = Omit<InputProps, 'value' | 'onChange'> & {
+    value: V;
+    onChange: (value: V) => void;
+    inputRef?: React.Ref<HTMLInputElement>;
+    smallNudge?: number;
+    bigNudge?: number;
+    formatter: Formatter<V>;
+};
+declare const Base: {
+    <V>(props: BaseProps<V>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export type { BaseProps };
+export { Base };

package/dist/components/value-field/value-field-elements.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+type ValueFieldScrubTarget = {
+    disabled: boolean;
+    inputRef: React.RefObject<HTMLInputElement>;
+    startScrub: () => void;
+    scrub: (movementX: number, event: PointerEvent) => void;
+};
+type ValueFieldContext = {
+    disabled?: boolean;
+    scrubbing: boolean;
+    scrubTargetsRef: React.MutableRefObject<ValueFieldScrubTarget[]>;
+    registerScrubTarget: (target: ValueFieldScrubTarget | null) => () => void;
+    setScrubbing: (scrubbing: boolean) => void;
+};
+declare const useValueFieldContext: (consumerName: string) => ValueFieldContext | null;
+type RootProps = React.ComponentPropsWithoutRef<'label'> & {
+    disabled?: boolean;
+};
+declare const Root: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, "ref"> & {
+    disabled?: boolean;
+} & React.RefAttributes<HTMLLabelElement>>;
+type MultiProps = React.ComponentPropsWithoutRef<'div'> & {
+    disabled?: boolean;
+};
+declare const Multi: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    disabled?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+type LabelProps = React.ComponentPropsWithoutRef<'span'>;
+declare const Label: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export type { RootProps, LabelProps, MultiProps, ValueFieldContext, ValueFieldScrubTarget };
+export { Root, Label, Multi, useValueFieldContext };

package/dist/components/value-field/value-field-hex.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { RGBA } from '../../lib/color';
+import type { InputProps } from '../input';
+type HexProps = Omit<InputProps, 'value' | 'onChange'> & {
+    /** Color in Figma's normalized RGBA format */
+    value: RGBA;
+    /** Callback to call upon submission. */
+    onChange: (value: RGBA) => void;
+    /**
+     * Ignores the alpha channel in user input, treating it as opaque. Useful when rendering without an alpha field.
+     * Results in 'onChange' always being called with an alpha value of 1.
+     * @default false
+     * */
+    ignoreAlpha?: boolean;
+};
+declare const Hex: React.ForwardRefExoticComponent<Omit<InputProps, "onChange" | "value"> & {
+    /** Color in Figma's normalized RGBA format */
+    value: RGBA;
+    /** Callback to call upon submission. */
+    onChange: (value: RGBA) => void;
+    /**
+     * Ignores the alpha channel in user input, treating it as opaque. Useful when rendering without an alpha field.
+     * Results in 'onChange' always being called with an alpha value of 1.
+     * @default false
+     * */
+    ignoreAlpha?: boolean;
+} & React.RefAttributes<HTMLInputElement>>;
+export type { HexProps };
+export { Hex };

package/dist/components/value-field/value-field-numeric-select.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { NumericProps } from './value-field-numeric';
+type NumericSelectProps = Omit<NumericProps, 'className' | 'style'> & {
+    options: readonly number[];
+    className?: string;
+    style?: React.CSSProperties;
+    triggerLabel?: string;
+};
+declare const NumericSelect: React.ForwardRefExoticComponent<Omit<NumericProps, "className" | "style"> & {
+    options: readonly number[];
+    className?: string;
+    style?: React.CSSProperties;
+    triggerLabel?: string;
+} & React.RefAttributes<HTMLInputElement>>;
+export type { NumericSelectProps };
+export { NumericSelect };

package/dist/components/value-field/value-field-numeric.d.ts

@@ -0,0 +1,62 @@
+import React from 'react';
+import type { InputProps } from '../input';
+type NumericProps = Omit<InputProps, 'value' | 'onChange' | 'min' | 'max' | 'type'> & {
+    /** The numeric value of the input. */
+    value: number;
+    /** Callback to call upon submission. */
+    onChange: (value: number) => void;
+    /** The minimum allowed value. */
+    min?: number;
+    /** The maximum allowed value. */
+    max?: number;
+    /** The numeric range that the `value` prop will be normalized to when displayed in the input.
+     * Requires non-equal 'max' and 'min' values.
+     * @example:
+     * <Numeric value={0.5} min={0} max={1} targetRange={[0, 100]} /> // Displays value of 50
+     * */
+    targetRange?: [number, number];
+    /** The decimal precision that user input will be rounded to. */
+    precision?: number;
+    /** Units that will be accepted as valid input (e.g., "px", "%"). */
+    allowedUnits?: string[];
+    /** Suffix to be appended to the value (e.g., "px", "%"). Suffix is treated as an allowed unit.  */
+    suffix?: string;
+    /** The small nudge increment for the value. */
+    smallNudge?: number;
+    /** The big nudge increment for the value. */
+    bigNudge?: number;
+};
+declare const Numeric: React.ForwardRefExoticComponent<Omit<InputProps, "onChange" | "value" | "max" | "min" | "type"> & {
+    /** The numeric value of the input. */
+    value: number;
+    /** Callback to call upon submission. */
+    onChange: (value: number) => void;
+    /** The minimum allowed value. */
+    min?: number;
+    /** The maximum allowed value. */
+    max?: number;
+    /** The numeric range that the `value` prop will be normalized to when displayed in the input.
+     * Requires non-equal 'max' and 'min' values.
+     * @example:
+     * <Numeric value={0.5} min={0} max={1} targetRange={[0, 100]} /> // Displays value of 50
+     * */
+    targetRange?: [number, number];
+    /** The decimal precision that user input will be rounded to. */
+    precision?: number;
+    /** Units that will be accepted as valid input (e.g., "px", "%"). */
+    allowedUnits?: string[];
+    /** Suffix to be appended to the value (e.g., "px", "%"). Suffix is treated as an allowed unit.  */
+    suffix?: string;
+    /** The small nudge increment for the value. */
+    smallNudge?: number;
+    /** The big nudge increment for the value. */
+    bigNudge?: number;
+} & React.RefAttributes<HTMLInputElement>>;
+declare function evaluateExpression(params: {
+    expression: string;
+    displayValue: number;
+    suffix?: string;
+    allowedUnits?: string[];
+}): number;
+export type { NumericProps };
+export { Numeric, evaluateExpression };

package/dist/components/value-field/value-field-scrubber.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Adapted from Base UI NumberFieldScrubArea.
+ * MIT license, Copyright (c) 2019 Material-UI SAS.
+ * https://github.com/mui/base-ui/blob/master/packages/react/src/number-field/scrub-area/NumberFieldScrubArea.tsx
+ * */
+import React from 'react';
+type ScrubberProps = React.ComponentPropsWithoutRef<'span'> & {
+    /** The number of horizontal pixels the pointer must move before the value changes. */
+    pixelSensitivity?: number;
+    /** Expands the cursor wrap boundary around the scrubber by half this distance on each side. */
+    teleportDistance?: number;
+};
+declare const Scrubber: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref"> & {
+    /** The number of horizontal pixels the pointer must move before the value changes. */
+    pixelSensitivity?: number;
+    /** Expands the cursor wrap boundary around the scrubber by half this distance on each side. */
+    teleportDistance?: number;
+} & React.RefAttributes<HTMLSpanElement>>;
+export type { ScrubberProps };
+export { Scrubber };

package/dist/figma-development-theme.css

@@ -1,6 +1,6 @@
 /**
 * FOR DEVELOPMENT PURPOSES ONLY.
-* Use this file in non-figma plugin environments, e.g. Storybook to ensure base styles and color tokens are accessible to components.
+* Use this file in non-figma plugin environments to ensure base styles and color tokens are accessible to components.
 * This file doesn't need to be imported into Plugin UI.
 * https://www.figma.com/plugin-docs/css-variables/
 */