esoftplay-event 0.0.0-n → 0.0.0-p

package/modules/use/dates.tsx

@@ -0,0 +1,20 @@
+// useLibs  
+// noPage
+
+import { useMemo } from 'react';
+
+export interface UseDatesProps {
+  year: number,
+  month: number
+}
+
+export default function m(props: UseDatesProps): [number[], number] {
+  const d = useMemo<[number[], number]>(() => {
+    let month = props.month - 1
+    const a = new Date(props.year, month + 1, 0).getDate();
+    const b = new Date(props.year, month, 1).getDay();
+    const c = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31].slice(0, a)
+    return [c, b]
+  }, [props])
+  return d
+}

package/modules/use/keep.tsx

@@ -0,0 +1,17 @@
+// useLibs  
+// noPage
+import useSafeState from 'esoftplay/state';
+
+import { useCallback, useMemo, useRef } from 'react';
+
+export default function m<T>(def?: T): [T, () => void] {
+  let a = useRef<T | any>({})
+  a.current = useMemo(() => def, [])
+  const [b, c] = useSafeState(0)
+
+  const d = useCallback(() => {
+    c(b + 1)
+  }, [])
+
+  return [a.current, d]
+}

package/modules/use/location.ts

@@ -0,0 +1,59 @@
+//useLibs
+
+import esp from "esoftplay/esp"
+import useLazyState from "esoftplay/lazy"
+import { useEffect } from "react"
+
+//type 1:provinsi 2:kota 3:kecamatan
+export default function m(query: string, type?: string): [any[], boolean, string] {
+  type = type || "2"
+  const [data, setData] = useLazyState<any>()
+  const [error, setError] = useLazyState<string>("")
+  const [isLoading, setIsLoading] = useLazyState<boolean>(false)
+  const countryCode = esp.isDebug("location country") ? esp.modProp("user/location_gps").currentCountryState.useSelector((s: any) => s?.code) : ""
+
+  useEffect(() => {
+    get(type, query)
+  }, [query, countryCode])
+
+  const get = (type: string, query: string) => {
+    const baseURL = "v3/location"
+
+    if (query == "") {
+      setData(undefined)()
+    }
+
+    if (!type || !query || !countryCode) {
+      return
+    }
+
+    const buildURL = (url: string) => {
+      if (type) {
+        url += url.includes('?') ? '&' : '?'
+        url += 'type=' + type
+      }
+      if (query) {
+        url += url.includes('?') ? '&' : '?'
+        url += 'keyword=' + query
+      }
+      if (countryCode) {
+        url += url.includes('?') ? '&' : '?'
+        url += 'country_code=' + countryCode
+      }
+      return url
+    }
+
+    setIsLoading(true)()
+    const curl = esp.mod("lib/curl")
+    new curl(buildURL(baseURL), null, (result) => {
+      setData(result?.list)()
+      setIsLoading(false)()
+    }, (error) => {
+      setData(undefined)()
+      setError(error?.message)()
+      setIsLoading(false)()
+    }, 1)
+  }
+
+  return [data, isLoading, error]
+}

package/modules/use/notif.ts

@@ -0,0 +1,32 @@
+// useLibs  
+// noPage
+
+import { UserNotification } from 'esoftplay/cache/user/notification/import';
+import { UserProfileProperty } from 'esoftplay/cache/user/profile/import';
+
+import * as Notifications from 'expo-notifications';
+import { useEffect } from "react";
+import { AppStateStatus, Platform } from 'react-native';
+
+export default function m(): void {
+  const counter = UserNotification.state().useSelector(s => s.unread)
+  useEffect(() => {
+    // const x = AppState.addEventListener("change", onAppStateChange)
+    // return () => x.remove()
+  }, [])
+
+  useEffect(() => {
+    if (Platform.OS == "ios") {
+      Notifications.setBadgeCountAsync(counter)
+    }
+  }, [counter])
+
+  function onAppStateChange(state: AppStateStatus) {
+    if (state == 'active') {
+      UserProfileProperty.update()
+      if (Platform.OS == "ios") {
+        Notifications.setBadgeCountAsync(counter)
+      }
+    }
+  }
+}

package/modules/use/paginate.tsx

