@fto-consult/expo-ui 8.19.2 → 8.20.0

package/babel.config.alias.js

@@ -77,5 +77,6 @@ module.exports = (opts)=>{
     r.$electronProjectRoot = path.resolve(r.$projectRoot,"electron");
     r.$econtext = path.resolve(expo,"context");
     r.$epdf = path.resolve(expo,"pdf");
+    r.$session = path.resolve(expo,"session");
     return r;
 }

package/bin/create-app/dependencies.js

@@ -24,7 +24,6 @@ module.exports = {
 	"expo-web-browser": "~12.8.2",
 	"react":"18.2.0",
 	"react-native": "0.73.2",
-	"@react-native-async-storage/async-storage": "1.21.0",
 	"react-native-safe-area-context": "4.8.2",
 	"react-native-screens": "~3.29.0",
 	"react-native-svg": "14.1.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fto-consult/expo-ui",
-  "version": "8.19.2",
+  "version": "8.20.0",
   "description": "Bibliothèque de composants UI Expo,react-native",
   "scripts": {
     "clear-npx-cache": "npx clear-npx-cache",
@@ -69,7 +69,7 @@
   "dependencies": {
     "@emotion/react": "^11.11.1",
     "@faker-js/faker": "^8.0.2",
-    "@fto-consult/common": "^4.19.4",
+    "@fto-consult/common": "^4.20.0",
     "@fto-consult/node-utils": "^1.4.7",
     "apexcharts": "^3.45.2",
     "crypto-browserify": "^3.12.0",

package/src/App.js

@@ -1,3 +1,5 @@
+import session from "$session";
+import {useState,useEffect} from "$react";
 import Provider from "$econtext/Provider";
 import App from "./AppEntry";
 /****
@@ -14,7 +16,18 @@ import App from "./AppEntry";
  */
 
 export default function ExpoUIAppEntryProvider({children,init,...rest}){
-    return <Provider {...rest}>
-        <App init={init} children={children}/>
-    </Provider>
+    const [children,setChildren] = useState(null);
+    useEffect(()=>{
+        const end = ()=>{
+            setChildren(<Provider {...rest}>
+                <App init={init} children={children}/>
+            </Provider>);
+        };
+        if(typeof session?.init =="function"){
+            return Promise.resolve(init).finally(end);
+        } else {
+            end();
+        }
+    },[]);
+    return children;
 }

package/src/context/Provider.js

@@ -25,7 +25,6 @@ import notify from "$cnotify";
 import {showPrompt} from "$ecomponents/Dialog/confirm";
 import {SWRConfig} from "$swr";
 import {Keyboard } from 'react-native';
-import initSQLite from "./init-sqlite";
 
 Object.map(Utils,(v,i)=>{
   if(typeof v =='function' && typeof window !='undefined' && window && !window[i]){
@@ -305,9 +304,7 @@ const Provider = ({children,getTableData,handleHelpScreen,navigation,swrConfig,a
       });
       return [...r,...getMainScreens(handleHelpScreen)];
     },[]);
-    const {linking} = navigation;
     React.useEffect(()=>{
-      initSQLite();
       const onScreenFocus = ({sanitizedName})=>{
           if(activeScreenRef.current){
              screensRef.current[activeScreenRef.current] = null;

package/src/session/index.js

@@ -0,0 +1,2 @@
+export * from "$csession";
+export {default} from "$csession";

package/src/session/index.native.js

@@ -0,0 +1,163 @@
+import * as SQLite from 'expo-sqlite/next';
+import {isDev} from "$cplatform";
+import appConfig from "$capp/config";
+import {sanitizeFileName,isNonNullString,isObj,defaultObj} from "$cutils";
+import {sanitizeKey as cSanitizeKey,handleGetValue,handleSetValue} from "$csession/utils";
+import * as FileSystem from 'expo-file-system';
+
+export const SESSION_TABLE = "SESSION";
+
+const debug = (...args)=>{
+    if(!isDev()) return;
+    return console.log(...args);
+}
+
+export class SQLiteSession {
+    constructor () {
+      this.hasInit = false
+      this.db = null
+      this.data = new Map();
+    }
+    getDBName(){
+        let appName = appConfig.name;
+        const suffix = "sqlite-sessname";
+        if(isNonNullString(appName)){
+            appName = sanitizeFileName(appName.replaceAll("\\","/").replaceAll("\\","")).replace(/\s+/g, "").trim();
+            return `${appName}-${suffix}`;
+        }
+        return `${suffix}`;
+    }
+    
+    sanitizeKey (key) {
+      if(!isNonNullString(key)) return "";
+      return sanitizeFileName(cSanitizeKey(key)).replace(/\s+/g, "").trim();
+    }
+    async init () {
+      if (!this.db || !this.hasInit) {
+        const dbName = this.getDBName();
+        debug(`Opening sqlite database ${dbName} for session storage`);
+        if(!this.openingPromise){
+            this.openingPromise = SQLite.openDatabaseAsync(dbName).then((db)=>{
+                return db.execAsync(`
+                    CREATE TABLE IF NOT EXISTS ${SESSION_TABLE} (id INTEGER PRIMARY KEY NOT NULL, key TEXT, value TEXT);
+                `).then((d)=>{
+                    this.db = db;
+                    this.hasInit = true;
+                    this.getAll();
+                }).catch((e)=>{
+                    debug(e," error when initializing sqlite session");
+                    throw e;
+                });
+            }).finally(()=>{
+                delete this.openingPromise;
+            });;
+        }
+        return this.openingPromise;
+      }
+      return Promise.resolve(true);
+    }
+    get(key){
+      key = this.sanitizeKey(key);
+      if(!key) return undefined;
+      return defaultObj(this.data.get(key)).value;
+    }
+    async getAsync (key,callback) {
+      key = this.sanitizeKey(key);
+      if(!key) return undefined;
+      await this.init()
+      const resp = await this.db.getFirstAsync(`SELECT value FROM ${SESSION_TABLE} WHERE key = ? `,key)
+      if (!resp) {
+        if(typeof callback =='function'){
+          callback(undefined);
+        }
+        return undefined;
+      }
+      const r = handleGetValue(resp?.value);
+      if(typeof callback =='function'){
+        callback(r);
+      }
+      return r;
+    }
+  
+    async set (key,value) {
+      key = this.sanitizeKey(key);
+      if (!key) return undefined;
+      const toUpdate  = {...defaultObj(this.data.get(key)),value};
+      this.data.set(key,toUpdate);
+      const isUpdate = "id" in toUpdate &&  !!String(toUpdate.id) || false;
+      value = handleSetValue(value,true);
+      try {
+        await this.init();
+        const params = {$key: key,$value:value};
+        if(isUpdate){
+          params.$id = toUpdate.id;
+        }
+        const statement = await this.db.prepareAsync(isUpdate ? `UPDATE ${SESSION_TABLE} SET value = $value WHERE id = $id` : `INSERT INTO ${SESSION_TABLE}(key,value) VALUES ($key,$value)`);
+        try {
+          const result = await statement.executeAsync(params)
+          if(!isUpdate && result.lastInsertRowId){
+              toUpdate.id = result.lastInsertRowId;
+              this.data.set(key,toUpdate);
+          }
+        } finally {
+          await statement.finalizeAsync();
+        }
+      } catch(e){
+        debug(e," error on inserting session data");
+      } 
+      return;
+    }
+    async remove (key) {
+      key = this.sanitizeKey(key);
+      if (!key) return false;
+      this.data.delete(key);
+      await this.init();
+      debug(`removing session: ${key}`)
+      return await this.db.runAsync(SQL`DELETE FROM sessions WHERE key = ?`,key);
+    }
+    async getAll () {
+      if(!this.hasInit || !this.db) return {};
+      const data = await this.db.getAllAsync(`SELECT * FROM ${SESSION_TABLE}`);
+      debug("getting all sql session");
+      this.data.clear();
+      return data.map(({key,id,value})=>{
+        value = handleGetValue(value);
+        this.data.set(key,{id,value});
+      });
+    }
+    async length () {
+      await this.init()
+      const data = await this.db.getFirstAsync(`SELECT count(*) as total FROM ${SESSION_TABLE}`)
+      return data.total
+    }
+  
+    async clearAll () {
+      await this.init()
+      debug(`Clearing all sessions`)
+      this.data.clear();
+      return await this.db.runAsync(`DELETE FROM ${SESSION_TABLE}`);
+    }
+  }
+  
+export function initSQLite (){
+  return new Promise((resolve,reject)=>{
+      const createD = ()=>{
+          return FileSystem.makeDirectoryAsync(FileSystem.documentDirectory + 'SQLite').then(resolve).catch(e=>{
+              resolve(null);
+          });
+      };
+      FileSystem.getInfoAsync(FileSystem.documentDirectory + 'SQLite').then((info)=>{
+      if(!info?.exists){
+        return createD();
+      }
+      resolve(info);   
+      return info;
+    }).catch(createD);
+  })
+}
+
+const sqliteSession = new SQLiteSession();
+sqliteSession.init();
+initSQLite();
+
+export default sqliteSession;

package/src/session/native.old/helpers.js

@@ -0,0 +1,14 @@
+// Copyright 2022 @fto-consult/Boris Fouomene. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+export const handleError= function (func, param) {
+  let message;
+  if (!param) {
+    message = func;
+  } else {
+    message = `${func}() requires at least ${param} as its first parameter.`;
+  }
+  console.warn(message); // eslint-disable-line no-console
+  return Promise.reject(message);
+}

package/src/session/native.old/index.MMKV.js

@@ -0,0 +1,37 @@
+// Copyright 2022 @fto-consult/Boris Fouomene. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*** for usage, @see : https://github.com/raphaelpor/sync-storage 
+  @see : https://github.com/echowaves/expo-storage
+*/
+import { MMKV } from 'react-native-mmkv'
+import {handleError} from './helpers';
+import {stringify} from "$cutils/json";
+import { sanitizeKey } from '../../../../common/src/session/utils';
+
+export const storage = new MMKV();
+
+export const get = (key)=> {
+  return storage.get(sanitizeKey(key));
+}
+
+export const set = (key, value)=> {
+  key = sanitizeKey(key);
+  if (!key) return handleError('set', `a key`);
+  storage.set(key, value);
+  value = stringify(value);
+  return storage.set(key, value).then((v)=>{return {[key]:value}});
+}
+
+export const remove = (key)=> {
+  key = sanitizeKey(key);
+  if (!key) return handleError('remove', 'a key');
+  return storage.delete(key);
+}
+export const clearAll = storage.clearAll;
+export const removeAll = storage.clearAll;
+
+export {MMKV};
+
+export default {...storage,set,get,remove,clearAll,removeAll};

package/src/session/native.old/index.fileSystem.js

@@ -0,0 +1,60 @@
+// Copyright 2022 @fto-consult/Boris Fouomene. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+import {handleError} from './helpers';
+import {stringify,isJSON,parseJSON} from "$cutils/json";
+import {sanitizeFileName} from "$cutils";
+import isPromise from "$cutils/isPromise";
+import { sanitizeKey } from '../../../../common/src/session/utils';
+import * as FileSystem from 'expo-file-system';
+
+export class Storage {
+  data = new Map();
+  currentPromise = null;
+  getPath(){
+      const appName = require("$packageJSON").name;
+      return `${FileSystem.documentDirectory}${appName?`${sanitizeFileName(appName).toLowerCase().trim()}.session`:"session"}`;
+  }
+  init() {
+    if(isPromise(this.currentPromise)) return this.currentPromise;
+    this.currentPromise = FileSystem.readAsStringAsync(`${this.getPath()}`).then((its)=>{
+      if(isJSON(its)){
+        this.data = new Map(parseJSON(its));
+      }
+      return this.data;
+    }).catch(e=>{});
+    return this.currentPromise;
+  }
+  get(key) {
+    return this.data.get(sanitizeKey(key));
+  }
+  persist(){
+    return FileSystem.writeAsStringAsync(this.getPath(), stringify(Array.from(this.data.entries())));
+  }
+  set(key, value) {
+    key = sanitizeKey(key);
+    if (!key) return handleError('set', 'a key');
+    this.data.set(key, value);
+    return this.persist();
+  }
+  remove(key) {
+    key = sanitizeKey(key);
+    if (!key) return handleError('remove', 'a key');
+    this.data.delete(key);
+    return this.persist();
+  }
+  getAllKeysSync(){
+    return Array.from(this.data.keys());
+  }
+  getItem(key){
+    return FileSystem.readAsStringAsync(`${this.getPath()}${key}`);
+  }
+}
+
+
+const storage = new Storage();
+
+storage.init();
+
+export default storage;

package/src/session/native.old/index.js

@@ -0,0 +1,79 @@
+// Copyright 2022 @fto-consult/Boris Fouomene. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*** for usage, @see : https://github.com/raphaelpor/sync-storage 
+  @see : https://github.com/echowaves/expo-storage
+*/
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import isPromise from "$cutils/isPromise";
+import {handleError} from './helpers';
+import {stringify} from "$cutils/json";
+import { sanitizeKey } from '../utils';
+
+let currentInitSession = undefined;
+
+export const isInitialized = x=> isPromise(currentInitSession);
+
+class SyncAsyncStorage {
+  data = new Map();
+  loading = true;
+
+  init() {
+    if(isInitialized()){
+      return currentInitSession;
+    }
+    currentInitSession = AsyncStorage.getAllKeys().then((keys) =>
+      AsyncStorage.multiGet(keys).then((data) => {
+        data.forEach(this.saveItem.bind(this));
+        this.isInitialized = true;
+        return [...this.data];
+      }),
+    );
+    return currentInitSession;
+  }
+
+  get(key) {
+    return this.data.get(sanitizeKey(key));
+  }
+
+  set(key, value) {
+    key = sanitizeKey(key);
+    if (!key) return handleError('set', 'a key');
+    this.data.set(key, value);
+    value = stringify(value);
+    return AsyncStorage.setItem(key, value).then((v)=>{return {[key]:value}});
+  }
+
+  remove(key) {
+    key = sanitizeKey(key);
+    if (!key) return handleError('remove', 'a key');
+
+    this.data.delete(key);
+    return AsyncStorage.removeItem(key);
+  }
+
+  saveItem(item) {
+    let value;
+
+    try {
+      value = JSON.parse(item[1]);
+    } catch (e) {
+      [, value] = item;
+    }
+
+    this.data.set(item[0], value);
+    this.loading = false;
+  }
+
+  getAllKeys(){
+    return Array.from(this.data.keys());
+  }
+}
+
+
+const syncAsyncStorage = new SyncAsyncStorage();
+
+syncAsyncStorage.init();
+
+export default syncAsyncStorage;

package/src/session/native.old/index.native.js

@@ -0,0 +1,14 @@
+// Copyright 2022 @fto-consult/Boris Fouomene. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+import { handleGetValue,handleSetValue } from './utils'
+import storage from "./native";
+const get = key => handleGetValue(storage.get(key))
+const set = (key,value,decycle)=>{
+    return Promise.resolve(storage.set(key,handleSetValue(value,decycle)));
+}
+
+export default {get,set};
+
+export {get,set}

package/src/context/init-sqlite/index.js

@@ -1,2 +0,0 @@
-export default function initSQLite(){
-}

package/src/context/init-sqlite/index.native.js

@@ -1,9 +0,0 @@
-import * as FileSystem from 'expo-file-system';
-export default function initSQLite (){
-    const createD = ()=>FileSystem.makeDirectoryAsync(FileSystem.documentDirectory + 'SQLite').catch(e=>{});
-    return FileSystem.getInfoAsync(FileSystem.documentDirectory + 'SQLite').then((info)=>{
-      if(!info?.exists){
-        createD();
-      }
-    }).catch(createD);
-}