@codeleap/mobile 6.3.0 → 6.8.0

package/src/components/SortablePhotos/useSortablePhotos.ts

@@ -1,4 +1,4 @@
-import { alert } from '@codeleap/modals'
+import { alert } from '@codeleap/portals'
 import { useEffect, useMemo, useState } from '@codeleap/hooks'
 import { FileInputImageSource, useFileInput } from '../FileInput'
 import { SortablePhoto, SortablePhotosProps, WithId } from './types'
@@ -30,6 +30,11 @@ export const useSortablePhotos = <T extends SortablePhoto>(props: SortablePhotos
     onChangePhotos(newPhotos)
   }
 
+  /**
+   * Runs only when `loading` transitions to false so the grid initialises with the full fixed
+   * number of slots (real photos + empty placeholders) in a single synchronous commit, avoiding
+   * a visible layout jump that would occur if empty slots were appended separately.
+   */
   useEffect(() => {
     if (!loading && data?.length < numPhotos) {
       const currentLength = currentPhotos?.length ?? 0
@@ -43,6 +48,7 @@ export const useSortablePhotos = <T extends SortablePhoto>(props: SortablePhotos
     }
   }, [loading])
 
+  /** Drag-and-drop is disabled when only one photo is filled; there is nothing meaningful to reorder. */
   const { emptyIndexes, numberPhotosMissing, enabledDragDrop } = useMemo(() => {
     const copyPhotos = [...data]
 
@@ -68,6 +74,11 @@ export const useSortablePhotos = <T extends SortablePhoto>(props: SortablePhotos
     return photos.map((photo, idx) => ({ ...photo, order: idx }))
   }
 
+  /**
+   * After a drag the Sortable.Grid emits all slots in their new visual order, including empty
+   * slots. This re-packs filled photos to the front while preserving the per-slot `key` values
+   * so the grid layout stays stable and empty slots don't accumulate at random positions.
+   */
   const sortPhotos = (_unorderedPhotos: WithId<T>[]) => {
     const unorderedPhotos = [..._unorderedPhotos]
 

package/src/components/Switch/index.tsx

@@ -84,6 +84,7 @@ export const Switch = (props: SwitchProps) => {
     dependencies: [inputValue, disabled],
   })
 
+  /** Same `__props` escape-hatch as Checkbox/RadioGroup — lets the style variant set the default side without requiring a prop at every call site. */
   // @ts-expect-error
   const _switchOnLeft = switchOnLeft ?? styles?.__props?.switchOnLeft
 

package/src/components/Tabs/Context.tsx

@@ -3,6 +3,11 @@ import { TabsContextProps, TabsStyles } from './types'
 import { FlatList } from 'react-native'
 import { TypeGuards } from '@codeleap/types'
 
+/**
+ * Uncontrolled mode (neither `value` nor `onValueChange` provided) uses internal `useState`;
+ * partial control (only one of the two) is not supported — if `onValueChange` is supplied
+ * without `value`, the value falls back to `defaultValue` and won't reflect external updates.
+ */
 function useTabHandle(props: TabsContextProps & { styles: TabsStyles }) {
   const {
     defaultValue,

package/src/components/Tabs/Panel.tsx

@@ -19,6 +19,11 @@ const PanelMemoized = memoBy((props: TabPropsWithCtx<PanelProps>) => {
   return <>{children}</>
 }, ['children', 'styles'])
 
+/**
+ * Inactive panels are hidden via `display: 'none'` rather than unmounted, so their state is
+ * preserved across tab switches when `keepMounted` is true. Set `keepMounted={false}` at the
+ * Tabs or Panel level to unmount inactive panels and reclaim memory at the cost of re-mounting.
+ */
 export const Panel = ({ keepMounted: panelKeepMounted = true, ...props }: PanelProps) => {
   const { value, styles, keepMounted } = useTabContext()
 

package/src/components/Tabs/TabList.tsx

@@ -4,6 +4,11 @@ import React from 'react'
 
 type TabListProps = Omit<FlatListProps<any>, 'data' | 'renderItem'>
 
+/**
+ * Tab children are passed as JSX children (not a `data` array), converted via
+ * `React.Children.toArray` and fed into a horizontal FlatList. The FlatList ref is shared from
+ * context so `Tab` can programmatically scroll to the active tab on selection.
+ */
 export const TabList = (props: TabListProps) => {
   const { children, ...flatListProps } = props
 

package/src/components/Text/index.tsx

@@ -26,6 +26,9 @@ export const Text = forwardRef<NativeText, TextProps>((textProps, ref) => {
     ...textProps,
   }
 
+  // On iOS, RN Text renders a highlight on tap by default; suppressHighlighting must be true to
+  // opt into the custom pressFeedback color animation. Android always uses the polyfill because
+  // it has no native text-press highlight at all.
   const pressPolyfillEnabled = Platform.select({
     ios: props.suppressHighlighting,
     android: true,
@@ -107,6 +110,8 @@ Text.withVariantTypes = <S extends AnyRecord>(styles: S) => {
   return Text as (props: StyledComponentProps<TextProps, typeof styles>) => IJSX
 }
 
+/** Default debounce is 1000 ms — longer than Touchable's 500 ms — because double-tap on a
+ *  pressable Text is harder to perceive and native tap coalescing on Text is unreliable. */
 Text.defaultProps = {
   debounce: 1000,
 } as Partial<TextProps>

package/src/components/Text/types.ts

@@ -11,7 +11,9 @@ export type TextProps =
     animated?: boolean
     colorChangeConfig?: Partial<Animated.TimingAnimationConfig>
     debugName?: string
+    /** Milliseconds to lock out repeat presses. Defaults to 1000. Set to `undefined` to disable. */
     debounce?: number
+    /** Keeps `onPress` wired while visually and semantically disabling the press — useful when a parent needs to intercept taps. */
     pressDisabled?: boolean
     style?: StyledProp<TextComposition>
     animatedStyle?: AnimatedStyle<ViewStyle | ImageStyle | TextStyle>

package/src/components/TextInput/index.tsx

@@ -72,12 +72,14 @@ export const TextInput = forwardRef<NativeTextInput, TextInputProps>((props, ref
     } as NativeTextInput
   })
   
+  /** Swaps the underlying element to the masked variant; the ref forwarding also changes — `refInput` is used instead of `ref` because MaskedTextInput does not forward refs the standard way. */
   const InputElement = masking ? MaskedTextInput : NativeTextInput
 
   const isPressable = TypeGuards.isFunction(onPress)
 
   const isDisabled = !!inputBaseProps.disabled
 
+  /** `placeholderTextColor` and `selectionColor` are scalar RN props that cannot accept style arrays, so their colors are extracted as plain values here rather than in the style array passed to the element. */
   const partialStyles = useInputBasePartialStyles(styles, ['placeholder', 'selection'], {
     disabled: isDisabled,
     error: !!hasError,
@@ -103,6 +105,7 @@ export const TextInput = forwardRef<NativeTextInput, TextInputProps>((props, ref
     onChangeText: onInputValueChange,
   }
 
+  /** When `onPress` is supplied the input acts as a button: editing and the caret are disabled so the native keyboard never opens, and `pointerEvents="none"` prevents touch from reaching the input itself. */
   const buttonModeProps = isPressable ? {
     editable: false,
     caretHidden: true,

package/src/components/TextInput/useTextInput.ts

@@ -57,12 +57,15 @@ export function useTextInput(props: Partial<TextInputProps>) {
 
   const handleFocus = useCallback((e: NativeSyntheticEvent<TextInputFocusEventData>) => {
     setIsFocused(true)
+    /** `null` selection lets RN restore the cursor to wherever the user tapped; it is reset to `selectionStart` on blur to keep a predictable resting position. */
     if (autoAdjustSelection) setCurrentSelection(null)
     onFocus?.(e)
+    /** Close any open InputOverlay (e.g. dropdowns, pickers) when the keyboard appears to avoid overlap. */
     inputOverlayManager.closeAll()
   }, [onFocus])
 
   const handleMaskChange = useCallback((masked, unmasked) => {
+    /** `saveFormatted` branch currently stores `masked` in both cases — the `unmasked` path is a known placeholder and not yet wired up. */
     onInputValueChange(masking?.saveFormatted ? masked : masked)
     if (onChangeMask) onChangeMask(masked, unmasked)
   }, [masking?.saveFormatted, onChangeMask])

package/src/components/TimeInput/index.tsx

@@ -14,6 +14,11 @@ import { InputOverlay, inputOverlayManager } from '../InputOverlay'
 export * from './styles'
 export * from './types'
 
+/**
+ * The picker is always rendered in `mode='time'` and `theme='light'` regardless of system theme;
+ * dark mode is not forwarded to the native `react-native-date-picker` wheel.
+ * Default format `'hh:mm A'` is 12-hour with AM/PM — pass `format='HH:mm'` for 24-hour display.
+ */
 export const TimeInput = (props: TimeInputProps) => {
   const {
     style,

package/src/components/Touchable/index.tsx

@@ -37,6 +37,8 @@ export const Touchable = forwardRef<RNView, TouchableProps>((touchableProps, ref
     ...touchableProps,
   }
 
+  // Start locked when leadingDebounce is true so the very first render is immune to ghost taps
+  // (e.g. a list item that mounts directly under the user's finger on Android).
   const pressed = React.useRef(!!leadingDebounce)
 
   onMount(() => {
@@ -103,6 +105,9 @@ export const Touchable = forwardRef<RNView, TouchableProps>((touchableProps, ref
 
   const Wrapper = View
 
+  // Style properties are split between the outer View (wrapperStyle) and the inner Pressable/Ripple
+  // (pressableStyle) so that margin/position are owned by the layout parent while the pressable
+  // touch area matches the visual surface. Radius is copied to both so clipping stays consistent.
   const { radiusStyle, wrapperStyle, pressableStyle } = React.useMemo(() => {
     const wrapperkeys = [
       'margin',
@@ -181,6 +186,7 @@ export const Touchable = forwardRef<RNView, TouchableProps>((touchableProps, ref
     bottom: props.hitSlop,
   } as Insets : props.hitSlop
 
+  // Ripple is Android-only; iOS uses Pressable's built-in opacity/color feedback via getFeedbackStyle.
   const disableRipple = disableFeedback || rippleDisabled || Platform.OS !== 'android'
 
   return (

package/src/components/Touchable/types.ts

@@ -13,8 +13,11 @@ export type TouchableProps =
     debugComponent?: string
     onPress?: AnyFunction
     noFeedback?: boolean
+    /** Milliseconds to lock out repeat presses after the first. Defaults to 500. */
     debounce?: number
+    /** Start the component in a locked state for one debounce period on mount — prevents ghost taps when the component renders directly under the user's finger. */
     leadingDebounce?: boolean
+    /** Callback so a parent can mirror the internal pressed state, e.g. to drive its own feedback animations. */
     setPressed?: (param: boolean) => void
     rippleDisabled?: boolean
     children?: React.ReactNode

package/src/components/View/index.tsx

@@ -10,6 +10,7 @@ import { useComponentTestId } from '@codeleap/hooks'
 export * from './types'
 export * from './styles'
 
+/** `View.Animated` is a convenience alias that passes `animated` as true; prefer it over setting the prop manually so variant types stay correct. */
 export const View = forwardRef<RNView, ViewProps>((props, ref) => {
   const {
     style,

package/src/components/View/types.ts

@@ -4,6 +4,7 @@ import Animated, { AnimatedStyle } from 'react-native-reanimated'
 import { ViewComposition } from './styles'
 import { PropsOf } from '@codeleap/types'
 
+/** `animatedStyle` is kept separate from `style` because Reanimated shared-value styles must not be flattened through the style registry — merging them would lose the animated binding. */
 export type ViewProps = Omit<RNViewProps, 'style'> & {
   style?: StyledProp<ViewComposition>
   animated?: boolean

package/src/components/components.ts

@@ -26,7 +26,6 @@ export * from './SegmentedControl'
 export * from './Autocomplete'
 export * from './Grid'
 export * from './LoadingOverlay'
-export * from './ActionIcon'
 export * from './InputBase'
 export * from './DatePickerModal'
 export * from './RefreshControl'

package/src/hooks/useAnimatedState.ts

@@ -2,11 +2,9 @@ import { useState, useCallback } from 'react'
 import { SharedValue, useSharedValue, useDerivedValue, runOnJS, isSharedValue } from 'react-native-reanimated'
 
 /**
- * Hook that synchronizes a React state with a Reanimated SharedValue.
+ * `runOnJS(_setValue)` is required because `useDerivedValue` runs on the UI thread — calling a React state setter directly from a worklet would crash. The derived value callback fires synchronously after the shared value changes, then bounces the update back to the JS thread via `runOnJS`.
  *
- * @example
- * const [value, setValue, sharedValue] = useAnimatedState(0)
- * setValue(10) // Updates both React state and SharedValue
+ * Closures inside the `useDerivedValue` callback must only reference serializable values; capturing non-serializable JS objects here will silently break on the UI thread.
  */
 export function useAnimatedState<T>(initialValue: SharedValue<T> | T) {
   const sharedValue = isSharedValue(initialValue)
@@ -30,12 +28,6 @@ export function useAnimatedState<T>(initialValue: SharedValue<T> | T) {
   return [value, setValue, sharedValue] as const
 }
 
-/**
- * Hook that extracts and synchronizes the value from a SharedValue.
- *
- * @example
- * const value = useAnimatedValue(sharedValue)
- */
 export function useAnimatedValue<T>(initialValue: SharedValue<T> | T): T {
   const [value] = useAnimatedState(initialValue)
   return value

package/src/hooks/useKeyboardController.ts

@@ -6,6 +6,9 @@ type KeyboardControllerState = {
   isVisible: boolean
 }
 
+/**
+ * Uses `react-native-keyboard-controller` `KeyboardEvents` rather than the standard RN `Keyboard` API because it fires `keyboardWillShow`/`keyboardWillHide` on both platforms with accurate animated height values; the native `KeyboardProvider` must wrap the app tree or these events will never fire.
+ */
 export function useKeyboardController() {
   const [keyboardState, setKeyboardState] = useState<KeyboardControllerState>({ isVisible: false, height: 0 })
 

package/src/hooks/useStatusBar.ts

@@ -6,6 +6,9 @@ type UseStatusBarOptions = {
   statusBarColor?: StatusBarStyle
 }
 
+/**
+ * Uses the stack-based `pushStackEntry`/`popStackEntry` API so that nested screens can each set a style and restore the parent's style on unmount — imperative `setBarStyle` calls would stomp each other. On Android the background colour of the status bar is controlled separately via the system theme; only `barStyle` (light/dark content) is affected here.
+ */
 export function useStatusBar({ statusBarColor }: UseStatusBarOptions) {
   const focused = useIsFocused()
 

package/src/hooks/useStylesFor.ts

@@ -1,13 +1,15 @@
-import { StyleProp, useStyleObserver } from '@codeleap/styles'
+import { ComponentContext, StyleProp, useStyleObserver } from '@codeleap/styles'
+import { useStableReference } from '@codeleap/hooks'
 import { useMemo } from 'react'
 import { MobileStyleRegistry } from '../Registry'
 
-export const useStylesFor = <T = unknown>(componentName: string, style?: StyleProp<T, string>): T => {
+export const useStylesFor = <T = unknown>(componentName: string, style?: StyleProp<T, string>, context?: ComponentContext): T => {
   const styleObserver = useStyleObserver(style)
+  const stableContext = useStableReference(context ?? {})
 
   const styles = useMemo(() => {
-    return MobileStyleRegistry.current.styleFor(componentName, style)
-  }, [styleObserver])
+    return MobileStyleRegistry.current.styleFor(componentName, style, true, stableContext)
+  }, [styleObserver, stableContext])
 
   return styles
 }

package/src/index.ts

@@ -10,4 +10,5 @@ import uuid from 'react-native-uuid'
 
 export { uuid }
 
+/** Side-effect import that patches `Field` with native measurement/scroll methods — must remain at the bottom so it runs after all named exports are resolved. */
 import './modules/formConfig'

package/src/modules/backgroundTimer.ts

@@ -1,6 +1,9 @@
 import { AnyFunction } from '@codeleap/types'
 import uuid from 'react-native-uuid'
 
+/**
+ * Timer maps are module-level singletons keyed by caller-supplied `ref` strings so that disparate call sites (e.g. a button handler and an effect) can share and cancel the same logical timer without passing the id through props. If no `ref` is provided a UUID is generated, making each call site independent — callers must capture and reuse the returned ref to cancel or coalesce subsequent calls.
+ */
 const throttleTimerId = {}
 
 export function throttle(func: AnyFunction, ref?: string, delay = 200) {

package/src/modules/formConfig.ts

@@ -1,3 +1,6 @@
+/**
+ * Side-effect module — importing it monkey-patches `Field` with mobile-specific measurement and scroll implementations. It must be imported (via `packages/mobile/src/index.ts`) before any form field renders; the form package ships no-op stubs for these methods by default so a missing import would silently fail to scroll to validation errors.
+ */
 import React from 'react'
 import { Field } from '@codeleap/form'
 import { StatusBar, View } from 'react-native'

package/src/modules/reactNavigation.ts

@@ -5,8 +5,7 @@ import { createPathConfigForStaticNavigation } from '@react-navigation/native'
 type TreeStack = Parameters<typeof createPathConfigForStaticNavigation>[0]
 
 /**
- * Extracts screen options from a static navigation tree, consolidating default, group, 
- * and individual screen options into a single object. Supports nested navigators.
+ * Accesses `config.screenOptions` and `group.screenOptions` via `@ts-ignore` because `@react-navigation/native` does not expose these properties in the public `TreeStack` type — they exist at runtime but are considered internal to the static navigation builder. If React Navigation changes this internal shape, the extraction will silently return empty options rather than throwing.
  */
 export function staticNavigationExtractOptions(stack: TreeStack) {
   const { config } = stack

package/src/modules/scroll.tsx

@@ -35,6 +35,9 @@ const noOpScrollable = {
 
 const ScrollContext = React.createContext({} as ScrollContextValue)
 
+/**
+ * Augments a plain `ScrollView` ref with a pub/sub `subscribe` method so that sibling components (e.g. a floating header) can react to scroll events without prop-drilling. The augmented ref is exposed via `useImperativeHandle` so the parent sees the extended interface; the underlying `ScrollView` ref is called through directly so no native bridge call is duplicated.
+ */
 export const useScrollPubSub = (ref: MutableRefObject<Omit<Scrollable,'subscribe'>>) => {
   const listeners = useRef(new Map())
 

package/src/modules/textInputMask.tsx

@@ -1,5 +1,8 @@
 import { TextInputMask, TextInputMaskProps } from 'react-native-masked-text'
 
+/**
+ * Re-exported with a looser type because `react-native-masked-text` does not forward refs in its public typings; the cast to `ForwardRefExoticComponent` lets callers attach a ref to read the raw (unmasked) value via `.getRawValue()` — without the ref the only value accessible is the formatted display string.
+ */
 export const MaskedTextInput = TextInputMask as unknown as React.ForwardRefExoticComponent<Partial<TextInputMaskProps> & {
     ref?: any
 }>

package/src/modules/types/textInputMask.ts

@@ -3,6 +3,7 @@ import { TextInputProps } from 'react-native'
 
 import { TextInputMaskProps as RNTextInputMaskProps } from 'react-native-masked-text'
 
+/** `saveFormatted: true` makes the form store the display string (e.g. `"(11) 99999-9999"`) instead of the raw digits — only set this if the backend expects the formatted value, otherwise leave it unset and call `.getRawValue()` via ref before submission. */
 type Mask = Partial<RNMaskedTextTypes.TextInputMaskProps> & {
   saveFormatted?: boolean
 }

package/src/utils/NotificationManager/index.ts

@@ -9,8 +9,8 @@ export * from './types'
 const MODULE = 'NotificationManager'
 
 /**
-  * Class responsible for the notification system
-*/
+ * Requires `@react-native-firebase/messaging` to be installed and the app to have a valid `google-services.json` / `GoogleService-Info.plist`. `initialize` must be awaited at app boot — calling `registerEvent` before `initialize` is safe (events are stored) but `invokeForInitialNotification` will be skipped if `initialized` is already `true`, so calling `initialize` twice silently drops the cold-start notification. `onBackgroundMessage` registers a global Firebase background handler that persists beyond the component lifecycle; it is never automatically cleaned up.
+ */
 export class NotificationManager<N extends object = Message, E extends string = string> {
   public parser: NotificationManagerOptions<N>['parser'] = (message: Message) => message as N
 

package/src/utils/OSAlert.ts

@@ -25,6 +25,7 @@ export type AlertEvent = AlertButton['onPress']
 export type OSAlertType = 'info' | 'error' | 'warn' | 'ask'
 export type NamedEvents<E extends string> = Partial<Record<E, AlertEvent>>
 
+/** Deduplication map keyed by alert identity (type + title + body) — prevents the same alert from stacking when triggered multiple times before the user dismisses it. Entries are removed only after the user taps a button, so alerts that are dismissed via the hardware back button on Android will leave a stale entry and block the next identical alert. */
 const currentAlerts = {
 
 }

package/src/utils/StorageManager.ts

@@ -10,6 +10,11 @@ type ValueTypeMap<V = AnyRecord> = {
   object: V
 }
 
+/**
+ * Wraps `react-native-mmkv`, which is fully synchronous — reads and writes block the JS thread for microseconds but never return Promises, unlike AsyncStorage. Each `StorageManager` instance creates its own MMKV database file; if you need encryption, pass an `id` and `encryptionKey` to `new MMKV(options)` here before sharing the instance across the app.
+ *
+ * Objects are round-tripped through `JSON.stringify`/`JSON.parse`; non-serialisable values (class instances, functions) will silently lose their prototype on read-back.
+ */
 export class StorageManager<T extends Record<string, any>> {
   public instance = new MMKV()
 

package/src/utils/hooks.ts

@@ -182,6 +182,7 @@ type RippleConfig = {
   config?: PressableRippleProps
   iosFallback?: FeedbackConfig
 }
+/** On iOS `ripple` is not supported by the native layer; the `iosFallback` config is substituted automatically inside `getFeedbackStyle` so callers do not need platform guards at the call site. */
 export type TouchableFeedbackConfig = RippleConfig | FeedbackConfig
 
 export type TouchFeedbackConfig = {
@@ -290,6 +291,7 @@ export function useBackButton(cb: () => boolean|void, deps = []) {
   }, deps)
 }
 
+/** Merges keyboard height into `paddingBottom` rather than adjusting layout height or using `KeyboardAvoidingView` because padding-based adjustment composites cleanly with existing scroll content insets and does not cause a layout jump on Android. */
 export function useKeyboardPaddingStyle(styles: ViewStyle[], enabled = true) {
   const { isVisible, height } = useKeyboardController()
 

package/src/utils/misc.ts

@@ -24,6 +24,7 @@ export const stringToFile = (str: string): MobileInputFile => {
   }
 }
 
+/** Unwraps a `FileWithPreview` wrapper (which carries a `preview` URI for display) down to the raw `MobileFile` shape that the fetch layer can append to `FormData`; passing a `FileWithPreview` directly to `FormData.append` would serialize the wrapper object as a string. */
 export function toMultipartFile(file: MobileInputFile) {
   // const inputFile = file as MobileInputFile
   const withPreview = file as FileWithPreview

package/src/utils/theme.ts

@@ -7,6 +7,9 @@ type Options = {
   getAndroidNavbarHeight?: () => number
 }
 
+/**
+ * Safe-area insets are computed statically from `DeviceInfo` flags rather than from `react-native-safe-area-context` so the values are available synchronously before the context provider mounts. The `initialWindowMetrics` argument should come from `SafeAreaProvider`'s `initialMetrics` prop to seed Android bottom inset before the provider has measured. On iOS, notch/island presence is inferred from hardware flags rather than from `initialWindowMetrics` because those metrics are not stable across orientation changes at init time.
+ */
 export function getMobileThemeValues(initialWindowMetrics, options: Options = {}) {
   const { statusBarHeight, getStatusBarHeight, getAndroidNavbarHeight } = options
 

package/src/utils/useQueryListRefresh.ts

@@ -14,6 +14,9 @@ type useQueryListRefresh = (
   }
 ) => void
 
+/**
+ * Uses `useFocusEffect` (not `useEffect`) so the refetch/stale timer is tied to React Navigation screen focus — a background tab never triggers an unnecessary network request. The stale window starts on blur and is cleared on the next focus, meaning a very fast back-and-forward (faster than `staleTime`) will not refetch.
+ */
 export const useQueryListRefresh: useQueryListRefresh = (listQuery, options = {}) => {
   const {
     staleTime = 5000,

package/dist/Registry.js

@@ -1,42 +0,0 @@
-import { CodeleapStyleRegistry, StylePersistor } from '@codeleap/styles';
-import { StyleSheet } from 'react-native';
-import { MMKV } from 'react-native-mmkv';
-const mmkvStorage = new MMKV();
-const persistor = new StylePersistor({
-    set(key, value) {
-        return mmkvStorage?.set(key, value);
-    },
-    get(key) {
-        return mmkvStorage?.getString(key);
-    },
-    del(key) {
-        return mmkvStorage?.delete(key);
-    },
-});
-let instance;
-const components = [];
-export class MobileStyleRegistry extends CodeleapStyleRegistry {
-    constructor() {
-        super(persistor);
-        components.forEach((component) => {
-            this.registerComponent(component);
-        });
-        if (!instance) {
-            instance = this;
-        }
-        return instance;
-    }
-    createStyle(css) {
-        return StyleSheet.create({ s: css }).s;
-    }
-    static get current() {
-        return instance;
-    }
-    static registerComponent(component) {
-        components.push(component);
-        if (instance) {
-            instance.registerComponent(component);
-        }
-    }
-}
-//# sourceMappingURL=Registry.js.map

package/dist/Registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Registry.js","sourceRoot":"","sources":["../src/Registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,qBAAqB,EAAQ,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAExC,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,CAAA;AAE9B,MAAM,SAAS,GAAG,IAAI,cAAc,CAAC;IACnC,GAAG,CAAC,GAAG,EAAE,KAAK;QACZ,OAAO,WAAW,EAAE,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;IACrC,CAAC;IACD,GAAG,CAAC,GAAG;QACL,OAAO,WAAW,EAAE,SAAS,CAAC,GAAG,CAAC,CAAA;IACpC,CAAC;IACD,GAAG,CAAC,GAAG;QACL,OAAO,WAAW,EAAE,MAAM,CAAC,GAAG,CAAC,CAAA;IACjC,CAAC;CACF,CAAC,CAAA;AAEF,IAAI,QAA6B,CAAA;AAEjC,MAAM,UAAU,GAAkD,EAAE,CAAA;AAEpE,MAAM,OAAO,mBAAoB,SAAQ,qBAAqB;IAC5D;QACE,KAAK,CAAC,SAAS,CAAC,CAAA;QAEhB,UAAU,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;YAC/B,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAA;QACnC,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,QAAQ,GAAG,IAAI,CAAA;QACjB,CAAC;QAED,OAAO,QAAQ,CAAA;IACjB,CAAC;IAED,WAAW,CAAC,GAAS;QACnB,OAAO,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAA;IACxC,CAAC;IAED,MAAM,KAAK,OAAO;QAChB,OAAO,QAAQ,CAAA;IACjB,CAAC;IAED,MAAM,CAAC,iBAAiB,CAAC,SAA6B;QACpD,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QAC1B,IAAI,QAAQ,EAAE,CAAC;YACb,QAAQ,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAA;QACvC,CAAC;IACH,CAAC;CACF"}

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

@@ -1,12 +0,0 @@
-import { AnyRecord, IJSX, StyledComponentProps } from '@codeleap/styles';
-import { ActionIconProps } from './types';
-export * from './styles';
-export * from './types';
-export declare const ActionIcon: {
-    (props: ActionIconProps): import("react/jsx-runtime").JSX.Element;
-    styleRegistryName: string;
-    elements: string[];
-    rootElement: string;
-    withVariantTypes<S extends AnyRecord>(styles: S): (props: StyledComponentProps<ActionIconProps, typeof styles>) => IJSX;
-    defaultProps: Partial<ActionIconProps>;
-};

package/dist/components/ActionIcon/index.js

@@ -1,33 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useCompositionStyles } from '@codeleap/styles';
-import { MobileStyleRegistry } from '../../Registry';
-import { Badge } from '../Badge';
-import { Icon } from '../Icon';
-import { Touchable } from '../Touchable';
-import { useStylesFor } from '../../hooks';
-export * from './styles';
-export * from './types';
-export const ActionIcon = (props) => {
-    const { name, icon, iconProps, children, badge, badgeProps = {}, style, ...touchableProps } = {
-        ...ActionIcon.defaultProps,
-        ...props,
-    };
-    const styles = useStylesFor(ActionIcon.styleRegistryName, style);
-    const compositionStyles = useCompositionStyles(['badge', 'touchable'], styles);
-    return (_jsxs(Touchable, { ...touchableProps, style: compositionStyles?.touchable, children: [_jsx(Icon, { name: icon ?? name, ...iconProps, style: [
-                    styles.icon,
-                    touchableProps?.disabled && styles['icon:disabled'],
-                ] }), children, _jsx(Badge, { badge: badge, ...badgeProps, style: compositionStyles?.badge })] }));
-};
-ActionIcon.styleRegistryName = 'ActionIcon';
-ActionIcon.elements = ['icon', 'touchable', 'badge'];
-ActionIcon.rootElement = 'touchableWrapper';
-ActionIcon.withVariantTypes = (styles) => {
-    return ActionIcon;
-};
-ActionIcon.defaultProps = {
-    hitSlop: 10,
-    badge: false,
-};
-MobileStyleRegistry.registerComponent(ActionIcon);
-//# sourceMappingURL=index.js.map

package/dist/components/ActionIcon/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/components/ActionIcon/index.tsx"],"names":[],"mappings":";AACA,OAAO,EAAyC,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC9F,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AACpD,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAChC,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC9B,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAExC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE1C,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AAEvB,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,KAAsB,EAAE,EAAE;IACnD,MAAM,EACJ,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,QAAQ,EACR,KAAK,EACL,UAAU,GAAG,EAAE,EACf,KAAK,EACL,GAAG,cAAc,EAClB,GAAG;QACF,GAAG,UAAU,CAAC,YAAY;QAC1B,GAAG,KAAK;KACT,CAAA;IAED,MAAM,MAAM,GAAG,YAAY,CAAC,UAAU,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAA;IAEhE,MAAM,iBAAiB,GAAG,oBAAoB,CAAC,CAAC,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM,CAAC,CAAA;IAE9E,OAAO,CACL,MAAC,SAAS,OAAK,cAAc,EAAE,KAAK,EAAE,iBAAiB,EAAE,SAAS,aAChE,KAAC,IAAI,IACH,IAAI,EAAE,IAAI,IAAI,IAAI,KACd,SAAS,EACb,KAAK,EAAE;oBACL,MAAM,CAAC,IAAI;oBACX,cAAc,EAAE,QAAQ,IAAI,MAAM,CAAC,eAAe,CAAC;iBACpD,GACD,EAED,QAAQ,EAET,KAAC,KAAK,IAAC,KAAK,EAAE,KAAK,KAAM,UAAU,EAAE,KAAK,EAAE,iBAAiB,EAAE,KAAK,GAAI,IAC9D,CACb,CAAA;AACH,CAAC,CAAA;AAED,UAAU,CAAC,iBAAiB,GAAG,YAAY,CAAA;AAC3C,UAAU,CAAC,QAAQ,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,CAAA;AACpD,UAAU,CAAC,WAAW,GAAG,kBAAkB,CAAA;AAE3C,UAAU,CAAC,gBAAgB,GAAG,CAAsB,MAAS,EAAE,EAAE;IAC/D,OAAO,UAAmF,CAAA;AAC5F,CAAC,CAAA;AAED,UAAU,CAAC,YAAY,GAAG;IACxB,OAAO,EAAE,EAAE;IACX,KAAK,EAAE,KAAK;CACe,CAAA;AAE7B,mBAAmB,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAA"}

package/dist/components/ActionIcon/styles.d.ts

@@ -1,5 +0,0 @@
-import { BadgeComposition } from '../Badge';
-import { TouchableComposition } from '../Touchable';
-export type ActionIconParts = 'icon' | `touchable${Capitalize<TouchableComposition>}` | `badge${Capitalize<BadgeComposition>}`;
-export type ActionIconStates = ':disabled' | '';
-export type ActionIconComposition = `${ActionIconParts}${ActionIconStates}`;

package/dist/components/ActionIcon/styles.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=styles.js.map

package/dist/components/ActionIcon/styles.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../../src/components/ActionIcon/styles.ts"],"names":[],"mappings":""}

package/dist/components/ActionIcon/types.d.ts

@@ -1,11 +0,0 @@
-import { AppIcon, StyledProp } from '@codeleap/styles';
-import { BadgeComponentProps } from '../Badge';
-import { IconProps } from '../Icon';
-import { TouchableProps } from '../Touchable';
-import { ActionIconComposition } from './styles';
-export type ActionIconProps = Omit<TouchableProps, 'style'> & BadgeComponentProps & {
-    iconProps?: Partial<IconProps>;
-    icon?: AppIcon;
-    name?: AppIcon;
-    style?: StyledProp<ActionIconComposition>;
-};

package/dist/components/ActionIcon/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map

package/dist/components/ActionIcon/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/components/ActionIcon/types.ts"],"names":[],"mappings":""}

package/dist/components/ActivityIndicator/index.js

@@ -1,26 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { ActivityIndicator as RNActivityIndicator } from 'react-native';
-import { MobileStyleRegistry } from '../../Registry';
-import { useStylesFor } from '../../hooks';
-export * from './styles';
-export * from './types';
-export const ActivityIndicator = (props) => {
-    const { style, component: Component = RNActivityIndicator, ...rest } = {
-        ...ActivityIndicator.defaultProps,
-        ...props,
-    };
-    const styles = useStylesFor(ActivityIndicator.styleRegistryName, style);
-    const wrapperStyle = styles?.wrapper;
-    const color = wrapperStyle?.color || '#000';
-    const size = (wrapperStyle?.height || wrapperStyle?.width || 'large');
-    return (_jsx(Component, { size: size, color: color, ...rest, style: styles?.wrapper }));
-};
-ActivityIndicator.styleRegistryName = 'ActivityIndicator';
-ActivityIndicator.elements = ['wrapper'];
-ActivityIndicator.rootElement = 'wrapper';
-ActivityIndicator.defaultProps = {};
-ActivityIndicator.withVariantTypes = (styles) => {
-    return ActivityIndicator;
-};
-MobileStyleRegistry.registerComponent(ActivityIndicator);
-//# sourceMappingURL=index.js.map