@@ -0,0 +1,224 @@
+// useLibs
+
+import { LibIcon } from "esoftplay/cache/lib/icon/import";
+import { LibNet_status } from "esoftplay/cache/lib/net_status/import";
+import { LibStyle } from "esoftplay/cache/lib/style/import";
+import esp from "esoftplay/esp";
+import useLazyState from "esoftplay/lazy";
+import FastStorage from "esoftplay/mmkv";
+import useGlobalSubscriber from "esoftplay/subscribe";
+import { useEffect, useLayoutEffect } from "react";
+import { InteractionManager, Text, View } from "react-native";
+import Animated, { Easing, useAnimatedStyle, useSharedValue, withRepeat, withTiming } from "react-native-reanimated";
+
+export interface UsePaginateProps { }
+
+function LoadingView() {
+  const progress = useSharedValue(0);
+
+  useEffect(() => {
+    progress.value = withRepeat(
+      withTiming(1, {
+        duration: 2000,
+        easing: Easing.linear,
+      }),
+      -1,
+      false
+    );
+  }, [progress]);
+
+  const animatedStyle = useAnimatedStyle(() => ({
+    width: `${progress.value * 100}%`,
+  }));
+
+  return (
+    <View style={{ flex: 1, alignItems: "center", justifyContent: "center" }}>
+      <LibIcon.Ionicons name='cloud-download-outline' size={LibStyle.width * 0.2} color={"#aeacb2"} />
+      <View style={{ marginTop: 20, width: LibStyle.width - 100, height: 10, backgroundColor: '#f2f2f2', borderRadius: 10, overflow: 'hidden' }}>
+        <Animated.View style={[{ height: '100%', backgroundColor: "#908d94", borderRadius: 10 }, animatedStyle]} />
+      </View>
+      <View style={{ marginHorizontal: 20, marginTop: 10 }}>
+        <Text allowFontScaling={false} style={{ fontSize: 14, textAlign: "center" }}>{"Mohon tunggu, sedang mengunduh data.."}</Text>
+      </View>
+    </View>
+  )
+}
+
+const listen = useGlobalSubscriber()
+
+export default function m(url: string, post?: any, isUserData?: boolean, filterData?: (cache: any) => any[]): [any[], () => void, boolean, () => JSX.Element | null] {
+  const tsKey = `usePaginateTimestamp-${url}`
+  const dataKey = `usePaginate-${url}`
+  const stopKey = `usePaginateStop-${url}`
+  const tempDataKey = `usePaginateDataTemp-${url}`
+
+  if (isUserData) esp.mod('user/data').multiRegister([tsKey, dataKey, stopKey, tempDataKey])
+
+  const ctime = new Date();
+  const ts = (ctime.getTime() / 1000).toFixed(0);
+  const timestamp = FastStorage.getItemSync(tsKey);
+  const cache = FastStorage.getItemSync(dataKey);
+  const s = FastStorage.getItemSync(stopKey);
+  const [status] = LibNet_status.state().useState()
+
+  const [stop, setStop] = useLazyState<boolean>(s ? JSON.parse(s) : false);
+  const [data, set, get] = useLazyState<any>(cache ? (Array.isArray(cache) ? cache : JSON.parse(cache)) : []);
+
+  useLayoutEffect(() => {
+    if (status?.isOnline == true && status?.isInternetReachable == true) {
+      loadData();
+    }
+  }, [status]);
+
+  listen.useSubscribe(() => {
+    const cache = JSON.parse(FastStorage.getItemSync(dataKey))
+    set(cache)()
+  })
+
+  function setData(cdata: any) {
+    set(cdata)()
+    FastStorage.setItem(dataKey, JSON.stringify(cdata));
+    if (cdata.length > 0) {
+      listen.trigger()
+    }
+  }
+
+  function stopSet(status: boolean) {
+    setStop(status)()
+    FastStorage.setItem(stopKey, JSON.stringify(status))
+  }
+
+  function loadData(page: number = 0) {
+    const time = FastStorage.getItemSync(tsKey);
+    const temp = FastStorage.getItemSync(tempDataKey)
+    const tempData = temp != undefined ? JSON.parse(temp) : []
+    const curr = FastStorage.getItemSync(dataKey)
+    const currData = curr != undefined ? JSON.parse(curr) : []
+
+    if (stop == false && page == 0 && time) {
+      return
+    }
+
+    if (time && tempData.length == 0 && currData.length > 0) {
+      url += url.includes('?') ? '&' : '?'
+      url += 'updates=' + time
+    }
+
+    const fixedUrl = `${url}${url.includes("?") ? "&" : "?"}page=${page}`;
+    const LibCurl = esp.mod("lib/curl")
+    new LibCurl(fixedUrl, post, (result) => {
+      if (page === 0) {
+        FastStorage.setItem(tsKey, ts.toString());
+      }
+      if (result?.list)
+        if (result?.list?.length === 0) {
+          stopSet(true)
+        } else {
+          const res = result;
+
+          if (!timestamp) {
+            const od = FastStorage.getItemSync(tempDataKey)
+            const oldData = od != undefined ? JSON.parse(od) : []
+            const updatedData = esp.mod('lib/object').push(oldData, ...res.list)();
+            FastStorage.setItem(tempDataKey, JSON.stringify(updatedData))
+          } else {
+            const oldData = get();
+            let newData = oldData;
+            res.list.forEach((item: any) => {
+              const fIndex = oldData.findIndex((x: any) => x.id == item.id)
+              if (fIndex > -1) {
+                newData = esp.mod('lib/object').replaceItem(newData, (x: any) => x.id === item.id, item)();
+              } else {
+                newData = esp.mod('lib/object').push(newData, item)()
+              }
+            });
+            setData(newData)
+          }
+
+          const od = FastStorage.getItemSync(tempDataKey)
+          const oldData = od != undefined ? JSON.parse(od) : []
+          if (!timestamp && oldData?.length == result?.total) {
+            setData(oldData)
+            FastStorage.removeItem(tempDataKey)
+          }
+
+          if ((result.pages - 1) === page) {
+            stopSet(true)
+          }
+
+          if (!stop) {
+            InteractionManager.runAfterInteractions(() => {
+              loadData(page + 1);
+            });
+          }
+        }
+    }, (error) => {
+      stopSet(true)
+      if (timestamp) {
+        findDiff();
+      }
+    });
+  }
+
+  function fetchDataCount(start_id: string, end_id: string, onResult: (result: any) => void) {
+    const LibCurl = esp.mod("lib/curl")
+    new LibCurl(`${url}?start_id=${start_id}&end_id=${end_id}`, null, (res) => {
+      onResult(res);
+    }, (err) => {
+
+    });
+  }
+
+  function findDiff() {
+    const val = FastStorage.getItemSync(dataKey);
+    const cache = val ? Array.isArray(val) ? val : JSON.parse(val) : [];
+    const _cacheID: [] = filterData ? filterData(cache) : cache;
+    const cacheID = _cacheID.map((c: any) => c.id).sort((a, b) => a - b)
+
+    if (cache.length > 0) {
+      sync(cacheID);
+    }
+  }
+
+  function sync(data: any[], left = 0, right = data.length - 1, useFullRange = true) {
+    if (left > right) {
+      return;
+    }
+
+    let startId, endId;
+    if (useFullRange) {
+      startId = data[0];
+      endId = data[data.length - 1];
+    } else {
+      const mid = Math.floor((left + right) / 2);
+      startId = data[left];
+      endId = data[mid];
+    }
+
+    fetchDataCount(startId, endId, (result: any) => {
+      const expectedLength = useFullRange ? data.length : (Math.floor((left + right) / 2) - left + 1);
+      if (result.total === 0) {
+        removeItem(startId);
+      } else if (result.total === expectedLength) {
+        if (!useFullRange) {
+          if (Math.floor((left + right) / 2) < right) {
+            sync(data, Math.floor((left + right) / 2) + 1, right, false);
+          }
+        }
+      } else {
+        sync(data, left, Math.floor((left + right) / 2) - 1, false);
+        sync(data, Math.floor((left + right) / 2) + 1, right, false);
+      }
+    });
+  }
+
+  function removeItem(id: string | number) {
+    const val = FastStorage.getItemSync(dataKey);
+    const cache = JSON.parse(val);
+    const findIndex = cache.findIndex((c: any) => c.id === id);
+    const updatedData = esp.mod('lib/object').splice(cache, findIndex, 1)();
+    setData(updatedData)
+  }
+
+  return [data, loadData, !stop, LoadingView];
+}

