react-native-system-ui 0.0.1 → 0.0.3

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

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

package/dist/types/components/rate/Rate.d.ts

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

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

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

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

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

package/dist/types/components/safe-area-view/SafeAreaView.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { type LayoutChangeEvent, type StyleProp, type ViewStyle } from 'react-native';
+export interface SafeAreaViewProps {
+    edge?: 'top' | 'bottom';
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+    onLayout?: (event: LayoutChangeEvent) => void;
+    pointerEvents?: 'box-none' | 'none' | 'box-only' | 'auto';
+}
+export declare const SafeAreaView: React.FC<SafeAreaViewProps>;

package/dist/types/components/safe-area-view/index.d.ts

@@ -0,0 +1,2 @@
+export { SafeAreaView } from './SafeAreaView';
+export type { SafeAreaViewProps } from './SafeAreaView';

package/dist/types/components/search/Search.d.ts

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

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

@@ -0,0 +1,4 @@
+import Search from './Search';
+export default Search;
+export { Search };
+export type { SearchProps, SearchRef, SearchShape } from './types';

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

@@ -0,0 +1,40 @@
+import type { TextStyle } from 'react-native';
+import type { SearchShape } from './types';
+export interface SearchTokens {
+    defaults: {
+        shape: SearchShape;
+        clearTrigger: 'always' | 'focus';
+    };
+    colors: {
+        background: string;
+        contentBackground: string;
+        label: string;
+        action: string;
+        icon: string;
+    };
+    spacing: {
+        paddingHorizontal: number;
+        paddingVertical: number;
+        labelGap: number;
+        actionGap: number;
+        contentPaddingHorizontal: number;
+        contentPaddingVertical: number;
+    };
+    radius: {
+        square: number;
+        round: number;
+    };
+    typography: {
+        label: number;
+        labelWeight: NonNullable<TextStyle['fontWeight']>;
+        action: number;
+        actionWeight: NonNullable<TextStyle['fontWeight']>;
+    };
+    opacity: {
+        actionPressed: number;
+    };
+    icon: {
+        size: number;
+    };
+}
+export declare const useSearchTokens: (overrides?: import("../..").DeepPartial<SearchTokens> | undefined) => SearchTokens;

package/dist/types/components/selector/Selector.d.ts

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

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

@@ -0,0 +1,4 @@
+import Selector from './Selector';
+export default Selector;
+export { Selector };
+export type { SelectorProps, SelectorOption, SelectorValue } from './types';

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

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

package/dist/types/components/share-sheet/ShareSheet.d.ts

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

package/dist/types/components/share-sheet/index.d.ts

@@ -0,0 +1,4 @@
+import ShareSheet from './ShareSheet';
+export type { ShareSheetProps, ShareSheetOption, ShareSheetOptions } from './types';
+export { useShareSheetTokens } from './tokens';
+export default ShareSheet;

package/dist/types/components/share-sheet/tokens.d.ts

@@ -0,0 +1,26 @@
+export interface ShareSheetTokens {
+    colors: {
+        background: string;
+        title: string;
+        description: string;
+        option: string;
+        optionDesc: string;
+        border: string;
+        divider: string;
+    };
+    spacing: {
+        horizontal: number;
+        vertical: number;
+        gap: number;
+    };
+    sizing: {
+        icon: number;
+    };
+    typography: {
+        title: number;
+        description: number;
+        option: number;
+        optionDesc: number;
+    };
+}
+export declare const useShareSheetTokens: (overrides?: import("../..").DeepPartial<ShareSheetTokens> | undefined) => ShareSheetTokens;

package/dist/types/components/sidebar/Sidebar.d.ts

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

package/dist/types/components/sidebar/SidebarContext.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface SidebarContextValue {
+    activeIndex: number;
+    onSelect: (index: number) => void;
+}
+export declare const SidebarContext: React.Context<SidebarContextValue | null>;
+export declare const useSidebarContext: () => SidebarContextValue | null;

package/dist/types/components/sidebar/SidebarItem.d.ts

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

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

@@ -0,0 +1,8 @@
+import SidebarItem from './SidebarItem';
+export type { SidebarProps, SidebarItemProps } from './types';
+export { useSidebarTokens } from './tokens';
+declare const Sidebar: import("react").FC<import("./types").SidebarProps> & {
+    Item: import("react").FC<import("./types").SidebarItemProps>;
+};
+export { SidebarItem };
+export default Sidebar;

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

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

package/dist/types/components/skeleton/Skeleton.d.ts

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

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

@@ -0,0 +1,5 @@
+import Skeleton from './Skeleton';
+export type { SkeletonProps, SkeletonAvatarShape } from './types';
+export { useSkeletonTokens } from './tokens';
+export default Skeleton;
+export { Skeleton };

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

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

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

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

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

@@ -0,0 +1,3 @@
+import { Slider } from './Slider';
+export type { SliderProps, SliderValue } from './types';
+export default Slider;

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;