react-native-system-ui 0.0.1 → 0.0.2

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

@@ -0,0 +1,28 @@
+export interface SliderTokens {
+    track: {
+        height: number;
+        radius: number;
+    };
+    thumb: {
+        size: number;
+        indicatorSize: number;
+        elevation: number;
+    };
+    colors: {
+        active: string;
+        inactive: string;
+        thumbBackground: string;
+        thumbIndicator: string;
+    };
+    spacing: {
+        containerPaddingVertical: number;
+    };
+    layout: {
+        verticalMinHeight: number;
+        verticalWidth: number;
+    };
+    states: {
+        disabledOpacity: number;
+    };
+}
+export declare const useSliderTokens: (overrides?: import("../..").DeepPartial<SliderTokens> | undefined) => SliderTokens;

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

@@ -0,0 +1,42 @@
+import type { GestureResponderEvent } from 'react-native';
+import React from 'react';
+import { View } from 'react-native';
+import type { SliderValue } from './types';
+export type TrackLayout = {
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+};
+export declare const clampValue: (value: number | undefined, min: number, max: number) => number;
+export declare const isSameLayout: (a: TrackLayout, b: TrackLayout) => boolean;
+export declare const normalizeValue: (value: SliderValue | undefined, range: boolean, min: number, max: number) => number[];
+export declare const toSliderValue: (values: readonly number[], range: boolean, fallback: number) => SliderValue;
+export declare const createAccessibilityProps: (inputProps?: {
+    role?: string;
+    ["aria-value"]?: unknown;
+    accessibilityActions?: unknown;
+    onAccessibilityAction?: unknown;
+    disabled?: boolean;
+} | null) => {
+    accessible?: undefined;
+    accessibilityRole?: undefined;
+    accessibilityValue?: undefined;
+    accessibilityActions?: undefined;
+    onAccessibilityAction?: undefined;
+    accessibilityState?: undefined;
+} | {
+    accessible: boolean;
+    accessibilityRole: string;
+    accessibilityValue: unknown;
+    accessibilityActions: unknown;
+    onAccessibilityAction: unknown;
+    accessibilityState: {
+        disabled: boolean | undefined;
+    };
+};
+export declare const defaultNumberFormatter: Intl.NumberFormat;
+export type PressableLikeEvent = GestureResponderEvent & {
+    preventDefault?: () => void;
+};
+export type HandlerBag = Record<string, unknown> & Partial<React.ComponentProps<typeof View>>;

package/dist/types/components/space/Space.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { SpaceProps } from './types';
+export declare const Space: React.MemoExoticComponent<(props: SpaceProps) => React.JSX.Element>;

package/dist/types/components/space/index.d.ts

@@ -0,0 +1,3 @@
+export { Space as default } from './Space';
+export { Space } from './Space';
+export type { SpaceAlign, SpaceDirection, SpaceGap, SpaceJustify, SpaceProps, SpaceSizePreset } from './types';

package/dist/types/components/space/tokens.d.ts

@@ -0,0 +1,3 @@
+import type { SpaceGap, SpaceSizePreset, SpaceTokens } from './types';
+export declare const useSpaceTokens: (overrides?: import("../..").DeepPartial<SpaceTokens> | undefined) => SpaceTokens;
+export declare const resolveGapInput: (gap?: SpaceGap, size?: SpaceGap | SpaceSizePreset, fallback?: SpaceSizePreset) => string | number | [string | number, string | number];

package/dist/types/components/stepper/Stepper.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { StepperInstance, StepperProps } from './types';
+export declare const Stepper: React.ForwardRefExoticComponent<StepperProps & React.RefAttributes<StepperInstance>>;
+export default Stepper;

package/dist/types/components/stepper/index.d.ts

@@ -0,0 +1,4 @@
+import Stepper from './Stepper';
+export default Stepper;
+export { Stepper };
+export type { StepperProps, StepperTheme, StepperInstance } from './types';

package/dist/types/components/stepper/tokens.d.ts

