@codeleap/mobile 4.2.18 → 4.3.1

package/src/components/Select/types.ts

@@ -1,4 +1,5 @@
-import { FormTypes, PropsOf } from '@codeleap/common'
+import { PropsOf } from '@codeleap/types'
+import { FormTypes } from '@codeleap/form'
 import { AppIcon, StyledProp } from '@codeleap/styles'
 import { StylesOf } from '../../types/utility'
 import { GetKeyboardAwarePropsOptions } from '../../utils'

package/src/components/Slider/index.tsx

@@ -1,7 +1,8 @@
 import React from 'react'
 import { Slider as RNSlider } from '@miblanchard/react-native-slider'
 import { StyleSheet } from 'react-native'
-import { TypeGuards, onUpdate } from '@codeleap/common'
+import { TypeGuards } from '@codeleap/types'
+import { onUpdate } from '@codeleap/hooks'
 import { SliderProps, TrackMarkProps } from './types'
 import { InputBase, selectInputBaseProps } from '../InputBase'
 import { Text } from '../Text'

package/src/components/SortablePhotos/useSortablePhotos.ts

@@ -1,4 +1,5 @@
-import { CreateOSAlert, useEffect, useGlobalContext, useMemo, useState } from '@codeleap/common'
+import { CreateOSAlert } from '@codeleap/modals'
+import { useEffect, useMemo, useState } from '@codeleap/hooks'
 import { FileInputImageSource, useFileInput } from '../FileInput'
 import { SortablePhoto, SortablePhotosProps } from './types'
 
@@ -20,7 +21,6 @@ export const useSortablePhotos = <T extends SortablePhoto>(props: SortablePhotos
   } = props
 
   const input = useFileInput()
-  const { logger } = useGlobalContext()
 
   const [data, setData] = useState<T[]>([])
 
@@ -91,7 +91,7 @@ export const useSortablePhotos = <T extends SortablePhoto>(props: SortablePhotos
         multiple: isEdit ? false : props?.multiple
       })
     } catch (error) {
-      logger.error('Error opening file picker:', error)
+      console.error('Error opening file picker:', error)
     }
 
     if (files?.length <= 0) return null

package/src/components/Text/index.tsx

@@ -1,5 +1,5 @@
 import React, { forwardRef, useState } from 'react'
-import { TypeGuards } from '@codeleap/common'
+import { TypeGuards } from '@codeleap/types'
 import { Animated, Platform, Text as NativeText } from 'react-native'
 import { TouchableFeedbackConfig, usePressableFeedback } from '../../utils'
 import { TextProps } from './types'

package/src/components/Text/styles.ts

@@ -1,4 +1,4 @@
-import { StylesOf } from '@codeleap/common'
+import { StylesOf } from '@codeleap/types'
 import { FeedbackConfig } from '../../utils'
 
 export type TextComposition = 'text' | 'pressFeedback' | 'text:disabled'

package/src/components/TextInput/index.tsx

@@ -1,5 +1,7 @@
 import React, { useState } from 'react'
-import { TypeGuards, useValidate, useBooleanToggle } from '@codeleap/common'
+import { useValidate } from '@codeleap/form'
+import { useBooleanToggle } from '@codeleap/hooks'
+import { TypeGuards } from '@codeleap/types'
 import { forwardRef, useImperativeHandle } from 'react'
 import { TextInput as NativeTextInput, NativeSyntheticEvent, TextInputFocusEventData } from 'react-native'
 import { InputBase, selectInputBaseProps } from '../InputBase'

package/src/components/TextInput/types.ts

@@ -1,6 +1,7 @@
 import { InputBaseProps } from '../InputBase'
 import { TextInputProps as RNTextInputProps, TextInput as RNTextInput } from 'react-native'
-import { AnyFunction, FormTypes, yup } from '@codeleap/common'
+import { AnyFunction } from '@codeleap/types'
+import { FormTypes, yup } from '@codeleap/form'
 import { AppIcon, StyledProp } from '@codeleap/styles'
 import { TextInputMaskProps } from '../../modules/textInputMask'
 import { TextInputComposition } from './styles'

package/src/components/Touchable/index.tsx

@@ -1,5 +1,7 @@
 import React, { forwardRef } from 'react'
