@codeleap/mobile 5.8.21 → 6.0.1

package/src/deprecated/modals/index.ts

@@ -1,13 +0,0 @@
-import { useModalContext, useModalSequence, Provider } from './Context'
-import { Modal, ManagedModalProps } from './components'
-
-export const ModalManager = {
-  useModalContext,
-  Modal,
-  Provider,
-  useModalSequence,
-}
-
-export type {
-  ManagedModalProps,
-}

package/src/deprecated/permissions/Context.tsx

@@ -1,316 +0,0 @@
-import React, { useContext, useState } from 'react'
-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 './package'
-import { useModalContext } from '../modals/Context'
-
-type TPermissionContext = {
-  state: Record<string, PermissionTypes.PermissionStatus>
-  modalConfig: PermissionModalsConfig<any>
-  manager: PermissionManager<any, any>
-  setState: (forPermission: string, status: PermissionTypes.PermissionState) => void
-}
-
-const PermissionContext = React.createContext({} as TPermissionContext)
-
-type PermissionProviderProps = {
-  children: React.ReactElement
-  AppPermissions: PermissionManager<any, any>
-  modalConfig: PermissionModalsConfig<any>
-}
-type PermissionsRecord = PermissionManager<any, any>['values']
-function getStatuses(state: PermissionsRecord) {
-  const statuses = Object.entries(state).map(([k, v]) => [k, v.status])
-  return Object.fromEntries(statuses)
-}
-
-export function Provider({ children, AppPermissions, modalConfig }: PermissionProviderProps) {
-
-  const [state, setState] = useState(() => getStatuses(AppPermissions.values))
-
-  onMount(() => {
-
-    AppState.addEventListener('change', (state) => {
-      if (state === 'active') {
-        AppPermissions.update().then((vals) => {
-          const statuses = getStatuses(vals)
-          if (!deepEqual(statuses, state)) {
-            setState({ ...statuses })
-          }
-        })
-      }
-    })
-
-  })
-
-  const setPermissionState = (forPermission: string, status: PermissionTypes.PermissionState) => {
-    setState({
-      ...state,
-      [forPermission]: status
-    })
-  }
-
-
-  return <PermissionContext.Provider value={{
-    state,
-    modalConfig: modalConfig,
-    manager: AppPermissions,
-    setState: setPermissionState
-  }}>
-    {children}
-  </PermissionContext.Provider>
-}
-
-type TAskManyResults<T extends string> = Record<T, PermissionTypes.PermissionStatus> & {
-  overall
-  : PermissionTypes.PermissionStatus
-}
-
-type AskManyOpts<T extends string | number | symbol> = {
-  breakOnDenied?: T[]
-}
-
-export type UsePermissions<
-  _PermissionNames extends string,
-  PermissionNames extends string = `${_PermissionNames}?` | _PermissionNames> = () => TPermissionContext & {
-    askPermission: (name: PermissionNames, onResolve?: (status: PermissionTypes.PermissionStatus) => any) => Promise<PermissionTypes.PermissionStatus>
-    askMany<T extends PermissionNames, R = TAskManyResults<T>>(
-      perms: T[],
-      onResolve?: (res: R) => any,
-      options?: AskManyOpts<T>
-    ): Promise<
-      R
-    >
-  }
-
-export const usePermissions: UsePermissions<any> = () => {
-  const modalCtx = useModalContext()
-  const permissionCtx = useContext(PermissionContext)
-
-  function askPermission(name: string, onResolve?: (status: PermissionTypes.PermissionStatus, modalName?: string) => any) {
-    return new Promise<PermissionTypes.PermissionStatus>((resolve, reject) => {
-      permissionCtx.manager.get(name, {
-        ask: false,
-        askOnDenied: false,
-        askOnPending: false,
-      }).then(status => {
-        const permissionModalName = `permissions.${name}`
-
-        if (!status.isGranted) {
-
-          modalCtx.toggleModal(permissionModalName, true, {
-            onPermissionResolve: (status) => {
-              modalCtx.toggleModal(permissionModalName, false, {})
-              setTimeout(() => {
-                onResolve?.(status, permissionModalName)
-
-                resolve(status)
-              }, modalCtx.transitionDuration)
-            },
-          })
-
-        } else {
-          onResolve?.(status.status as unknown as PermissionTypes.PermissionStatus)
-          resolve(status)
-        }
-      })
-    })
-
-  }
-
-  const askMany = async (
-    perms: any[],
-    onResolve?: (res: any) => any,
-    options?: AskManyOpts<any>,
-  ) => {
-
-    let prevModal = null
-    const results = {}
-
-    for (const _permission of perms) {
-      const permission = _permission.replace('?', '')
-      const status = await permissionCtx.manager.get(permission, {
-        ask: false,
-        askOnDenied: false,
-        askOnPending: false,
-      })
-      results[permission] = status.status
-      const permissionModalName = `permissions.${permission}`
-
-      if (!status.isGranted) {
-        let onOpen = null
-
-        if (prevModal) {
-
-          onOpen = () => new Promise((resolve) => {
-            setTimeout(() => {
-
-              modalCtx.transition(prevModal, permissionModalName, {
-                props: {
-                  onPermissionResolve: (status) => {
-                    resolve(status)
-                    permissionCtx.setState(permission, status)
-                  },
-                },
-              })
-            })
-          })
-        } else {
-          onOpen = () => new Promise((resolve) => {
-            setTimeout(() => {
-              modalCtx.toggleModal(permissionModalName, true, {
-                onPermissionResolve: (status) => {
-                  resolve(status)
-                  permissionCtx.setState(permission, status)
-
-                },
-              })
-            })
-          })
-
-        }
-
-        results[permission] = await onOpen()
-        prevModal = permissionModalName
-
-        if (!_permission.endsWith('?') && results[permission] !== 'granted') {
-          break
-        }
-      }
-    }
-    if (prevModal) {
-
-      setTimeout(() => {
-        modalCtx.toggleModal(prevModal, false, {})
-      })
-    }
-    const res: Parameters<typeof onResolve>[0] = {
-      ...results,
-      overall: Object.values(results).every(x => x === 'granted') ? 'granted' : 'denied',
-    }
-    onResolve(res)
-    return res
-  }
-
-  return {
-    askPermission,
-    askMany,
-    ...permissionCtx,
-  }
-}
-
-export function usePermissionModal(permissionName: string) {
-
-  const modalId = `permissions.${permissionName}`
-  const modals = useModalContext()
-  const permissionCtx = usePermissions()
-  const modalState = modals.state[modalId]
-
-  const currentState = permissionCtx?.state?.[permissionName]
-  const status = currentState
-  const [debouncedStatus, reset] = useDebounce(status, modals.transitionDuration * 0.5)
-
-  function getConfig(withStatus) {
-    return {
-      ...permissionCtx.modalConfig[permissionName],
-      ...permissionCtx.modalConfig[permissionName]?.[withStatus],
-    } as PermissionConfig
-  }
-  const config = getConfig(debouncedStatus)
-
-  function onPermissionResolve(_status?: PermissionTypes.PermissionStatus) {
-    modalState?.props?.onPermissionResolve?.(_status || status)
-
-  }
-
-  onUpdate(() => {
-
-    if (modalState?.visible && !!status) {
-
-      if (status === 'granted') {
-        reset()
-        onPermissionResolve()
-      } else {
-
-        if (!deepEqual(config, getConfig(status))) {
-
-          modals.transition(modalId, modalId, {
-            props: modalState?.props,
-          })
-        }
-      }
-
-    }
-  }, [status, modalState?.visible])
-
-  async function onAllow() {
-
-    switch (config.onAllow) {
-      case 'ask':
-        const newStatus = await permissionCtx.manager.get(permissionName, {
-          ask: true,
-          askOnDenied: true,
-          askOnPending: true,
-        })
-        if (!newStatus.isGranted) {
-          onPermissionResolve(newStatus.status)
-        }
-        break
-
-      case 'openSettings':
-      default:
-        Linking.openSettings()
-        break
-    }
-
-  }
-
-  function onDeny() {
-    onPermissionResolve()
-  }
-
-  return {
-    onAllow,
-    onDeny,
-    modalId,
-    permissionName,
-    modalState: {
-      ...modalState,
-
-    },
-    currentState,
-    config,
-  }
-}
-
-type PermissionManagerArgTypes<M extends PermissionManager<any, any>> = {
-  perms: M extends PermissionManager<infer P, any> ? P extends Record<string, any> ? P : never : never
-  opts: M extends PermissionManager<any, infer O> ? O : never
-}
-
-type CreateTypedPermissionHooksArgs<
-  M extends PermissionManager<any, any>,
-  Args extends PermissionManagerArgTypes<M> = PermissionManagerArgTypes<M>,
-  ModalConfig extends PermissionModalsConfig<keyof Args['perms']> = PermissionModalsConfig<keyof Args['perms']>
-> = {
-  modalConfig: ModalConfig
-  permissionsManager: M
-}
-
-export function createTypedPermissionHooks<
-  M extends PermissionManager<any, any>,
-  Args extends PermissionManagerArgTypes<M> = PermissionManagerArgTypes<M>
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
->(configuration: CreateTypedPermissionHooksArgs<M>) {
-
-  const _usePermissions = usePermissions as UsePermissions<Exclude<keyof Args['perms'], number | symbol>>
-  const _usePermissionModal = usePermissionModal as ((name: keyof Args['perms']) => ReturnType<typeof usePermissionModal>)
-
-  return {
-    usePermissions: _usePermissions,
-    usePermissionModal: _usePermissionModal,
-
-  }
-}