@@ -0,0 +1,43 @@
+import { type TextStyle } from 'react-native';
+import type { StepperTheme } from './types';
+export interface StepperTokens {
+    defaults: {
+        theme: StepperTheme;
+        showInput: boolean;
+        showPlus: boolean;
+        showMinus: boolean;
+        longPress: boolean;
+        inputWidth: number;
+        buttonSize: number;
+    };
+    colors: {
+        active: string;
+        background: string;
+        buttonIcon: string;
+        buttonDisabledBackground: string;
+        buttonDisabledIcon: string;
+        roundTheme: string;
+        roundThemeText: string;
+        roundThemeBackground: string;
+        inputText: string;
+        inputDisabledText: string;
+        inputDisabledBackground: string;
+    };
+    radii: {
+        default: number;
+    };
+    typography: {
+        fontSize: number;
+        fontWeight: TextStyle['fontWeight'];
+    };
+    opacity: {
+        disabled: number;
+        roundDisabled: number;
+        pressed: number;
+    };
+    spacing: {
+        gap: number;
+    };
+}
+export declare const useStepperTokens: (overrides?: import("../..").DeepPartial<StepperTokens> | undefined) => StepperTokens;
+export type { StepperTheme };

package/dist/types/components/swiper/Swiper.d.ts

@@ -0,0 +1,7 @@
+import { type ReactElement, type RefAttributes } from 'react';
+import type { SwiperProps, SwiperInstance } from './types';
+type SwiperComponent = (<T>(props: SwiperProps<T> & RefAttributes<SwiperInstance>) => ReactElement | null) & {
+    displayName?: string;
+};
+declare const Swiper: SwiperComponent;
+export default Swiper;

package/dist/types/components/swiper/SwiperItem.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { View } from 'react-native';
+import type { SwiperItemProps } from './types';
+declare const SwiperItem: React.ForwardRefExoticComponent<SwiperItemProps & React.RefAttributes<View>>;
+export default SwiperItem;

package/dist/types/components/swiper/SwiperPagIndicator.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import { type StyleProp, type ViewStyle, type ViewProps } from 'react-native';
+import type { DeepPartial } from '../../types';
+export interface SwiperPagIndicatorTokens {
+    colors: {
+        active: string;
+        inactive: string;
+    };
+    sizing: {
+        dotSizeActive: number;
+        dotSizeInactive: number;
+    };
+    spacing: {
+        dotMargin: number;
+    };
+    offset: {
+        horizontalBottom: number;
+        verticalRight: number;
+    };
+    layer: {
+        zIndex: number;
+        elevation: number;
+    };
+}
+export declare const useSwiperPagIndicatorTokens: (overrides?: DeepPartial<SwiperPagIndicatorTokens> | undefined) => SwiperPagIndicatorTokens;
+export interface SwiperPagIndicatorProps extends ViewProps {
+    total: number;
+    current: number;
+    vertical?: boolean;
+    style?: StyleProp<ViewStyle>;
+    activeColor?: string;
+    inactiveColor?: string;
+    tokensOverride?: DeepPartial<SwiperPagIndicatorTokens>;
+}
+declare const SwiperPagIndicator: React.NamedExoticComponent<SwiperPagIndicatorProps>;
+export default SwiperPagIndicator;

package/dist/types/components/swiper/index.d.ts

@@ -0,0 +1,14 @@
+import Swiper from './Swiper';
+import SwiperItem from './SwiperItem';
+import SwiperPagIndicator from './SwiperPagIndicator';
+declare const SwiperWithItem: (<T>(props: import("./types").SwiperProps<T> & import("react").RefAttributes<import("./types").SwiperInstance>) => import("react").ReactElement | null) & {
+    displayName?: string;
+} & {
+    Item: import("react").ForwardRefExoticComponent<import("./types").SwiperItemProps & import("react").RefAttributes<import("react-native").View>>;
+    PagIndicator: import("react").NamedExoticComponent<import("./SwiperPagIndicator").SwiperPagIndicatorProps>;
+};
+export default SwiperWithItem;
+export { Swiper, SwiperItem, SwiperPagIndicator };
+export { useSwiperPagIndicatorTokens } from './SwiperPagIndicator';
+export type { SwiperPagIndicatorProps, SwiperPagIndicatorTokens } from './SwiperPagIndicator';
+export type { SwiperProps, SwiperInstance, SwiperItemProps } from './types';

package/dist/types/components/swiper/useSwiperWeb.d.ts