package/modules/use/secure_page.tsx

@@ -0,0 +1,33 @@
+// useLibs
+
+import { UserClass } from 'esoftplay/cache/user/class/import';
+import { useEffect } from 'react';
+import RNPrevent from "react-native-screenshot-prevent";
+
+export interface UseSecure_pageProps {
+
+}
+export default function m(): any {
+  const can_screencapture = UserClass.state().get('config', 'can_screencapture')
+  // const focus = useIsFocused()
+
+  useEffect(() => {
+    let subs: any
+    if (!__DEV__)
+      if (can_screencapture != 1) {
+        RNPrevent?.enabled?.(true)
+        RNPrevent?.enableSecureView?.()
+        // subs = RNPrevent?.addListener?.(() => { })
+      }
+    return () => {
+      if (!__DEV__)
+        if (can_screencapture != 1) {
+          RNPrevent?.disableSecureView?.()
+          RNPrevent?.enabled?.(false)
+          // subs?.remove?.()
+        }
+    }
+  }, [])
+
+  return null
+}

package/modules/use/smartnotif.ts

@@ -0,0 +1,72 @@
+// useLibs
+
+import { LibNotification } from "esoftplay/cache/lib/notification/import";
+import { LibObject } from "esoftplay/cache/lib/object/import";
+import { LibUtils } from "esoftplay/cache/lib/utils/import";
+import useGlobalState, { useGlobalReturn } from "esoftplay/global";
+import moment from "esoftplay/moment";
+import { useEffect } from "react";
+
+
+export interface UseSmartnotifProps {
+
+}
+
+export interface UseSmartnotifParams {
+  title: string,
+  message: string,
+  url: string,
+  module: string,
+  delayInMinute: number,
+  arguments?: any
+}
+
+const state = useGlobalState({}, { persistKey: 'use/smartnotiflist' })
+
+export function listState(): useGlobalReturn<Object> {
+  return state
+}
+
+export default function UseSmartnotif(params: UseSmartnotifParams, autoSetByDebounceTime?: number): Function {
+
+  useEffect(() => {
+    let timeout: NodeJS.Timeout
+    if (autoSetByDebounceTime) {
+      timeout = setTimeout(set, autoSetByDebounceTime);
+    }
+    return () => clearTimeout(timeout)
+  }, [])
+
+  const set = () => {
+    const key = LibUtils.shorten(JSON.stringify(params));
+    const exp = moment().add(params.delayInMinute, 'minutes').toMiliseconds()
+
+    if (!state.get(key)) {
+      /* set local notification */
+      LibNotification.setLocalNotification(
+        'default',
+        { message: params?.message, title: params?.title, module: params?.module, url: params?.url, arguments: params?.arguments },
+        { delayInMinutes: params?.delayInMinute },
+        (notif_id: string) => {
+          state.set(LibObject.set(state.get(), { expired: exp, notif_id })(key));
+        }
+      )
+    } else {
+      /* remove expired and cancel notif identifier */
+      removeExpired()
+    }
+  }
+
+  const removeExpired = () => {
+    const data: any = state.get()
+    Object.values(data).forEach((t: any, i: number) => {
+      if (t?.expired < new Date().getTime()) {
+        const index = Object.keys(data)[i]
+        state.set(LibObject.unset(state.get(), index)())
+        LibNotification.cancelLocalNotification(t?.notif_id)
+      }
+    })
+  }
+
+  return set
+}