-import { TypeGuards, onMount, useGlobalContext } from '@codeleap/common'
+import { TypeGuards } from '@codeleap/types'
+import { onMount } from '@codeleap/hooks'
+import { useGlobalContext } from '@codeleap/hooks'
 import { Pressable, StyleSheet, View as RNView, Insets, Platform } from 'react-native'
 import { View } from '../View'
 import { TouchableFeedbackConfig, usePressableFeedback } from '../../utils'

package/src/components/Touchable/types.ts

@@ -1,4 +1,4 @@
-import { AnyFunction } from '@codeleap/common'
+import { AnyFunction } from '@codeleap/types'
 import { StyledProp } from '@codeleap/styles'
 import { View as RNView, PressableProps } from 'react-native'
 import { TouchableComposition } from './styles'

package/src/components/View/types.ts

@@ -1,4 +1,4 @@
-import { PropsOf } from '@codeleap/common'
+import { PropsOf } from '@codeleap/types'
 import { StyledProp } from '@codeleap/styles'
 import { ImageStyle, TextStyle, View as RNView, ViewStyle } from 'react-native'
 import { AnimatedStyleProp } from 'react-native-reanimated'

package/src/modules/types/textInputMask.ts

@@ -1,4 +1,4 @@
-import { FormTypes } from '@codeleap/common'
+import { FormTypes } from '@codeleap/form'
 import { TextInputProps } from 'react-native'
 
 import { TextInputMaskProps as RNTextInputMaskProps } from 'react-native-masked-text'

package/src/utils/KeyboardAware/keyboardHooks.ts

@@ -1,4 +1,4 @@
-import { PropsOf, TypeGuards } from '@codeleap/common'
+import { PropsOf, TypeGuards } from '@codeleap/types'
 import { ScrollView, Platform, StyleSheet, Dimensions, EasingFunction, Easing } from 'react-native'
 import { TransitionConfig } from '../../types'
 import { useKeyboard } from './context'

package/src/utils/MobilePermissionManager/Permission.ts

@@ -0,0 +1,79 @@
+import { AnyFunction } from '@codeleap/types'
+import * as PermissionTypes from './types'
+
+const SCOPE = 'Permissions'
+
+export class Permission implements PermissionTypes.IPermission {
+  status: PermissionTypes.PermissionStatus
+
+  shouldAsk: boolean
+
+  constructor(private actions:PermissionTypes.PermissionActions & {log?: AnyFunction}, public name = '') {
+    this.actions = actions
+    this.shouldAsk = true
+    this.status = 'pending'
+
+  }
+
+  async ask(): Promise<void> {
+    const newState = await this.actions.onAsk()
+    this.actions.log(`Request for permission ${this.name} returned`, newState, SCOPE)
+    this.status = newState
+
+    if (newState === 'blocked') {
+      this.shouldAsk = false
+    }
+  }
+
+  async check(options?:PermissionTypes.CheckOptions): Promise<void> {
+    const _options:PermissionTypes.CheckOptions = {
+      askOnPending: true,
+      askOnDenied: false,
+      ask: true,
+      ...options,
+    }
+
+    this.status = await this.actions.onCheck()
+    this.actions.log(`Check for permission ${this.name} returned`, this.status, SCOPE)
+    if (!_options.ask) return
+
+    switch (this.status) {
+      case 'denied':
+        if (_options.askOnDenied) {
+          await this.ask()
+        }
+        break
+      case 'pending':
+        if (_options.askOnPending) {
+          await this.ask()
+        }
+        break
+    }
+  }
+
+  get isGranted() {
+    return this.status === 'granted'
+  }
+
+  get isDenied() {
+    return this.status === 'denied'
+  }
+
+  get isPending() {
+    return this.status === 'pending'
+  }
+
+  get isBlocked() {
+    return this.status === 'blocked'
+  }
+
+  get isUnavailable() {
+    return this.status === 'unavailable'
+
+  }
+
+  get isLimited() {
+    return this.status === 'limited'
+
+  }
+}

package/src/utils/MobilePermissionManager/PermissionManager.ts