@@ -0,0 +1,41 @@
+import { type MutableRefObject } from 'react';
+import { Animated } from 'react-native';
+interface UseSwiperWebParams {
+    isWeb: boolean;
+    enabledState: boolean;
+    touchable: boolean;
+    vertical: boolean;
+    count: number;
+    shouldLoop: boolean;
+    displayCount: number;
+    slideSizeValue: number;
+    nonLoopMinOffset: number;
+    nonLoopMaxOffset: number;
+    durationMs: number;
+    preventScroll: boolean;
+    trackOffsetPx: number;
+    swipeToRef: MutableRefObject<(index: number, animated?: boolean) => void>;
+    onDragStart?: () => void;
+    onDragEnd?: () => void;
+}
+export declare const useSwiperWeb: ({ isWeb, enabledState, touchable, vertical, count, shouldLoop, displayCount, slideSizeValue, nonLoopMinOffset, nonLoopMaxOffset, durationMs, preventScroll, trackOffsetPx, swipeToRef, onDragStart, onDragEnd, }: UseSwiperWebParams) => {
+    webOffsetRef: import("react").RefObject<number>;
+    webTranslateXAnim: Animated.Value;
+    webTranslateYAnim: Animated.Value;
+    webTrackTransform: ({
+        translateY: number;
+    } | {
+        translateY: Animated.Value;
+    })[] | ({
+        translateX: number;
+    } | {
+        translateX: Animated.Value;
+    })[];
+    panResponder: import("react-native").PanResponderInstance | null;
+    stopWebSnapAnim: () => void;
+    cancelWebRaf: () => void;
+    flushWebTranslate: () => void;
+    scheduleWebTranslate: (next: number) => void;
+    webSnapAnimRef: import("react").RefObject<Animated.CompositeAnimation | null>;
+};
+export {};

package/dist/types/components/swiper/utils.d.ts

@@ -0,0 +1,17 @@
+import type { SwiperProps } from './types';
+export declare const FALLBACK_WIDTH = 375;
+export declare const FALLBACK_HEIGHT = 667;
+export declare const runAfterFrames: (frames: number, fn: () => void) => void;
+export type WebCancelableEvent = {
+    preventDefault?: () => void;
+    stopPropagation?: () => void;
+    nativeEvent?: {
+        preventDefault?: () => void;
+        stopPropagation?: () => void;
+    };
+};
+export declare const stopWebEvent: (event: WebCancelableEvent) => void;
+export declare const getInitialSwipeValue: (initialSwipe: SwiperProps["initialSwipe"]) => number;
+export declare const getDurationMs: (duration: SwiperProps["duration"]) => number;
+export declare const getSlideSizePct: (slideSize: SwiperProps["slideSize"]) => number;
+export declare const getTrackOffsetPct: (trackOffset: SwiperProps["trackOffset"]) => number;

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

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { SwitchProps } from './types';
+type SwitchComponent = (<V = boolean>(props: SwitchProps<V>) => React.ReactElement) & {
+    displayName?: string;
+};
+export declare const Switch: SwitchComponent;
+export default Switch;

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

@@ -0,0 +1,4 @@
+import Switch from './Switch';
+export default Switch;
+export { Switch };
+export type { SwitchProps } from './types';

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

@@ -0,0 +1,2 @@
+import type { SwitchTokens } from './types';
+export declare const useSwitchTokens: (overrides?: import("../..").DeepPartial<SwitchTokens> | undefined) => SwitchTokens;

package/dist/types/components/tabbar/Tabbar.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { TabbarProps } from './types';
+declare const TabbarBase: React.FC<TabbarProps>;
+export default TabbarBase;

package/dist/types/components/tabbar/TabbarContext.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import type { TextStyle } from 'react-native';
+import type { TabbarValue } from './types';
+export interface TabbarContextValue {
+    activeValue?: TabbarValue;
+    activeColor: string;
+    inactiveColor: string;
+    fontSize: number;
+    fontWeight: TextStyle['fontWeight'];
+    onSelect: (name: TabbarValue, index: number) => void;
+}
+export declare const TabbarContext: React.Context<TabbarContextValue | null>;
+export declare const useTabbarContext: () => TabbarContextValue | null;

package/dist/types/components/tabbar/TabbarItem.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { TabbarItemProps } from './types';
+declare const TabbarItem: React.FC<TabbarItemProps>;
+export default TabbarItem;

package/dist/types/components/tabbar/index.d.ts

