esoftplay 0.0.136-g → 0.0.136-i

package/global.ts

@@ -17,18 +17,31 @@ export interface useGlobalAutoSync {
   post: (item: any) => Object,
   isSyncing?: (isSync: boolean) => void
 }
+interface useGlobalOptionA {
+  persistKey?: string;
+  inFastStorage?: boolean;
+  inFile?: never; // Ensures inFile is not present in useGlobalOptionA
+  listener?: (data: any) => void;
+  useAutoSync?: useGlobalAutoSync;
+  jsonBeautify?: boolean;
+  isUserData?: boolean;
+  loadOnInit?: boolean;
+  onFinish?: () => void;
+}
 
-export interface useGlobalOption {
-  persistKey?: string,
-  inFile?: boolean,
-  listener?: (data: any) => void,
-  useAutoSync?: useGlobalAutoSync,
-  jsonBeautify?: boolean,
-  isUserData?: boolean,
-  loadOnInit?: boolean,
-  onFinish?: () => void
+interface useGlobalOptionB {
+  persistKey?: string;
+  inFile?: boolean;
+  inFastStorage?: never; // Ensures inFastStorage is not present in useGlobalOptionB
+  listener?: (data: any) => void;
+  useAutoSync?: useGlobalAutoSync;
+  jsonBeautify?: boolean;
+  isUserData?: boolean;
+  loadOnInit?: boolean;
+  onFinish?: () => void;
 }
 
+export type useGlobalOption = useGlobalOptionA | useGlobalOptionB;
 export interface useGlobalConnect<T> {
   render: (props: T) => any,
 }
@@ -44,7 +57,10 @@ export default function useGlobalState<T>(initValue: T, o?: useGlobalOption): us
   let sync: any = undefined
 
   if (o?.persistKey) {
-    STORAGE = o?.inFile ? (require('esoftplay/storage').default) : (require('@react-native-async-storage/async-storage').default)
+    if (o?.inFastStorage == true) {
+      STORAGE = require('esoftplay/mmkv').default
+    } else
+      STORAGE = o?.inFile ? (require('esoftplay/storage').default) : (require('@react-native-async-storage/async-storage').default)
     loaded = 0
     if (o?.loadOnInit)
       loadFromDisk()
@@ -82,33 +98,32 @@ export default function useGlobalState<T>(initValue: T, o?: useGlobalOption): us
     })[0]
   }
 