@@ -0,0 +1,124 @@
+import { Logger } from '@codeleap/logger'
+import { Permission } from './Permission'
+import * as PermissionTypes from './types'
+
+export class PermissionManager<
+    T extends PermissionTypes.PermissionActionRecord,
+    I extends PermissionTypes.IPermissionManager<T> = PermissionTypes.IPermissionManager<T>
+> implements PermissionTypes.IPermissionManager<T> {
+  private _permissions:Record<keyof T, Permission>
+
+  subscriberArgs:Parameters<PermissionTypes.ChangeListener<T>>
+
+  private subscribers: PermissionTypes.ChangeListener<T>[]
+
+  private permSubscribers: Record<keyof T, PermissionTypes.PermissionSubscriber[]>
+
+  public _perms: T
+
+  public opts: I
+
+  private params: T
+
+  public permissions: {
+      [Property in keyof T as Uppercase<string & Property>] : Property
+    }
+
+  logger: Logger
+
+  constructor(perms: T, options?: PermissionTypes.PermissionManagerOptions) {
+    this.params = perms
+    // @ts-ignore
+    this._permissions = {}
+    // @ts-ignore
+    this.permissions = {}
+
+    this.logger = options?.logger
+    this.permSubscribers = {} as typeof this.permSubscribers
+
+    for (const [permName, actions] of Object.entries(this.params)) {
+      const name = permName as keyof T
+      this._permissions[name] = new Permission({ ...actions, log: this.logger?.log || (() => null) }, permName)
+
+      this.permSubscribers[name] = []
+
+      // @ts-ignore
+      this.permissions[(name as string).toUpperCase()] = name
+    }
+
+    this.subscribers = []
+  }
+
+  get values() {
+    return this._permissions as unknown as Record<keyof T, PermissionTypes.PermissionState>
+  }
+
+  private async check(name: keyof T, options?: PermissionTypes.CheckOptions): Promise<PermissionTypes.PermissionState> {
+    const previousStatus = this._permissions[name].status
+
+    await this._permissions[name].check(options)
+
+    if (this._permissions[name].status !== previousStatus) {
+      this.permSubscribers[name].forEach(sub => sub(this._permissions[name]))
+      this.subscribers.forEach(sub => sub(name, this._permissions[name]))
+    }
+    return this._permissions[name]
+  }
+
+  getMany:I['getMany'] = async (perms, options) => {
+
+    const results = []
+
+    for (const p of perms) {
+      const isArray = Array.isArray(p)
+      const name = isArray ? p[0] : p
+      const opts = isArray ? p[1] : options
+
+      results.push(await this.check(name, opts))
+    }
+
+    return results
+  }
+
+  // @ts-ignore
+  get:I['get'] = async (name, options) => {
+    return await this.check(name, options)
+  }
+
+  onPermissionChange(name: keyof T, callback:PermissionTypes.PermissionSubscriber) {
+    const subIdx = this.permSubscribers[name].push(callback) - 1
+
+    return () => {
+      this.permSubscribers[name].splice(subIdx, 1)
+    }
+  }
+
+  onChange(callback:PermissionTypes.ChangeListener<T>) {
+    const subIdx = this.subscribers.push(callback) - 1
+
+    return () => {
+      this.subscribers.splice(subIdx, 1)
+    }
+  }
+
+  getState() {
+    const state = {}
+
+    for (const [p, { ask: _ig2, check: _ig1, ...values }] of Object.entries(this._permissions)) {
+      state[p] = { ...values }
+    }
+
+    return state as Record<keyof T, PermissionTypes.PermissionState>
+  }
+
+  async update() {
+    const res = {} as Record<keyof T, PermissionTypes.PermissionState>
+    for (const p of Object.keys(this._permissions)) {
+      res[p as keyof T] = await this.check(p, {
+        ask: false,
+      })
+    }
+    return res
+  }
+
+}

package/src/utils/MobilePermissionManager/index.ts

@@ -0,0 +1,3 @@
+export * as PermissionTypes from './types'
+export * from './Permission'
+export * from './PermissionManager'

package/src/utils/MobilePermissionManager/types.ts