@@ -0,0 +1,9 @@
+import TabbarBase from './Tabbar';
+import TabbarItem from './TabbarItem';
+export type { TabbarProps, TabbarItemProps, TabbarValue } from './types';
+export { useTabbarTokens } from './tokens';
+declare const Tabbar: typeof TabbarBase & {
+    Item: typeof TabbarItem;
+};
+export { TabbarItem };
+export default Tabbar;

package/dist/types/components/tabbar/tokens.d.ts

@@ -0,0 +1,28 @@
+import type { TextStyle } from 'react-native';
+export interface TabbarTokens {
+    defaults: {
+        fixed: boolean;
+        border: boolean;
+        placeholder: boolean;
+        safeAreaInsetBottom: boolean;
+    };
+    colors: {
+        background: string;
+        border: string;
+        active: string;
+        inactive: string;
+    };
+    layout: {
+        height: number;
+        paddingHorizontal: number;
+        paddingVertical: number;
+    };
+    icon: {
+        size: number;
+    };
+    typography: {
+        fontSize: number;
+        fontWeight: TextStyle['fontWeight'];
+    };
+}
+export declare const useTabbarTokens: (overrides?: import("../..").DeepPartial<TabbarTokens> | undefined) => TabbarTokens;

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

@@ -0,0 +1,4 @@
+import { type FC } from 'react';
+import type { TabPaneProps } from './types';
+declare const TabPane: FC<TabPaneProps>;
+export default TabPane;

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

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { TabsProps, TabsRef } from './types';
+declare const TabsBase: React.ForwardRefExoticComponent<TabsProps & React.RefAttributes<TabsRef>>;
+export default TabsBase;

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

@@ -0,0 +1,8 @@
+import TabPane from './TabPane';
+export type { TabsProps, TabPaneProps, TabsValue, TabsType, TabsAlign, TabsSwipeableConfig, TabsRef, } from './types';
+export { useTabsTokens } from './tokens';
+declare const Tabs: import("react").ForwardRefExoticComponent<import("./types").TabsProps & import("react").RefAttributes<import("./types").TabsRef>> & {
+    TabPane: import("react").FC<import("./types").TabPaneProps>;
+};
+export { TabPane };
+export default Tabs;

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

@@ -0,0 +1,87 @@
+import type { TextStyle } from 'react-native';
+import type { TabsAlign, TabsType } from './types';
+export interface TabsTokens {
+    defaults: {
+        type: TabsType;
+        align: TabsAlign;
+        ellipsis: boolean;
+        swipeThreshold: number;
+        animated: boolean;
+        duration: number;
+        lazyRender: boolean;
+    };
+    colors: {
+        text: string;
+        textActive: string;
+        textDisabled: string;
+        description: string;
+        descriptionActive: string;
+        descriptionBackground: string;
+        descriptionActiveBackground: string;
+        border: string;
+        indicator: string;
+        cardBackground: string;
+        cardActiveBackground: string;
+        cardBorder: string;
+        cardActiveBorder: string;
+        cardActiveText: string;
+        capsuleBackground: string;
+        capsuleActiveBackground: string;
+        capsuleBorder: string;
+        capsuleActiveBorder: string;
+        capsuleText: string;
+        capsuleActiveText: string;
+        badgeText: string;
+        jumboBackground: string;
+        jumboActiveBackground: string;
+        jumboBorder: string;
+        jumboActiveBorder: string;
+        jumboDescription: string;
+        jumboDescriptionActive: string;
+        jumboDescriptionBackground: string;
+        jumboDescriptionActiveBackground: string;
+    };
+    tabList: {
+        height: number;
+        paddingHorizontal: number;
+        paddingVertical: number;
+        paddingBottom: number;
+        background: string;
+    };
+    typography: {
+        titleSize: number;
+        titleWeight: NonNullable<TextStyle['fontWeight']>;
+        titleActiveWeight: NonNullable<TextStyle['fontWeight']>;
+        descriptionSize: number;
+        jumboTitleSize: number;
+        jumboLineHeight: number;
+    };
+    indicator: {
+        height: number;
+        radius: number;
+        width: number;
+        offset: number;
+    };
+    card: {
+        radius: number;
+        paddingHorizontal: number;
+        paddingVertical: number;
+        height: number;
+        marginHorizontal: number;
+    };
+    capsule: {
+        radius: number;
+        paddingHorizontal: number;
+        paddingVertical: number;
+    };
+    jumbo: {
+        radius: number;
+        paddingHorizontal: number;
+        paddingVertical: number;
+        height: number;
+        descriptionPaddingHorizontal: number;
+        descriptionPaddingVertical: number;
+        descriptionRadius: number;
+    };
+}
+export declare const useTabsTokens: (overrides?: import("../..").DeepPartial<TabsTokens> | undefined) => TabsTokens;

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