package/src/deprecated/permissions/index.ts

@@ -1,16 +0,0 @@
-import { usePermissions, Provider, createTypedPermissionHooks, usePermissionModal } from './Context'
-import { PermissionConfig, PermissionModalsConfig } from './types'
-
-export * from './package'
-
-export {
-  usePermissions,
-  Provider,
-  usePermissionModal,
-  createTypedPermissionHooks,
-}
-
-export type {
-  PermissionConfig,
-  PermissionModalsConfig,
-}

package/src/deprecated/permissions/package/Manager.ts

@@ -1,123 +0,0 @@
-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
-
-  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/deprecated/permissions/package/Permission.ts

@@ -1,79 +0,0 @@
-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/deprecated/permissions/package/index.ts

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

package/src/deprecated/permissions/package/types.ts

@@ -1,43 +0,0 @@
-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?: any
-}

package/src/deprecated/permissions/types.ts

@@ -1,27 +0,0 @@
-import { ImageProps } from '../../components/Image'
-import { PermissionTypes } from './package'
-type NonGrantedPermissionTypes = Exclude<PermissionTypes.PermissionStatus, 'granted'>
-
-export type BasePermissionConfig = {
-  fullscreenModal?: boolean
-  dismissable?: boolean
-  title: string
-  onAllow: 'openSettings' | 'ask'
-
-  description: string[]
-  icon?: string
-  image?: ImageProps['source']
-  imageProps?: Omit<ImageProps, 'source'>
-}
-
-export type PermissionConfig = BasePermissionConfig &
-  Partial<
-    Record<
-      NonGrantedPermissionTypes,
-      Partial<BasePermissionConfig>
-    >
-  >
-
-export type PermissionModalsConfig<PermissionNames extends string | number | symbol> = Partial<
-  Record<PermissionNames, PermissionConfig>
->