esoftplay 0.0.142 → 0.0.143

package/bin/build.js

@@ -267,6 +267,7 @@ npm-debug.*\n\
 package-lock.json\n\
 assets/esoftplaymodules/\n\
 bun.lockb\n\
+bun.lock\n\
 yarn.lock\n\
 yarn-error.log\n\
 			`

package/bin/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 const fs = require('fs');
 const exec = require('child_process').execSync;
-
+const fetch = require("node-fetch")
 const path = require('path');
+const https = require('https');
 const os = require('os')
 const readline = require('readline');
 const DIR = "./"
@@ -23,10 +24,15 @@ const gplistdebug = DIR + "GoogleService-Info.debug.plist"
 var args = process.argv.slice(2);
 
 // console.log(modpath, "sdofsjdofjsd")
-function execution() {
-	const cmd = `watchman watch-del ./ && watchman watch ./ && watchman -j <<< '["trigger","./",{"name":"esp","expression":["allof",["not",["dirname","node_modules"]],["not",["name","index.d.ts"]]],"command":["bun","./node_modules/esoftplay/bin/router.js"],"append_files":true}]' && bun ./node_modules/esoftplay/bin/run.js && bun ./node_modules/esoftplay/bin/gen.js && bun ./node_modules/esoftplay/bin/router.js`
-	command(cmd)
-
+async function execution() {
+	const preload = await preload_api()
+	console.log("PRELOAD", preload)
+	if (preload) {
+		const cmd = `watchman watch-del ./ && watchman watch ./ && watchman -j <<< '["trigger","./",{"name":"esp","expression":["allof",["not",["dirname","node_modules"]],["not",["name","index.d.ts"]]],"command":["bun","./node_modules/esoftplay/bin/router.js"],"append_files":true}]' && bun ./node_modules/esoftplay/bin/run.js && bun ./node_modules/esoftplay/bin/gen.js && bun ./node_modules/esoftplay/bin/router.js`
+		command(cmd)
+	} else {
+		console.log("SINI GAES")
+	}
 }
 
 if (args.length == 0) {
@@ -535,7 +541,149 @@ function isCustomUpdates() {
 	return false
 }
 
-function publish(notes) {
+async function preload_api() {
+	let out = true
+	let cjson = await readToJSON(confjson)
+	const { protocol, domain, uri, preload_api } = cjson.config
+	if (preload_api?.length > 0) {
+		fs.rmSync("./assets/preload_api", { recursive: true, force: true })
+		fs.rmSync("./assets/preload_assets", { recursive: true, force: true })
+		for (const apiUri of preload_api) {
+			let fullUrl = apiUri.includes("://") ? apiUri : `${(protocol || 'http')}://api.${domain}${(uri || "/")}${apiUri}`
+			const lastString = fullUrl.slice(fullUrl.lastIndexOf("/") + 1) // Fixed index adjustment
+			try {
+				const data = await fetch(fullUrl).then((res) => res.text())
+				if (data) {
+					try {
+						if (JSON.parse(data).ok === 0) {
+							consoleError(`-> preload_api: ${fullUrl}`)
+							fs.writeFileSync(`./assets/preload_api/${lastString}.json`, data)
+							out = false
+							return out
+						}
+					} catch (error) {
+						fs.writeFileSync(`./assets/preload_api/${lastString}.json`, data)
+						consoleError(`-> preload_api: ${fullUrl}`)
+						out = false
+						return out
+					}
+					/* sukses */
+					if (!fs.existsSync("./assets/preload_api")) {
+						fs.mkdirSync('./assets/preload_api', { recursive: true })
+					}
+					fs.writeFileSync(`./assets/preload_api/${lastString}.json`, data)
+					let objectData = JSON.parse(data)
+
+					async function readDeepObject(obj, path = []) {
+						if (Array.isArray(obj)) {
+							obj.forEach(async (item, index) => {
+								await readDeepObject(item, [...path, index]);
+							});
+						} else if (typeof obj === "object" && obj !== null) {
+							Object.keys(obj).forEach(async (key) => {
+								await readDeepObject(obj[key], [...path, key]);
+							});
+						} else if (obj != undefined) {
+							const value = obj
+							var cursor = path.join(".")
+							if (/\.(jpg|jpeg|png|gif|bmp|webp|svg|pdf|txt)$/i.test(value)) {
+								const localFilePath = await downloadFile(value, "./assets/preload_assets/" + lastString)
+								objectData = LibObject.set(objectData, String(localFilePath)?.replace('assets/', ''))(cursor)
+								const newData = JSON.stringify(objectData, undefined, 2)
+								fs.writeFileSync(`./assets/preload_api/${lastString}.json`, newData, { encoding: "utf8" })
+							}
+						}
+					}
+
+					async function downloadFile(url, downloadDir = "./assets/preload_assets", retries = 3) {
+						if (!fs.existsSync(downloadDir)) {
+							fs.mkdirSync(downloadDir, { recursive: true });
+						}
+						const fileName = path.basename(url);
+						const filePath = path.join(downloadDir, fileName);
+
+						for (let attempt = 1; attempt <= retries; attempt++) {
+							try {
+								return await new Promise((resolve, reject) => {
+									const fileStream = fs.createWriteStream(filePath);
+									const request = https.get(url, (response) => {
+										if (response.statusCode !== 200) {
+											reject(new Error(`Failed to fetch ${url}: ${response.statusCode}`));
+											return;
+										}
+
+										response.pipe(fileStream);
+
+										fileStream.on('finish', () => {
+											fileStream.close(() => {
+												// Validate that file is not empty
+												if (fs.statSync(filePath).size > 0) {
+													resolve(filePath);
+												} else {
+													reject(new Error(`Downloaded file is empty: ${filePath}`));
+												}
+											});
+										});
+
+										fileStream.on('error', (error) => {
+											fileStream.close(() => reject(error));
+										});
+									});
+
+									request.on('error', (error) => reject(error));
+								});
+							} catch (error) {
+								console.error(`Attempt ${attempt} failed:`, error);
+								if (attempt === retries) {
+									return null; // Return null after final attempt
+								}
+							}
+						}
+					}
+					// async function downloadFile(url, downloadDir = "./assets/preload_assets") {
+					// 	if (!fs.existsSync("./assets/preload_assets")) {
+					// 		fs.mkdirSync("./assets/preload_assets")
+					// 	}
+					// 	try {
+					// 		const https = require('https');
+					// 		const fileName = path.basename(url);
+					// 		const filePath = path.join(downloadDir, fileName);
+					// 		const fileStream = fs.createWriteStream(filePath);
+
+					// 		return new Promise((resolve, reject) => {
+					// 			https.get(url, (response) => {
+					// 				if (response.statusCode !== 200) {
+					// 					reject(new Error(`Failed to fetch ${url}: ${response.statusCode}`));
+					// 					return;
+					// 				}
+					// 				response.pipe(fileStream);
+					// 				fileStream.on('finish', () => resolve(filePath));
+					// 				fileStream.on('error', reject);
+					// 			}).on('error', reject);
+					// 		});
+					// 	} catch (error) {
+					// 		console.error(`Error downloading file ${url}:`, error);
+					// 		return null;
+					// 	}
+					// }
+
+					await readDeepObject(objectData)
+					consoleSucces("-> preload_api: " + fullUrl)
+					/* endSukses */
+				}
+			} catch (error) {
+				out = false
+				consoleError(`-> preload_api: ${fullUrl}`)
+			}
+		}
+	}
+	return out
+}
+
+async function publish(notes) {
+	if (!await preload_api()) {
+		return consoleError("Preload API ada yg error, tidak bisa publish")
+	}
 	let status = "-"
 	let isCustomServer = false
 	let ajson = readToJSON(appjson)
@@ -1237,6 +1385,12 @@ function switchStatus(status) {
 				const [usr, pwd] = cjson.config.build
 				command(`eas logout && expect -c 'spawn eas login; expect "Email or username"; send "${usr}\r"; expect "Password"; send "${pwd}\r"; expect eof;'`)
 			}
+			if (cjson.config.hasOwnProperty('post_script')) {
+				eval(cjson.config.post_script)
+			}
+		}
+		if (valid) {
+
 		}
 	}
 	if (valid && fs.existsSync(gplist))
