@codeleap/mobile 3.21.4 → 3.21.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeleap/mobile",
-  "version": "3.21.4",
+  "version": "3.21.6",
   "main": "src/index.ts",
   "license": "UNLICENSED",
   "repository": {

package/src/components/InputBase/styles.ts

@@ -37,14 +37,19 @@ const getIconStyles = (obj, state) => {
       state.hasError && obj['icon:error'], 
       state.disabled && obj['icon:disabled']
     ],
+    'icon:disabled': [
+      state.disabled && obj['icon:disabled']
+    ],
     touchableWrapper: [
       obj.touchableWrapper, 
       state.focused && obj['touchableWrapper:focus'],
       state.hasError && obj['touchableWrapper:error'], 
       state.disabled && obj['touchableWrapper:disabled']
     ],
+    'touchableWrapper:disabled': [
+      state.disabled && obj['touchableWrapper:disabled']
+    ]
   }
-
 }
 
 export const useInputBaseStyles = (props: InputBaseProps) => {
@@ -71,12 +76,14 @@ export const useInputBaseStyles = (props: InputBaseProps) => {
 
   const leftIconStyles = [
     generalIconStyles, 
-   getIconStyles(_leftIconStyles, { hasError, disabled, focused })
+    // @ts-ignore
+    getIconStyles(_leftIconStyles, { hasError, disabled: disabled || props?.leftIcon?.disabled, focused })
   ]
 
   const rightIconStyles = [
     generalIconStyles,
-    getIconStyles(_rightIconStyles, { hasError, disabled, focused })
+    // @ts-ignore
+    getIconStyles(_rightIconStyles, { hasError, disabled: disabled || props?.right?.disabled, focused })
   ]
 
   const labelStyle = [

package/src/utils/NotificationManager/index.ts

@@ -0,0 +1,231 @@
+import { AnyFunction, silentLogger } from '@codeleap/common' // @ts-ignore
+import messaging from '@react-native-firebase/messaging'
+import { Subscriber, Subscription } from '../Subscription'
+import { Message, NotificationInitializeCallback, NotificationManagerOptions, NotificationType, TNotification } from './types'
+
+export * from './types'
+
+const MODULE = 'NotificationManager'
+
+/**
+  * Class responsible for the notification system
+*/
+export class NotificationManager<N extends object = Message, E extends string = string> {
+  public parser: NotificationManagerOptions<N>['parser'] = (message: Message) => message as N
+
+  public currentOptions: NotificationManagerOptions<N> = {
+    handleInitialNotification: true,
+    debug: false,
+    slackDebug: false,
+  }
+
+  public currentToken = null
+
+  private registeredUnsubscribers: Record<string, AnyFunction> = {}
+
+  private initialized = false
+
+  public events = new Subscription<TNotification<N>, E>()
+
+  constructor(
+    private _logger = silentLogger,
+    options: NotificationManagerOptions<N> = {}
+  ) {
+    if (typeof options?.parser == 'function') {
+      this.parser = options?.parser
+    }
+
+    this.currentOptions = {
+      ...this.currentOptions,
+      ...options
+    }
+  }
+
+  private invoke(args: {
+    data: Message,
+    type: NotificationType,
+  }) {
+    this.log('Invoke this events:', this.events.getSubscribersKeys())
+
+    this.events.invoke({
+      data: this.parser(args?.data),
+      type: args?.type
+    })
+  }
+
+  public log(description: string, data: any = {}) {
+    if (!this._logger) return
+
+    if (this.currentOptions.debug) {
+      this._logger.log(description, data, MODULE)
+    }
+
+    if (this.currentOptions.slackDebug) {
+      this._logger.slack.echo(description, data, MODULE, {
+        'include': ['version'],
+        'sendIn': ['release', 'debug']
+      })
+    }
+  }
+
+  /**
+   * Checks if you are authorized for notifications and returns the result
+   * 
+   * @return hasAuthorization (boolean)
+  */
+  public async getHasAuthorization() {
+    const authStatus = await messaging().hasPermission()
+
+    const hasAuthorization =
+      authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
+      authStatus === messaging.AuthorizationStatus.PROVISIONAL
+
+    return hasAuthorization
+  }
+
+  /**
+   * Gets and returns the device token
+   * 
+   * @return token (string) or null if an error occurs
+  */
+  public async getToken() {
+    try {
+      const token = await messaging().getToken()
+
+      this.log('Get token', { token })
+
+      this.currentToken = token
+
+      return token
+    } catch (err) {
+      this.log('Get token error', err)
+      return null
+    }
+  }
+
+  public onTokenRefresh(cb: (token: string) => void) {
+    const unsubscribe = messaging().onTokenRefresh(newToken => {
+      this.log('Refreshed token', { newToken })
+
+      this.currentToken = newToken
+
+      cb(newToken)
+    })
+
+    return unsubscribe
+  }
+
+  public async invokeForInitialNotification() {
+    if (this.initialized) return
+
+    const initialNotification = await messaging().getInitialNotification()
+
+    this.log('Initial Notification', initialNotification)
+
+    if (!!initialNotification && this.currentOptions.handleInitialNotification) {
+      this.invoke({
+        data: initialNotification,
+        type: 'initial'
+      })
+    }
+  }
+
+  public onBackgroundMessage() {
+    messaging().setBackgroundMessageHandler(async remoteMessage => {
+      this.log('Notification in background:', remoteMessage)
+
+      this.invoke({
+        data: remoteMessage,
+        type: 'background'
+      })
+    })
+
+    return () => messaging().setBackgroundMessageHandler(() => null)
+  }
+
+  /**
+   * Responsible for initializing all notification services: token refresh, background, foreground, press and initial notification
+   *
+   * @param {function} callback Callback that is executed when the services are initialized, returning the device token
+  */
+  public async initialize(callback: NotificationInitializeCallback) {
+    this.log('Initialize', this.currentOptions)
+
+    this.unsubscribe()
+
+    const token = await this.getToken()
+
+    callback(token)
+
+    this.invokeForInitialNotification()
+
+    const unsubscribeOnNotificationOpenedApp = messaging().onNotificationOpenedApp(remoteMessage => {
+      this.log('Notification pressed:', remoteMessage)
+
+      this.invoke({
+        data: remoteMessage,
+        type: 'press'
+      })
+    })
+
+    this.registeredUnsubscribers['openApp'] = unsubscribeOnNotificationOpenedApp
+
+    const unsubscribeOnBackgroundMessage = this.onBackgroundMessage()
+
+    this.registeredUnsubscribers['background'] = unsubscribeOnBackgroundMessage
+
+    const unsubscribeOnMessage = messaging().onMessage(async remoteMessage => {
+      this.log('Notification in foreground', remoteMessage)
+
+      this.invoke({
+        data: remoteMessage,
+        type: 'foreground'
+      })
+    })
+
+    this.registeredUnsubscribers['foreground'] = unsubscribeOnMessage
+
+    const unsubscribeOnTokenRefresh = this.onTokenRefresh(callback)
+
+    this.registeredUnsubscribers['refreshToken'] = unsubscribeOnTokenRefresh
+
+    this.initialized = true
+  }
+
+  public async unsubscribe() {
+    this.log('Unsubscribe handlers', this.registeredUnsubscribers)
+
+    for (const unsubscribeKey in this.registeredUnsubscribers) {
+      this.registeredUnsubscribers[unsubscribeKey]()
+      delete this.registeredUnsubscribers[unsubscribeKey]
+    }
+  }
+
+  /**
+   * Unsubscribe all services that have been started
+   *
+   * @param {function} callback Callback that is executed when the services are deinitialized
+  */
+  public async deinitialize(callback: AnyFunction = null) {
+    if (!this.initialized) return
+
+    this.log('Deinitialize')
+
+    this.unsubscribe()
+
+    if (typeof callback == 'function') {
+      callback()
+    }
+  }
+
+  /**
+   * Registers an event that will be called by all notification services that have been started
+   *
+   * @param {string} eventName Event name
+   * @param {string} handler Function that will be performed
+   * @return unsubscribe event (function)
+  */
+  public registerEvent(eventName: E, handler: Subscriber<TNotification<N>>) {
+    return this.events.subscribe(eventName, handler)
+  }
+}

package/src/utils/NotificationManager/types.ts

@@ -0,0 +1,25 @@
+// @ts-ignore
+import { FirebaseMessagingTypes } from '@react-native-firebase/messaging'
+import { FunctionType } from '@codeleap/common'
+
+export type Message = FirebaseMessagingTypes.RemoteMessage
+
+export type NotificationType = 'foreground' | 'background' | 'press' | 'initial'
+
+export type NotificationHandler<N extends object = Message> = FunctionType<[notification: N, type: NotificationType], void>
+
+export type TNotification<N extends object = Message> = {
+  data: N
+  type: NotificationType
+}
+
+export type NotificationInitializeCallback = (
+  deviceToken: string, 
+) => void
+
+export type NotificationManagerOptions<N extends object = Message> = {
+  debug?: boolean
+  slackDebug?: boolean
+  handleInitialNotification?: boolean,
+  parser?: (message: Message) => N
+}

package/src/utils/Subscription.ts

@@ -0,0 +1,73 @@
+import React from 'react'
+
+export type Subscriber<T> =  (e: T) => any
+
+type SubscriptionRecord = Record<string, Subscription<any>>
+
+type MultiSubscriptor<T extends SubscriptionRecord> = <K extends keyof T>(
+  e: K,
+  key: string,
+  cb: Subscriber<T[K] extends Subscription<infer ET> ? ET : never>
+) => () => void
+
+class Subscription<T, K extends string = string> {
+  public subscribers: Record<K, Subscriber<T>> = {} as Record<K, Subscriber<T>>
+
+  private _history: T[] = []
+
+  get history(){
+    return Object.freeze(this._history)
+  }
+
+  subscribe(key: K, cb: Subscriber<T>) {
+    this.subscribers[key] = cb
+
+    return () => {
+      delete this.subscribers[key]
+    }
+  }
+
+  getSubscriber(key: K) {
+    return this.subscribers[key]
+  }
+
+  removerSubscriber(key: K) {
+    delete this.subscribers[key] 
+  }
+
+  getSubscribersKeys() {
+    return Object.keys(this.subscribers)
+  }
+
+  invoke(e: T) {
+    this._history.push(e)
+
+    for (const subscriber in this.subscribers) {
+      this.subscribers[subscriber](e)
+    }
+  }
+
+  removeAllListeners(){
+    this.subscribers = {} as Record<K, Subscriber<T>>
+  }
+
+  static createSubscriptor<SR extends SubscriptionRecord>(events: SR): MultiSubscriptor<SR> {
+    return (e, key, cb) => {
+      return events[e]!.subscribe(key, cb)
+    }
+  }
+}
+
+function useSubscriptionHistory<T>(subscription: Subscription<T>){
+  const [state, setState] = React.useState(subscription.history)
+
+  React.useEffect(() => {
+    return subscription.subscribe('subscription-history', e => {
+      setState([...state, e])
+    })
+  }, [])
+
+  return state
+}
+
+export { Subscription, useSubscriptionHistory }

package/src/utils/{notifications.ts → deprecated/notifications.ts}

@@ -17,6 +17,13 @@ export type HandleNotificationParam = {
 }
 
 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 class NotificationManager {
 
     stateChangeListeners:NotificationStateChangeListener[] = []

package/src/utils/index.ts

@@ -1,7 +1,7 @@
 export * from './OSAlert'
 export * from './hooks'
 export * from './misc'
-export * from './notifications'
+export * from './NotificationManager'
 export * from './ModalManager'
 import * as Permissions from './PermissionManager'
 
@@ -10,3 +10,4 @@ export * from './KeyboardAware'
 export * from './input'
 export * from './theme'
 export * from './locale'
+export * from './Subscription'