@@ -0,0 +1,30 @@
+import { type MutableRefObject } from 'react';
+import { Animated } from 'react-native';
+import type { TabsValue } from './types';
+interface UseTabsAnimationParams {
+    type: 'line' | 'card' | 'jumbo' | 'capsule';
+    animated: boolean;
+    scrollable: boolean;
+    align: 'start' | 'center' | 'end';
+    panes: Array<{
+        name: TabsValue;
+        index: number;
+    }>;
+    nameIndexMap: Map<TabsValue, number>;
+    resolvedLineWidth?: number;
+    resolvedLineHeight: number;
+    resolvedDuration: number;
+    currentName?: TabsValue | null;
+    layoutMap: MutableRefObject<Map<TabsValue, {
+        x: number;
+        width: number;
+    }>>;
+    navContainerWidthRef: MutableRefObject<number>;
+}
+export declare const useTabsAnimation: ({ type, animated, scrollable, align, panes, nameIndexMap, resolvedLineWidth, resolvedDuration, currentName, layoutMap, navContainerWidthRef, }: UseTabsAnimationParams) => {
+    indicatorX: Animated.Value;
+    indicatorWidth: Animated.Value;
+    indicatorInitializedRef: import("react").RefObject<boolean>;
+    animateIndicator: (name?: TabsValue, immediate?: boolean) => boolean;
+};
+export {};

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

@@ -0,0 +1,23 @@
+import { type MutableRefObject } from 'react';
+import { Animated, ScrollView, type NativeSyntheticEvent, type NativeScrollEvent } from 'react-native';
+import type { TabsValue } from './types';
+interface UseTabsScrollParams {
+    scrollable: boolean;
+    animated: boolean;
+    currentName?: TabsValue | null;
+    resolvedDuration: number;
+    layoutMap: MutableRefObject<Map<TabsValue, {
+        x: number;
+        width: number;
+    }>>;
+    navContainerWidthRef: MutableRefObject<number>;
+    navContentWidthRef: MutableRefObject<number>;
+}
+export declare const useTabsScroll: ({ scrollable, animated, currentName, resolvedDuration, layoutMap, navContainerWidthRef, navContentWidthRef, }: UseTabsScrollParams) => {
+    navScrollRef: import("react").RefObject<ScrollView | null>;
+    navScrollX: Animated.Value;
+    scrollIntoView: (immediate?: boolean) => void;
+    handleNavScrollBeginDrag: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+    handleNavScroll: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
+};
+export {};

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { TabPaneProps } from './types';
+export declare const requestFrame: (cb: (time?: number) => void) => number;
+export declare const cancelFrame: (id: number | null) => void;
+export declare const isTabPaneElement: (child: React.ReactNode) => child is React.ReactElement<TabPaneProps>;

package/dist/types/components/tag/Tag.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { TagProps } from './types';
+export declare const Tag: React.FC<TagProps>;

package/dist/types/components/tag/index.d.ts

@@ -0,0 +1,3 @@
+import { Tag } from './Tag';
+export type { TagProps, TagSize, TagType } from './types';
+export default Tag;

package/dist/types/components/tag/tokens.d.ts

@@ -0,0 +1,4 @@
+import type { Foundations } from '../../design-system/tokens';
+import type { TagTokens } from './types';
+export declare const createTagTokens: (foundations: Foundations) => TagTokens;
+export declare const useTagTokens: (overrides?: import("../..").DeepPartial<TagTokens> | undefined) => TagTokens;