-  function loadFromDisk() {
+  async function loadFromDisk() {
     if (loaded == 0) {
       loaded = 1
       let persistKey = o?.persistKey
-      STORAGE.getItem(String(persistKey)).then((p: any) => {
-        if (p) {
-          if (persistKey != '__globalReady')
-            if (p != undefined && typeof p == 'string' && (p.startsWith("{") || p.startsWith("[")))
-              try { set(JSON.parse(p)) } catch (error) { }
-            else {
-              if (p == "true" || p == "false") {
-                try { /* @ts-ignore */ set(eval(p)) } catch (error) { }
-              } else if (isNaN(p)) {
-                try { /* @ts-ignore */ set(p) } catch (error) { }
-              } else {
-                try { /* @ts-ignore */ set(eval(p)) } catch (error) { }
-              }
+      const p = await STORAGE.getItem(String(persistKey))
+      if (p) {
+        if (persistKey != '__globalReady')
+          if (p != undefined && typeof p == 'string' && (p.startsWith("{") || p.startsWith("[")))
+            try { set(JSON.parse(p)) } catch (error) { }
+          else {
+            if (p == "true" || p == "false") {
+              try { /* @ts-ignore */ set(eval(p)) } catch (error) { }
+            } else if (isNaN(p)) {
+              try { /* @ts-ignore */ set(p) } catch (error) { }
+            } else {
+              try { /* @ts-ignore */ set(eval(p)) } catch (error) { }
             }
-        }
-        if (o?.onFinish) {
+          }
+      }
+      if (o?.onFinish) {
+        clearTimeout(timeoutFinish)
+        timeoutFinish = setTimeout(() => {
+          o.onFinish?.()
           clearTimeout(timeoutFinish)
-          timeoutFinish = setTimeout(() => {
-            o.onFinish?.()
-            clearTimeout(timeoutFinish)
-          }, 50);
-        }
-      })
+        }, 50);
+      }
     }
   }
 
@@ -166,7 +181,7 @@ export default function useGlobalState<T>(initValue: T, o?: useGlobalOption): us
     set(initValue)
   }
 
-  function useSelector(se: (state: T) => any): void {
+  async function useSelector(se: (state: T) => any): void {
     loadFromDisk()
 
     let [l, s] = R.useState<any>(se(value));

package/mmkv.d.ts

@@ -0,0 +1,2 @@
+import FastStorage from "./mmkv";
+export default FastStorage

package/mmkv.ts

@@ -0,0 +1,20 @@
+import { MMKV } from 'react-native-mmkv';
+
+const storage = new MMKV()
+
+const FastStorage = {
+  getItem(key: string): string | undefined {
+    return storage.getString(key)
+  },
+  setItem(key: string, value: string) {
+    storage.set(key, value)
+  },
+  async removeItem(key: string) {
+    storage.delete(key)
+  },
+  clear(): void {
+    storage.clearAll()
+  },
+};
+
+export default FastStorage;

package/modules/lib/lazy.tsx

@@ -1,67 +1,73 @@
 // withHooks
 // noPage
 
-import { UseTasks } from 'esoftplay/cache/use/tasks/import';
-import useGlobalState from 'esoftplay/global';
 import useSafeState from 'esoftplay/state';
-import { startTransition, useEffect } from 'react';
+import { useEffect } from 'react';
 import { InteractionManager } from 'react-native';
 
 export interface LibLazyProps {
   children?: any;
 }
 
-const renderList = useGlobalState<Function[]>([])
-const useTasks = UseTasks<Function>()
+// const renderList = useGlobalState<Function[]>([])
+// const useTasks = UseTasks<Function>()
 
-let timeoutId: NodeJS.Timeout;
-function debounce(cb: () => void, delay: number) {
-  clearTimeout(timeoutId);
-  timeoutId = setTimeout(function () {
-    cb()
-  }, delay);
-}
-let timeoutIdB: NodeJS.Timeout;
-function debounceB(cb: () => void, delay: number) {
-  clearTimeout(timeoutIdB);
-  timeoutIdB = setTimeout(function () {
-    cb()
-  }, delay);
-}
+// let timeoutId: NodeJS.Timeout;
+// function debounce(cb: () => void, delay: number) {
+//   clearTimeout(timeoutId);
+//   timeoutId = setTimeout(function () {
+//     cb()
+//   }, delay);
+// }
+// let timeoutIdB: NodeJS.Timeout;
+// function debounceB(cb: () => void, delay: number) {
+//   clearTimeout(timeoutIdB);
+//   timeoutIdB = setTimeout(function () {
+//     cb()
+//   }, delay);
+// }
 
 export default function m(props: LibLazyProps): any {
   const [done, setDone] = useSafeState(false);
-  const [sync] = useTasks((item) => new Promise((next) => {
-    InteractionManager.runAfterInteractions(() => {
-      startTransition(() => {
-        item(true)
-       const timer = setTimeout(() => {
-          next()
-          clearTimeout(timer)
-        }, 50);
-      })
-    })
-  }))
-
-  useEffect(() => {
-    if (done) {
-      debounceB(() => {
-        sync(renderList.get())
-      }, 100);
-    }
-  }, [done])
 
   useEffect(() => {
-    renderList.set((x) => [...x, setDone])
-    debounce(() => {
-      sync(renderList.get())
-    }, 100);
-    return () => {
-      renderList.set((x) => x.filter((c) => c !== setDone))
-    }
+    const int = InteractionManager.runAfterInteractions(() => {
+      setDone(true)
+    })
+    return () => int.cancel()
   }, [])
 
-  return done ? props.children ?? null : null;
+  // const [sync] = useTasks((item) => new Promise((next) => {
+  //   InteractionManager.runAfterInteractions(() => {
+  //     startTransition(() => {
+  //       item(true)
+  //       const timer = setTimeout(() => {
+  //         next()
+  //         clearTimeout(timer)
+  //       }, 50);
+  //     })
+  //   })
+  // }))
+
+  // useEffect(() => {
+  //   if (done) {
+  //     debounceB(() => {
+  //       sync(renderList.get())
+  //     }, 100);
+  //   }
+  // }, [done])
+
+  // useEffect(() => {
+  //   renderList.set((x) => [...x, setDone])
+  //   debounce(() => {
+  //     sync(renderList.get())
+  //   }, 100);
+  //   return () => {
+  //     renderList.set((x) => x.filter((c) => c !== setDone))
+  //   }
+  // }, [])
+
+  return done ? (props.children ?? null) : null;
 }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esoftplay",
-  "version": "0.0.136-g",
+  "version": "0.0.136-i",
   "description": "embedding data from esoftplay framework (web based) into mobile app",
   "main": "cache/index.js",
   "types": "../../index.d.ts",