@@ -1255,6 +1409,173 @@ function tm(message) {
 	command("curl -d \"text=" + message + "&disable_web_page_preview=true&chat_id=-1001227788828\" 'https://api.telegram.org/bot112133589:AAFFyztZh79OsHRCxJ9rGCGpnxkcjWBP8kU/sendMessage'")
 }
 
+class LibObject {
+	#value = undefined;
+
+	constructor(array) {
+		this.#value = array;
+		this.value = this.value.bind(this);
+		this.push = this.push.bind(this);
+		this.unset = this.unset.bind(this);
+		this.unshift = this.unshift.bind(this);
+		this.set = this.set.bind(this);
+		this.splice = this.splice.bind(this);
+		this.update = this.update.bind(this);
+		this.assign = this.assign.bind(this);
+		this.cursorBuilder = this.cursorBuilder.bind(this);
+	}
+
+	cursorBuilder(command, array, value, ...values) {
+		return (cursor, ...cursors) => {
+			let pathToUpdate = [cursor, ...cursors].filter(x => x != undefined).join('.');
+			let allValues = [value, ...values].filter(x => x != undefined);
+			let spec = {};
+			if (pathToUpdate !== '') spec = { [pathToUpdate]: [command, ...allValues] };
+			else spec = [command, ...allValues];
+			this.#value = update(array, spec);
+			return this;
+		};
+	}
+
+	push(value, ...values) {
+		return this.cursorBuilder("push", this.#value, value, ...values);
+	}
+
+	unshift(value, ...values) {
+		return this.cursorBuilder("unshift", this.#value, value, ...values);
+	}
+
+	splice(index, deleteCount, value, ...values) {
+		return this.cursorBuilder("splice", this.#value, index, deleteCount, value, ...values);
+	}
+
+	unset(index, ...indexs) {
+		return this.cursorBuilder("unset", this.#value, index, ...indexs);
+	}
+
+	set(value) {
+		return this.cursorBuilder("set", this.#value, value);
+	}
+
+	update(callback) {
+		return this.cursorBuilder("batch", this.#value, callback);
+	}
+
+	assign(obj1) {
+		return this.cursorBuilder("assign", this.#value, deepCopy(obj1));
+	}
+
+	removeKeys(deletedItemKeys) {
+		return this.cursorBuilder("batch", this.#value, arr => _removeKeys(arr, deletedItemKeys));
+	}
+
+	replaceItem(filter, newItem) {
+		return this.cursorBuilder("batch", this.#value, arr => _replaceItem(arr, filter, newItem));
+	}
+
+	value() {
+		return this.#value;
+	}
+
+	static push(array, value, ...values) {
+		return cursorBuilder("push", array, value, ...values);
+	}
+
+	static unshift(array, value, ...values) {
+		return cursorBuilder("unshift", array, value, ...values);
+	}
+
+	static removeKeys(arrayOrObj, deletedItemKeys) {
+		return cursorBuilder("batch", arrayOrObj, arrOrObj => _removeKeys(arrOrObj, deletedItemKeys));
+	}
+
+	static replaceItem(arrayOrObj, filter, newItem) {
+		return cursorBuilder("batch", arrayOrObj, arrOrObj => _replaceItem(arrOrObj, filter, newItem));
+	}
+
+	static splice(array, index, deleteCount, value, ...values) {
+		return cursorBuilder("splice", array, index, deleteCount, value, ...values);
+	}
+
+	static unset(obj, index, ...indexs) {
+		return cursorBuilder("unset", obj, index, ...indexs);
+	}
+
+	static set(obj, value) {
+		return cursorBuilder("set", obj, value);
+	}
+
+	static update(obj, callback) {
+		return cursorBuilder("batch", obj, callback);
+	}
+
+	static assign(obj, obj1) {
+		return cursorBuilder("assign", obj, deepCopy(obj1));
+	}
+}
+
+function cursorBuilder(command, array, value, ...values) {
+	const update = require('immhelper').default
+	return function (cursor, ...cursors) {
+		let pathToUpdate = [cursor, ...cursors].filter(x => x != undefined).join('.');
+		let allValues = [value, ...values].filter(x => x != undefined);
+		let spec = {};
+		if (pathToUpdate !== '') spec = { [pathToUpdate]: [command, ...allValues] };
+		else spec = [command, ...allValues];
+		return update(array, spec);
+	};
+}
+
+function _removeKeys(objOrArr, keysToRemove) {
+	if (Array.isArray(objOrArr)) {
+		return objOrArr.map(obj => {
+			let newObj = { ...obj };
+			keysToRemove.forEach(key => {
+				delete newObj[key];
+			});
+			return newObj;
+		});
+	} else {
+		let newObj = { ...objOrArr };
+		keysToRemove.forEach(key => {
+			delete newObj[key];
+		});
+		return newObj;
+	}
+}
+
+function _replaceItem(data, predicate, newItem) {
+	if (Array.isArray(data)) {
+		return data.map((item, index) => (predicate(item, index) ? newItem : item));
+	} else if (typeof data === 'object' && data !== null) {
+		let newData = { ...data };
+		Object.keys(newData).forEach((key, index) => {
+			if (predicate(newData[key], index)) {
+				newData[key] = newItem;
+			}
+		});
+		return newData;
+	} else return data;
+}
+
+function deepCopy(o) {
+	switch (typeof o) {
+		case 'object':
+			if (o === null) return null;
+			if (Array.isArray(o)) return o.map(item => deepCopy(item));
+			let newO = Object.create(Object.getPrototypeOf(o));
+			for (let key in o) {
+				if (Object.prototype.hasOwnProperty.call(o, key)) {
+					newO[key] = deepCopy(o[key]);
+				}
+			}
+			return newO;
+		default:
+			return o;
+	}
+}
+
+
 function help() {
 	console.log(
 		"\n\n PERINTAH YANG BISA DIGUNAKAN",

package/error.ts

@@ -1,4 +1,5 @@
 import Constants from 'expo-constants';
+import * as FileSystem from 'expo-file-system';
 import { Platform } from 'react-native';
 import { LibCurl } from './cache/lib/curl/import';
 import { UserClass } from './cache/user/class/import';
@@ -22,6 +23,7 @@ const myErrorHandler = (e: any, isFatal: any) => {
   defaultErrorHandler?.(e, isFatal)
 }
 
+/** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/error.md#setError) untuk melihat dokumentasi*/
 export function setError(error?: any) {
   const config = esp?.config?.();
   const routes = UserRoutes?.state()?.get?.();
@@ -36,12 +38,14 @@ export function setError(error?: any) {
   };
   try {
     FastStorage.setItem(`${config?.domain}error`, JSON.stringify(_e));
+    cleanCache()
   } catch (e) {
     console.error(e);
   }
 }
 
 
+/** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/error.md#reportApiError) untuk melihat dokumentasi*/
 export function reportApiError(fetch: any, error: any) {
   let routes = UserRoutes?.state?.()?.get?.()
   let lastIndex = routes?.routes?.length - 1 ?? 0
@@ -79,6 +83,7 @@ export function reportApiError(fetch: any, error: any) {
   }
 }
 
+/** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/error.md#sendTm) untuk melihat dokumentasi*/
 export function sendTm(message: string, chat_id?: string, bot?: string, res?: (result: any) => void): void {
   let _chatids: string[] = []
   if (chat_id) {
@@ -98,10 +103,12 @@ export function sendTm(message: string, chat_id?: string, bot?: string, res?: (r
   })
 }
 
+/** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/error.md#getError) untuk melihat dokumentasi*/
 export function getError() {
   let config = esp?.config?.()
   FastStorage.getItem(config?.domain + 'error').then((e: any) => {
     if (e) {
+      cleanCache()
       let _e = JSON.parse(e)
       let msg = [
         'slug: ' + "#" + expoConfig?.slug,
@@ -141,9 +148,18 @@ export function getError() {
           new LibCurl()?.custom?.('https://api.telegram.org/bot923808407:AAEFBlllQNKCEn8E66fwEzCj5vs9qGwVGT4/sendMessage', post)
         });
       }
-      // });
+
       FastStorage.removeItem(config.domain + 'error')
     }
   })
 }
+
+function cleanCache() {
+  try {
+    // try remove cache after errors
+    if (FileSystem.cacheDirectory) {
+      FileSystem.deleteAsync(FileSystem.cacheDirectory, { idempotent: true });
+    }
+  } catch (error) { }
+}
 ErrorUtils.setGlobalHandler(myErrorHandler)

package/esp.ts

@@ -54,7 +54,7 @@ try {
 }
 if (conf?.config?.isDebug == 0)
   LogBox.ignoreAllLogs();
-
+/** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/esp.md) untuk melihat dokumentasi*/
 const esp = {
   mergeDeep(target: any, ...sources: any[]) {
     target = Object(target);

package/global.ts

@@ -1,7 +1,12 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
 import esp from 'esoftplay/esp';
+import MMKV from 'esoftplay/mmkv';
+import Storage from 'esoftplay/storage';
 import * as R from 'react';
+import isEqual from 'react-fast-compare';
 import { createDebounce } from './timeout';
 
+
 export interface useGlobalReturn<T> {
   useState: () => [T, (newState: T | ((newState: T) => T)) => void, () => T],
   get: (param?: string, ...params: string[]) => T,
@@ -38,22 +43,28 @@ export interface useGlobalConnect<T> {
 }
 export let userDataReset: Function[] = []
 let timeoutFinish: NodeJS.Timeout
+
+/** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/global.md) untuk melihat dokumentasi*/
 export default function useGlobalState<T>(initValue: T, o?: useGlobalOption): useGlobalReturn<T> {
-  let STORAGE: any = undefined
-  const isEqual = require('react-fast-compare');
-  const subsSetter = new Set<Function>()
+  const STORAGE = o?.inFastStorage ? MMKV : (o?.inFile ? Storage : AsyncStorage);
   let value: T = initValue;
-  let listener = new Set<Function>()
-  let loaded = -1
-  let taskSync: any = undefined
-
-  if (o?.persistKey) {
-    STORAGE = o?.inFastStorage ? require('esoftplay/mmkv').default : (o?.inFile ? (require('esoftplay/storage').default) : (require('@react-native-async-storage/async-storage').default))
-    loaded = 0
-    if (o?.loadOnInit)
-      loadFromDisk()
+  const subsSetter = new Set<(newValue: T) => void>(); // Typed Set
+  const listener = new Set<(value: T) => void>(); // Typed Set
+  let loaded = -1;
+  let taskSync: any = undefined;
+
+  // Optimization: Check persistKey only once
+  const hasPersistKey = !!o?.persistKey;
+  const persistKey = o?.persistKey; // Store it for easier access
+
+  if (hasPersistKey) {
+    loaded = 0;
+    if (o?.loadOnInit) {
+      loadFromDisk();
+    }
   }
 
+
   function _sync() {
     const debounce = createDebounce()
     if (o?.useAutoSync && taskSync && Array.isArray(value)) {
@@ -101,33 +112,38 @@ export default function useGlobalState<T>(initValue: T, o?: useGlobalOption): us
     })
   }
 
+
   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) { }
+    if (loaded === 0) {
+      loaded = 1;
+
+      if (hasPersistKey) { // Check hasPersistKey
+        STORAGE.getItem(String(persistKey)).then((p: any) => {
+          if (p) {
+            try {
+              if (persistKey !== '__globalReady' && typeof p == 'string' && ((String(p).startsWith('{') && String(p).endsWith('}')) || (String(p).startsWith('[') && String(p).endsWith(']')))) {
+                set(JSON.parse(p));
+              } else if (p === "true" || p === "false") {
+                set(JSON.parse(p)); // Directly parse boolean strings
+              } else if (!isNaN(p as any)) {
+                set(Number(p)); // Directly convert to number
               } else {
-                try { /* @ts-ignore */ set(eval(p)) } catch (error) { }
+                set(p); // No need for eval if not an object or boolean or number
               }
+            } catch (error) {
+              console.error("Error loading from disk:", persistKey, error, JSON.stringify(p)); // More informative error message
             }
-        }
-        if (o?.onFinish) {
-          clearTimeout(timeoutFinish)
-          timeoutFinish = setTimeout(() => {
-            o.onFinish?.()
-            clearTimeout(timeoutFinish)
-          }, 50);
-        }
-      })
+          }
+
+          if (o?.onFinish) {
+            clearTimeout(timeoutFinish);
+            timeoutFinish = setTimeout(() => {
+              o.onFinish?.();
+              clearTimeout(timeoutFinish);
+            }, 50);
+          }
+        });
+      }
     }
   }
 
@@ -148,37 +164,36 @@ export default function useGlobalState<T>(initValue: T, o?: useGlobalOption): us
   }
 
   function set(ns: T | ((old: T) => T)) {
-    let newValue: any
+    let newValue: T; // Type newValue correctly
     if (ns instanceof Function) {
-      newValue = ns(value)
+      newValue = ns(value);
     } else {
-      newValue = ns
+      newValue = ns;
     }
-    const isChange = !isEqual(value, newValue)
-    if (isChange) {
-      value = newValue
-      subsSetter.forEach((c) => c?.(newValue))
-      if (o?.persistKey && newValue != undefined) {
-        let data: any
-        switch (typeof newValue) {
-          case 'object':
-            if (newValue != null || newValue != undefined)
-              data = o.jsonBeautify ? JSON.stringify(newValue, undefined, 2) : JSON.stringify(newValue)
-            break;
-          default:
-            data = String(newValue)
-        }
-        STORAGE.setItem(o.persistKey, data)
+
+    if (!isEqual(value, newValue)) { // Use direct import of isEqual
+      value = newValue;
+      subsSetter.forEach((c) => c(newValue)); // Directly call the callback
+
+      if (hasPersistKey && newValue !== undefined) { // Check hasPersistKey
+        const data = typeof newValue === 'object' && newValue !== null
+          ? (o.jsonBeautify ? JSON.stringify(newValue, null, 2) : JSON.stringify(newValue))
+          : String(newValue); // Simplified data assignment
+
+        STORAGE.setItem(persistKey, data); // Use the stored persistKey
       }
-      if (o?.listener)
-        o.listener(newValue)
-      if (o?.useAutoSync && taskSync)
-        taskSync?.[0]?.(newValue.filter((item: any) => item.synced != 1))
-      if (listener.size > 0) {
-        listener.forEach((fun) => fun?.(newValue))
+
+      if (o?.listener) {
+        o.listener(newValue);
       }
+
+      if (o?.useAutoSync && taskSync && Array.isArray(newValue)) {
+        taskSync[0](newValue.filter((item: any) => item.synced != 1));
+      }
+
+      listener.forEach((fun) => fun(newValue)); // Directly call the listener functions
     }
-  };
+  }
 
   function del() {
     if (o?.persistKey) {

package/mmkv.ts

@@ -2,19 +2,25 @@ import { MMKV } from 'react-native-mmkv';
 
 const storage = new MMKV()
 
+/** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/mmkv.md) untuk melihat dokumentasi*/
 const FastStorage = {
+  /** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/mmkv.md#getItemSync) untuk melihat dokumentasi*/
   getItemSync(key: string): string {
     return storage.getString(key)
   },
+  /** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/mmkv.md#getItem) untuk melihat dokumentasi*/
   getItem(key: string): Promise<string | undefined | null> {
     return new Promise((r) => r(storage.getString(key)))
   },
+  /** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/mmkv.md#setItem) untuk melihat dokumentasi*/
   setItem(key: string, value: string) {
     storage.set(key, value)
   },
+  /** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/mmkv.md#removeItem) untuk melihat dokumentasi*/
   removeItem(key: string) {
     storage.delete(key)
   },
+  /** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/mmkv.md#clear) untuk melihat dokumentasi*/
   clear(): void {
     storage.clearAll()
   },

package/modules/lib/autoreload.ts

@@ -3,7 +3,9 @@
 import { InteractionManager } from 'react-native'
 
 let updater: any
+/** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/modules/lib/autoreload.md) untuk melihat dokumentasi*/
 export default {
+  /** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/modules/lib/autoreload.md#setcallback---void-duration-number-void) untuk melihat dokumentasi*/
   set(callback: () => void, duration?: number): void {
     if (updater != undefined) {
       clearInterval(updater)
@@ -15,6 +17,7 @@ export default {
       });
     }, duration || 6000)
   },
+  /** Klik [disini](https://github.com/dev-esoftplay/mobile-docs/blob/main/modules/lib/autoreload.md#clear-void) untuk melihat dokumentasi*/
   clear(): void {
     if (updater != undefined) {
       clearInterval(updater)