package/dist/types/components/toast/Toast.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import { type StyleProp, type TextStyle, type ViewStyle } from 'react-native';
+import type { LoadingType } from '../loading';
+import type { DeepPartial } from '../../types';
+import type { ToastTokens } from './tokens';
+export type ToastPosition = 'top' | 'middle' | 'bottom';
+export type ToastType = 'info' | 'success' | 'fail' | 'loading';
+export interface ToastProps {
+    visible: boolean;
+    message?: React.ReactNode;
+    icon?: React.ReactNode;
+    type?: ToastType;
+    iconSize?: number;
+    loadingType?: LoadingType;
+    duration?: number;
+    position?: ToastPosition;
+    forbidClick?: boolean;
+    overlay?: boolean;
+    overlayStyle?: StyleProp<ViewStyle>;
+    closeOnClickOverlay?: boolean;
+    closeOnClick?: boolean;
+    loadingIndicator?: React.ReactNode;
+    /** 内容顶部是否预留安全区域（默认根据 position 自动设置，设置为 false 可全屏显示） */
+    safeAreaInsetTop?: boolean;
+    /** 内容底部是否预留安全区域（默认根据 position 自动设置，设置为 false 可全屏显示） */
+    safeAreaInsetBottom?: boolean;
+    tokensOverride?: DeepPartial<ToastTokens>;
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    onClose?: () => void;
+    onOpen?: () => void;
+    onOpened?: () => void;
+    onClosed?: () => void;
+}
+export declare const Toast: React.FC<ToastProps>;
+export default Toast;

package/dist/types/components/toast/imperative.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { type ToastProps, type ToastType } from './Toast';
+export type ToastShowOptions = Omit<ToastProps, 'visible'> & {
+    message?: React.ReactNode;
+};
+export type ToastInput = ToastShowOptions | React.ReactNode;
+export interface ToastReturnType {
+    clear: () => void;
+    update: (options: ToastInput) => void;
+    config: (options: ToastInput | ((prev: ToastShowOptions) => ToastInput)) => void;
+}
+export declare const ToastImperative: {
+    show: (options?: ToastInput) => ToastReturnType;
+    info: (options?: ToastInput) => ToastReturnType;
+    success: (options?: ToastInput) => ToastReturnType;
+    fail: (options?: ToastInput) => ToastReturnType;
+    loading: (options?: ToastInput) => ToastReturnType;
+    clear: () => void;
+    allowMultiple: (value?: boolean) => void;
+    setDefaultOptions: (typeOrOptions: ToastType | ToastShowOptions, options?: ToastShowOptions) => void;
+    resetDefaultOptions: (type?: ToastType) => void;
+};

package/dist/types/components/toast/index.d.ts

@@ -0,0 +1,15 @@
+declare const Toast: import("react").FC<import("./Toast").ToastProps> & {
+    show: (options?: import("./imperative").ToastInput) => import("./imperative").ToastReturnType;
+    info: (options?: import("./imperative").ToastInput) => import("./imperative").ToastReturnType;
+    success: (options?: import("./imperative").ToastInput) => import("./imperative").ToastReturnType;
+    fail: (options?: import("./imperative").ToastInput) => import("./imperative").ToastReturnType;
+    loading: (options?: import("./imperative").ToastInput) => import("./imperative").ToastReturnType;
+    clear: () => void;
+    allowMultiple: (value?: boolean) => void;
+    setDefaultOptions: (typeOrOptions: import("./Toast").ToastType | import("./imperative").ToastShowOptions, options?: import("./imperative").ToastShowOptions) => void;
+    resetDefaultOptions: (type?: import("./Toast").ToastType) => void;
+};
+export type { ToastProps, ToastPosition, ToastType } from './Toast';
+export type { ToastShowOptions, ToastInput, ToastReturnType } from './imperative';
+export default Toast;
+export { Toast };

package/dist/types/components/toast/tokens.d.ts

@@ -0,0 +1,24 @@
+import { type Foundations } from '../../design-system/tokens';
+import type { ToastType } from './Toast';
+export interface ToastTokens {
+    colors: {
+        text: string;
+        backdrop: string;
+        variants: Record<ToastType, string>;
+    };
+    fontSize: number;
+    lineHeight: number;
+    radius: number;
+    gap: number;
+    iconSize: number;
+    maxWidth: number | string;
+    textMinWidth: number;
+    textPaddingVertical: number;
+    textPaddingHorizontal: number;
+    defaultPadding: number;
+    defaultWidth: number;
+    defaultMinHeight: number;
+    animationDuration: number;
+}
+export declare const createToastTokens: (foundations: Foundations) => ToastTokens;
+export declare const useToastTokens: (overrides?: import("../..").DeepPartial<ToastTokens> | undefined) => ToastTokens;