@@ -0,0 +1,44 @@
+import { Logger } from '@codeleap/logger'
+import { FunctionType } from '@codeleap/types'
+
+export const permissionStatuses = ['unavailable', 'pending', 'denied', 'limited', 'granted', 'blocked'] as const
+export type PermissionStatus = typeof permissionStatuses[number]
+
+export type PermissionState = {
+    status: PermissionStatus
+    shouldAsk: boolean
+
+} & Record<`is${Capitalize<PermissionStatus>}`, boolean>
+
+export type CheckOptions = {
+    askOnPending?:boolean
+    askOnDenied?:boolean
+    ask?: boolean
+
+}
+
+export type IPermission = {
+    ask():Promise<void>
+    check(options?:CheckOptions):Promise<void>
+
+} & PermissionState
+
+export type PermFunction = FunctionType<[], Promise<PermissionStatus>>
+
+export type PermissionActions = Record<'onAsk'|'onCheck', PermFunction> & { init?: 'check' | PermissionState }
+
+export type PermissionActionRecord = Record<string, PermissionActions>
+
+export interface IPermissionManager<T extends PermissionActionRecord> {
+    getMany(perms: PermissionArray<T>, options?: CheckOptions): Promise<PermissionState[]>
+    get(name: keyof T, options?: CheckOptions): Promise<PermissionState>
+}
+
+export type ChangeListener<T> = FunctionType<[keyof T, PermissionState], any>
+export type PermissionSubscriber = FunctionType<[PermissionState], any>
+
+export type PermissionArray<T> = ([name: keyof T, options: CheckOptions])[] | (keyof T)[]
+
+export type PermissionManagerOptions = {
+    logger?: Logger
+}

package/src/utils/ModalManager/components.tsx

@@ -1,5 +1,6 @@
 import React from 'react'
-import { usePrevious, onMount, onUpdate, PropsOf } from '@codeleap/common'
+import { usePrevious, onMount, onUpdate } from '@codeleap/hooks'
+import { PropsOf } from '@codeleap/types'
 import { useModalContext } from './context'
 import { Portal } from '@gorhom/portal'
 import { Modal as _Modal } from '../../components/Modal'

package/src/utils/ModalManager/context.tsx

@@ -1,5 +1,6 @@
 import React from 'react'
-import { AnyFunction, onUpdate, TypeGuards, useState } from '@codeleap/common'
+import { AnyFunction, TypeGuards } from '@codeleap/types'
+import { onUpdate, useState } from '@codeleap/hooks'
 import { PortalProvider } from '@gorhom/portal'
 import { KeyboardProvider } from '../KeyboardAware'
 

package/src/utils/NotificationManager/index.ts

@@ -1,4 +1,5 @@
-import { AnyFunction, silentLogger } from '@codeleap/common' // @ts-ignore
+import { AnyFunction } from '@codeleap/types'
+import { silentLogger } from '@codeleap/logger' // @ts-ignore
 import messaging from '@react-native-firebase/messaging'
 import { Subscriber, Subscription } from '../Subscription'
 import { Message, NotificationInitializeCallback, NotificationManagerOptions, NotificationType, TNotification } from './types'

package/src/utils/NotificationManager/types.ts

@@ -1,6 +1,6 @@
 // @ts-ignore
 import { FirebaseMessagingTypes } from '@react-native-firebase/messaging'
-import { FunctionType } from '@codeleap/common'
+import { FunctionType } from '@codeleap/types'
 
 export type Message = FirebaseMessagingTypes.RemoteMessage
 

package/src/utils/PermissionManager/context.tsx

@@ -1,8 +1,10 @@
 import React, { useContext, useState } from 'react'
 import { useModalContext } from '../ModalManager/context'
-import { deepEqual, onMount, onUpdate, PermissionManager, PermissionTypes, useDebounce, usePrevious } from '@codeleap/common'
+import { onMount, onUpdate, useDebounce, usePrevious } from '@codeleap/hooks'
+import { deepEqual } from '@codeleap/utils'
 import { AppState, Linking } from 'react-native'
 import { PermissionConfig, PermissionModalsConfig } from './types'