package/modules/use/test.ts

@@ -0,0 +1,178 @@
+// useLibs  
+// noPage
+
+import { LibNavigation } from 'esoftplay/cache/lib/navigation/import';
+import useSafeState from 'esoftplay/state';
+
+import { useEffect, useRef } from "react";
+
+export interface UseTestReturn {
+  fail: (data: any) => void,
+  pass: (data: any) => void,
+  execAndPass: (func: Function, params?: any[]) => void,
+  execState: (setState: any, val: any) => void,
+  waitRef: (refs: any[]) => void,
+  setInput: (ref: any, v: string) => void,
+  setTasks: (tasks: any[]) => void
+}
+// execAndThen: (func: any, params?: any[], then?: (value: any) => void) => void,
+
+export default function m(props: any, name: string): UseTestReturn {
+  const helper = useRef(new Helper()).current
+  const { isRunTest } = LibNavigation.getArgsAll(props) || props
+  let report = useRef<any[]>([]).current
+  const [copyState, setCopyState] = useSafeState('noHistoryOfCopyState')
+
+  function runNextTask() {
+    if (isRunTest) {
+      const ctask = helper.getTasks()[helper.getId()]
+      if (ctask && typeof ctask[0] == 'function') {
+        if (ctask.length == 2)
+          ctask[0](...ctask[1])
+        else if (ctask.length == 1) {
+          ctask[0]()
+        }
+      } else {
+
+      }
+    }
+  }
+
+  function setInput(ref: any, v: string): void {
+    if (ref?.current) {
+      ref?.current?.setText?.(v)
+    } else {
+      ref?.setText?.(v)
+    }
+  }
+
+  function waitRef(refs: any[]): void {
+
+    helper.setRefs(refs)
+    if (isRunTest) {
+      let arrRef = []
+      for (let i = 0; i < helper.getRefs().length; i++) {
+        const element = helper.getRefs()[i];
+        arrRef.push(!!element.current)
+      }
+      if (arrRef.some((x) => !x))
+        setTimeout(() => {
+          waitRef(helper.getRefs())
+        }, 300);
+      else
+        pass('refs is ready')
+    }
+  }
+
+  function execAndPass(func: any, params?: any[]): void {
+    if (typeof func == 'function') {
+      if (params)
+        pass(func(...params))
+      else
+        pass(func())
+    } else {
+      pass(func)
+    }
+  }
+  function execAndThen(func: any, params?: any[], then?: (value: any) => void): void {
+    if (typeof func == 'function') {
+      if (params)
+        func(...params).then(then)
+      else
+        func().then(then)
+    }
+  }
+
+  function execState(func: any, val: any): void {
+    func(val)
+    setTimeout(() => {
+      setCopyState(val)
+    }, 200);
+  }
+
+  function pass(data?: any): void {
+    if (isRunTest) {
+      report.push(data)
+      helper.updateId()
+      next()
+    }
+  }
+
+  function fail(data: any) {
+    if (isRunTest) {
+    }
+  }
+
+  function next() {
+    if (helper.getTasks().length != 0 && helper.getId() > -1) {
+      runNextTask()
+    }
+  }
+
+  function setTasks(task: any[]) {
+    if (isRunTest) {
+      helper.setTasks(task)
+    }
+  }
+
+  useEffect(() => {
+    if (helper.getTasks().length > 0 && helper.getId() == -1) {
+      helper.updateId()
+      next()
+    }
+  }, [])
+
+  useEffect(() => {
+    if (copyState != 'noHistoryOfCopyState')
+      pass(copyState)
+  }, [copyState])
+
+  return {
+    fail,
+    pass,
+    execAndPass,
+    waitRef,
+    setInput,
+    execState,
+    setTasks
+  }
+}
+
+class Helper {
+  task: any[] = []
+  idx = -1
+  refs: any[] = []
+
+  constructor() {
+    this.getId = this.getId.bind(this);
+    this.getTasks = this.getTasks.bind(this);
+    this.updateId = this.updateId.bind(this);
+    this.setTasks = this.setTasks.bind(this);
+    this.getRefs = this.getRefs.bind(this)
+    this.setRefs = this.setRefs.bind(this)
+  }
+
+  getRefs(): any[] {
+    return this.refs
+  }
+
+  setRefs(refs: any[]): void {
+    this.refs = refs
+  }
+
+  getId(): number {
+    return this.idx
+  }
+
+  updateId(): void {
+    this.idx += 1
+  }
+
+  getTasks(): any {
+    return this.task
+  }
+
+  setTasks(tasks: any[]): void {
+    this.task = tasks
+  }
+}