+import { PermissionManager, PermissionTypes } from '../MobilePermissionManager'
 
 type TPermissionContext = {
   state: Record<string, PermissionTypes.PermissionStatus>

package/src/utils/PermissionManager/types.ts

@@ -1,5 +1,5 @@
-import { PermissionTypes } from '@codeleap/common'
 import { ImageProps } from '../../components/Image'
+import { PermissionTypes } from '../MobilePermissionManager'
 type NonGrantedPermissionTypes = Exclude<PermissionTypes.PermissionStatus, 'granted'>
 
 export type BasePermissionConfig = {

package/src/utils/StorageManager.ts

@@ -1,5 +1,5 @@
 import { MMKV } from 'react-native-mmkv'
-import { AnyFunction, AnyRecord } from '@codeleap/common'
+import { AnyFunction, AnyRecord } from '@codeleap/types'
 
 type StorageKey<T extends Record<string, any>> = keyof T | (string & {}) | ((allKeys: T) => string) | [keyof T, any]
 

package/src/utils/hooks.ts

@@ -1,4 +1,6 @@
-import { onMount, onUpdate, shadeColor, TypeGuards, usePrevious, useRef, useState } from '@codeleap/common'
+import { onMount, onUpdate, usePrevious, useRef, useState } from '@codeleap/hooks'
+import { shadeColor } from '@codeleap/utils'
+import { TypeGuards } from '@codeleap/types'
 import { Animated, AppState, AppStateStatus, Platform, BackHandler, ViewStyle, ImageStyle, TextStyle, StyleSheet, StyleProp } from 'react-native'
 import { AnimatedStyleProp, Easing, EasingFn, useAnimatedStyle, withTiming } from 'react-native-reanimated'
 import { PressableRippleProps } from '../modules/PressableRipple/type'

package/src/utils/index.ts

@@ -14,3 +14,4 @@ export * from './Subscription'
 export * from './useQueryListRefresh'
 
 export * from './StorageManager'
+export * from './MobilePermissionManager'

package/src/utils/misc.ts

@@ -1,4 +1,5 @@
-import { MobileFile, MobileInputFile, parseFilePathData, FileWithPreview, TypeGuards } from '@codeleap/common'
+import { MobileFile, MobileInputFile, FileWithPreview, TypeGuards } from '@codeleap/types'
+import { parseFilePathData } from '@codeleap/utils'
 
 export const stringToFile = (str: string): MobileInputFile => {
   if (!str) {

package/src/utils/useQueryListRefresh.ts

@@ -1,6 +1,7 @@
 import React from 'react'
 import { useFocusEffect } from '@react-navigation/native'
-import { AnyFunction, TypeGuards, UseListEffect } from '@codeleap/common'
+import { AnyFunction, TypeGuards } from '@codeleap/types'
+import { UseListEffect } from '@codeleap/query'
 
 type useQueryListRefresh = (
   listQuery: Parameters<UseListEffect>[0],

package/dist/utils/deprecated/notifications.d.ts

@@ -1,40 +0,0 @@
-import { FunctionType } from '@codeleap/common';
-import { FirebaseMessagingTypes } from '@react-native-firebase/messaging';
-export type Message = FirebaseMessagingTypes.RemoteMessage;
-export type MessageType = 'foreground' | 'background' | 'press' | 'initial';
-export type NotificationHandler = FunctionType<[message: Message, type: MessageType], any>;
-export type HandleNotificationParam = {
-    data: Message;
-    type: MessageType;
-};
-export type NotificationStateChangeListener = FunctionType<[isInitialized: boolean, token?: string], any>;
-/**
-  * Class responsible for the notification system
-  *
-  * @deprecated Use the most updated version
-  * @note check the documentation to make the migration
-*/
-export declare class NotificationManager {
-    private logger;
-    autoHandleInitialNotification: boolean;
-    stateChangeListeners: NotificationStateChangeListener[];
-    messageListeners: NotificationHandler[];
-    _initialized: boolean;
-    unsubscribeFromMessage: any;
-    unsubscribeFromBackgroundMessage: any;
-    unsubscribeFromPress: any;
-    _currentToken: any;
-    _initialNoficationHandled: boolean;
-    constructor(logger?: import("@codeleap/common").Logger, autoHandleInitialNotification?: boolean);
-    init(): Promise<void>;
-    deinit(): Promise<void>;
-    private handleNotification;
-    get currentToken(): string;
-    set currentToken(token: string);
-    get initialized(): boolean;
-    set initialized(to: boolean);
-    onNotification(handler: NotificationHandler): () => void;
-    private triggerStateChange;
-    onStateChange(handler: NotificationStateChangeListener): () => void;
-    getInitialNotification(): Promise<HandleNotificationParam>;
-}