@fctc/interface-logic 4.2.7 → 4.2.9

package/dist/services.mjs

@@ -1606,9 +1606,9 @@ function applyBinaryOp(ast, context) {
 var DICT = {
   get(...args) {
     const { key, defValue } = parseArgs(args, ["key", "defValue"]);
-    const self = this;
-    if (key in self) {
-      return self[key];
+    const self2 = this;
+    if (key in self2) {
+      return self2[key];
     } else if (defValue !== void 0) {
       return defValue;
     }
@@ -2229,7 +2229,8 @@ var initialState2 = {
     allowed_company_ids: [],
     lang: "vi_VN",
     tz: "Asia/Saigon"
-  }
+  },
+  isLocalMode: false
 };
 var envSlice = createSlice2({
   name: "env",
@@ -3859,7 +3860,226 @@ var handleClosingSessionService = (env) => {
 
 // src/services/pos-service/load-data-pos-session.ts
 import { useCallback as useCallback23 } from "react";
+
+// src/services/filesystem-service/file-service.ts
+import { Directory, Encoding, Filesystem } from "@capacitor/filesystem";
+var fileService = {
+  async read(path) {
+    try {
+      const res = await Filesystem.readFile({
+        path,
+        directory: Directory.Data,
+        encoding: Encoding.UTF8
+      });
+      if (typeof res.data === "string") return res.data;
+      if (res.data instanceof Blob) return await res.data.text();
+      return null;
+    } catch {
+      return null;
+    }
+  },
+  async write(path, data) {
+    await Filesystem.writeFile({
+      path,
+      data,
+      directory: Directory.Data,
+      encoding: Encoding.UTF8,
+      recursive: true
+    });
+  },
+  async writeAtomic(path, data) {
+    const tempPath = path + ".tmp";
+    await Filesystem.writeFile({
+      path: tempPath,
+      data,
+      directory: Directory.Data,
+      encoding: Encoding.UTF8,
+      recursive: true
+    });
+    try {
+      await Filesystem.deleteFile({
+        path,
+        directory: Directory.Data
+      });
+    } catch {
+    }
+    await Filesystem.rename({
+      from: tempPath,
+      to: path,
+      directory: Directory.Data
+    });
+  },
+  async delete(path) {
+    try {
+      await Filesystem.deleteFile({
+        path,
+        directory: Directory.Data
+      });
+    } catch {
+    }
+  },
+  async exists(path) {
+    try {
+      await Filesystem.stat({
+        path,
+        directory: Directory.Data
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async mkdir(path) {
+    try {
+      await Filesystem.mkdir({
+        path,
+        directory: Directory.Data,
+        recursive: true
+      });
+    } catch (e) {
+      if (!String(e?.message).includes("Exists")) {
+        throw e;
+      }
+    }
+  },
+  async list(path) {
+    return Filesystem.readdir({
+      path,
+      directory: Directory.Data
+    });
+  },
+  async getUri(path) {
+    return Filesystem.getUri({
+      path,
+      directory: Directory.Data
+    });
+  }
+};
+
+// src/services/filesystem-service/json-worker.ts
+self.addEventListener("message", async (ev) => {
+  const { id, cmd, payload } = ev.data;
+  try {
+    if (cmd === "parse") {
+      const parsed = JSON.parse(payload);
+      self.postMessage({ id, ok: true, result: parsed });
+    } else if (cmd === "stringify") {
+      const str = JSON.stringify(payload);
+      self.postMessage({ id, ok: true, result: str });
+    }
+  } catch (err) {
+    self.postMessage({ id, ok: false, error: err?.message || String(err) });
+  }
+});
+function spawnParseWorker(raw) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(new URL("./json-worker.ts", import.meta.url), {
+      type: "module"
+    });
+    const id = Math.random().toString(36).slice(2);
+    worker.onmessage = (ev) => {
+      const { ok, result, error } = ev.data;
+      if (ok) {
+        resolve(result);
+      } else {
+        reject(new Error(error));
+      }
+      worker.terminate();
+    };
+    worker.postMessage({ id, cmd: "parse", payload: raw });
+  });
+}
+function spawnStringifyWorker(obj) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(new URL("./json-worker.ts", import.meta.url), {
+      type: "module"
+    });
+    worker.onmessage = (ev) => {
+      const { ok, result, error } = ev.data;
+      if (ok) resolve(result);
+      else reject(new Error(error));
+      worker.terminate();
+    };
+    worker.postMessage({ cmd: "stringify", payload: obj });
+  });
+}
+
+// src/services/filesystem-service/memory-cache.ts
+var MemoryCache = class {
+  map = /* @__PURE__ */ new Map();
+  get(k) {
+    const e = this.map.get(k);
+    if (!e) return null;
+    if (e.ttl && Date.now() - e.t > e.ttl) {
+      this.map.delete(k);
+      return null;
+    }
+    return e.value;
+  }
+  set(k, v, ttl = 5 * 60 * 1e3) {
+    this.map.set(k, { value: v, t: Date.now(), ttl });
+  }
+  del(k) {
+    this.map.delete(k);
+  }
+  clear() {
+    this.map.clear();
+  }
+};
+var memoryCache = new MemoryCache();
+
+// src/services/filesystem-service/model-loader.ts
+var MODELS_DIR = "pos/models";
+var MODELS_META_DIR = "pos/models_meta";
+async function loadData(includeMeta = true) {
+  const exists = await fileService.exists(MODELS_DIR);
+  if (!exists) {
+    console.warn("[loadData] MODELS_DIR not exists:", MODELS_DIR);
+    return {};
+  }
+  let listResult;
+  try {
+    listResult = await fileService.list(MODELS_DIR);
+  } catch (e) {
+    console.error("[loadData] list failed:", e);
+    return {};
+  }
+  if (!listResult || !Array.isArray(listResult.files)) {
+    return {};
+  }
+  const result = {};
+  for (const file of listResult.files) {
+    if (file.type !== "file") continue;
+    if (!file.name.endsWith(".json")) continue;
+    const modelName = file.name.replace(/\.json$/, "");
+    const dataPath = `${MODELS_DIR}/${file.name}`;
+    const metaPath = `${MODELS_META_DIR}/${encodeURIComponent(
+      modelName
+    )}.meta.json`;
+    const rawData = await fileService.read(dataPath);
+    if (!rawData) continue;
+    const parsedData = await spawnParseWorker(rawData);
+    const data = Array.isArray(parsedData) ? parsedData : [];
+    if (!includeMeta) {
+      result[modelName] = { data };
+      continue;
+    }
+    const rawMeta = await fileService.read(metaPath);
+    let fields = [];
+    let relations = {};
+    if (rawMeta) {
+      const parsedMeta = await spawnParseWorker(rawMeta);
+      fields = parsedMeta?.fields ?? [];
+      relations = parsedMeta?.relations ?? {};
+    }
+    result[modelName] = { data, fields, relations };
+  }
+  return result;
+}
+
+// src/services/pos-service/load-data-pos-session.ts
 var loadDataPosSessionService = (env) => {
+  const isLocalMode = env?.isLocalMode;
   const loadDataPosSession = useCallback23(
     ({
       model,
@@ -3870,6 +4090,14 @@ var loadDataPosSessionService = (env) => {
       modelsToLoad = [],
       searchParams
     }) => {
+      console.log("isLocalMode", isLocalMode);
+      if (isLocalMode) {
+        return loadData().then((localDb) => ({
+          data: {
+            data: localDb
+          }
+        }));
+      }
       const jsonData = {
         model,
         method: "load_data" /* LOAD_DATA */,
@@ -3896,7 +4124,7 @@ var loadDataPosSessionService = (env) => {
         service
       );
     },
-    [env]
+    [env, isLocalMode]
   );
   return {
     loadDataPosSession
@@ -4313,6 +4541,9 @@ import { useMutation as useMutation84 } from "@tanstack/react-query";
 // src/hooks/pos/use-update-order-status.ts
 import { useMutation as useMutation85 } from "@tanstack/react-query";
 
+// src/hooks/pos/use-init-snapshot.ts
+import { useMutation as useMutation86 } from "@tanstack/react-query";
+
 // src/provider/service-provider.tsx
 import { jsx as jsx6 } from "react/jsx-runtime";
 var ServiceContext = createContext2(null);
@@ -6475,12 +6706,152 @@ function useDashboardService() {
   );
   return { readGroup, getDataChart };
 }
+
+// src/services/filesystem-service/manifest.ts
+var MANIFEST_PATH = "pos/manifest.json";
+var MANIFEST_BAK_PATH = "pos/manifest.bak.json";
+async function writeManifest(manifest) {
+  const oldRaw = await fileService.read(MANIFEST_PATH);
+  if (oldRaw !== null) {
+    await fileService.writeAtomic(MANIFEST_BAK_PATH, oldRaw);
+  }
+  await fileService.writeAtomic(MANIFEST_PATH, JSON.stringify(manifest));
+  try {
+    await fileService.delete(MANIFEST_BAK_PATH);
+  } catch {
+  }
+}
+
+// src/services/filesystem-service/import-snapshot.ts
+var DATA_DIR = "pos";
+var MODELS_DIR2 = `${DATA_DIR}/models`;
+var MODELS_META_DIR2 = `${DATA_DIR}/models_meta`;
+var importSnapshot = async ({ data, onProgress }) => {
+  onProgress?.(1, "Parsing snapshot");
+  const parsed = await spawnParseWorker(data);
+  const modelNames = Object.keys(parsed);
+  const total = modelNames.length;
+  const manifest = { version: (/* @__PURE__ */ new Date()).toISOString(), models: {} };
+  const TMP_PREFIX = `pos/data/tmp_import_${Date.now()}`;
+  await fileService.writeAtomic(`${TMP_PREFIX}/.marker`, "1");
+  let i = 0;
+  for (const model of modelNames) {
+    i++;
+    onProgress?.(
+      Math.round(i / total * 100),
+      `Processing ${model} (${i}/${total})`
+    );
+    const block = parsed[model];
+    const dataPart = block?.data ?? block ?? [];
+    const fields = block?.fields ?? [];
+    const relations = block?.relations ?? {};
+    const serialized = await spawnStringifyWorker(dataPart);
+    const tmpModelPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.json`;
+    await fileService.writeAtomic(tmpModelPath, serialized);
+    const meta = {
+      fields,
+      relations,
+      count: Array.isArray(dataPart) ? dataPart.length : 0,
+      writtenAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const tmpMetaPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.meta.json`;
+    await fileService.writeAtomic(tmpMetaPath, JSON.stringify(meta));
+    manifest.models[model] = {
+      file: `${MODELS_DIR2}/${encodeURIComponent(model)}.json`,
+      metaFile: `${MODELS_META_DIR2}/${encodeURIComponent(model)}.meta.json`,
+      count: meta.count,
+      updatedAt: meta.writtenAt
+    };
+  }
+  onProgress?.(95, "Committing import (moving files)");
+  for (const model of modelNames) {
+    const tmpModelPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.json`;
+    const finalModelPath = `${MODELS_DIR2}/${encodeURIComponent(model)}.json`;
+    const tmpMetaPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.meta.json`;
+    const finalMetaPath = `${MODELS_META_DIR2}/${encodeURIComponent(
+      model
+    )}.meta.json`;
+    const tmpRaw = await fileService.read(tmpModelPath);
+    if (tmpRaw !== null) await fileService.writeAtomic(finalModelPath, tmpRaw);
+    const tmpMetaRaw = await fileService.read(tmpMetaPath);
+    if (tmpMetaRaw !== null)
+      await fileService.writeAtomic(finalMetaPath, tmpMetaRaw);
+    onProgress?.(
+      95 + Math.round(
+        (Object.keys(manifest.models).indexOf(model) + 1) / modelNames.length * 5
+      ),
+      `Committed ${model}`
+    );
+  }
+  await writeManifest(manifest);
+  try {
+    for (const model of modelNames) {
+      await fileService.delete(
+        `${TMP_PREFIX}/${encodeURIComponent(model)}.json`
+      );
+      await fileService.delete(
+        `${TMP_PREFIX}/${encodeURIComponent(model)}.meta.json`
+      );
+    }
+    await fileService.delete(`${TMP_PREFIX}/.marker`);
+  } catch (e) {
+    console.log("Failed to cleanup tmp import files:", e);
+  }
+  onProgress?.(100, "Import complete");
+  return manifest;
+};
+var import_snapshot_default = importSnapshot;
+
+// src/services/filesystem-service/init-snapshot.ts
+var isSnapshotReady = async () => {
+  try {
+    const raw = await fileService.read("pos/manifest.json");
+    if (!raw) return false;
+    const manifest = JSON.parse(raw);
+    if (!manifest.models || typeof manifest.models !== "object") {
+      return false;
+    }
+    const modelEntries = Object.values(manifest.models);
+    if (modelEntries.length === 0) return false;
+    const firstModel = modelEntries[0];
+    if (!firstModel.file) return false;
+    const modelExists = await fileService.exists(firstModel.file);
+    return modelExists;
+  } catch {
+    return false;
+  }
+};
+async function initSnapshot(onProgress) {
+  const ready = await isSnapshotReady();
+  if (ready) {
+    console.log("skip initialization.");
+    return;
+  }
+  console.log("initializing from data.json...");
+  const jsonData = await fetch("/data.json").then((r) => r.text());
+  if (!jsonData) {
+    console.error("cannot load data.json");
+    return;
+  }
+  await import_snapshot_default({
+    data: jsonData,
+    onProgress
+  });
+}
+
+// src/services/filesystem-service/index.ts
+var useFileSystemService = () => {
+  return {
+    initSnapshot
+  };
+};
 export {
   useActionService,
   useAuthService,
   useCompanyService,
   useDashboardService,
   useExcelService,
+  useFileSystemService,
   useFormService,
   useKanbanService,
   useModelService,

package/dist/store.js

@@ -146,7 +146,8 @@ var initialState2 = {
     allowed_company_ids: [],
     lang: "vi_VN",
     tz: "Asia/Saigon"
-  }
+  },
+  isLocalMode: false
 };
 var envSlice = (0, import_toolkit2.createSlice)({
   name: "env",

package/dist/store.mjs

@@ -41,7 +41,8 @@ var initialState2 = {
     allowed_company_ids: [],
     lang: "vi_VN",
     tz: "Asia/Saigon"
-  }
+  },
+  isLocalMode: false
 };
 var envSlice = createSlice2({
   name: "env",

package/package.json

@@ -1,90 +1,91 @@
-{
-  "name": "@fctc/interface-logic",
-  "version": "4.2.7",
-  "types": "dist/index.d.ts",
-  "main": "dist/index.cjs",
-  "module": "dist/index.mjs",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.cjs"
-    },
-    "./configs": {
-      "types": "./dist/configs.d.ts",
-      "import": "./dist/configs.mjs",
-      "require": "./dist/configs.cjs"
-    },
-    "./constants": {
-      "types": "./dist/constants.d.ts",
-      "import": "./dist/constants.mjs",
-      "require": "./dist/constants.cjs"
-    },
-    "./environment": {
-      "types": "./dist/environment.d.ts",
-      "import": "./dist/environment.mjs",
-      "require": "./dist/environment.cjs"
-    },
-    "./hooks": {
-      "types": "./dist/hooks.d.ts",
-      "import": "./dist/hooks.mjs",
-      "require": "./dist/hooks.cjs"
-    },
-    "./provider": {
-      "types": "./dist/provider.d.ts",
-      "import": "./dist/provider.mjs",
-      "require": "./dist/provider.cjs"
-    },
-    "./services": {
-      "types": "./dist/services.d.ts",
-      "import": "./dist/services.mjs",
-      "require": "./dist/services.cjs"
-    },
-    "./store": {
-      "types": "./dist/store.d.ts",
-      "import": "./dist/store.mjs",
-      "require": "./dist/store.cjs"
-    },
-    "./utils": {
-      "types": "./dist/utils.d.ts",
-      "import": "./dist/utils.mjs",
-      "require": "./dist/utils.cjs"
-    },
-    "./types": {
-      "types": "./dist/types.d.ts",
-      "import": "./dist/types.mjs",
-      "require": "./dist/types.cjs"
-    },
-    "./models": {
-      "types": "./dist/models.d.ts",
-      "import": "./dist/models.mjs",
-      "require": "./dist/models.cjs"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "test": "jest"
-  },
-  "peerDependencies": {
-    "react": "18.0.0",
-    "@tanstack/react-query": "^5.83.0"
-  },
-  "dependencies": {
-    "@reduxjs/toolkit": "^2.8.2",
-    "@tanstack/react-query": "^5.83.0",
-    "axios": "^1.11.0",
-    "moment": "^2.30.1",
-    "react-redux": "^9.2.0"
-  },
-  "devDependencies": {
-    "@types/react": "^18.3.1",
-    "react": "18.0.0",
-    "jest": "^29.7.0",
-    "tsup": "^8.0.0",
-    "typescript": "^5.8.2"
-  },
-  "packageManager": "yarn@1.22.0"
-}
+{
+  "name": "@fctc/interface-logic",
+  "version": "4.2.9",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./configs": {
+      "types": "./dist/configs.d.ts",
+      "import": "./dist/configs.mjs",
+      "require": "./dist/configs.cjs"
+    },
+    "./constants": {
+      "types": "./dist/constants.d.ts",
+      "import": "./dist/constants.mjs",
+      "require": "./dist/constants.cjs"
+    },
+    "./environment": {
+      "types": "./dist/environment.d.ts",
+      "import": "./dist/environment.mjs",
+      "require": "./dist/environment.cjs"
+    },
+    "./hooks": {
+      "types": "./dist/hooks.d.ts",
+      "import": "./dist/hooks.mjs",
+      "require": "./dist/hooks.cjs"
+    },
+    "./provider": {
+      "types": "./dist/provider.d.ts",
+      "import": "./dist/provider.mjs",
+      "require": "./dist/provider.cjs"
+    },
+    "./services": {
+      "types": "./dist/services.d.ts",
+      "import": "./dist/services.mjs",
+      "require": "./dist/services.cjs"
+    },
+    "./store": {
+      "types": "./dist/store.d.ts",
+      "import": "./dist/store.mjs",
+      "require": "./dist/store.cjs"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.mjs",
+      "require": "./dist/utils.cjs"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.mjs",
+      "require": "./dist/types.cjs"
+    },
+    "./models": {
+      "types": "./dist/models.d.ts",
+      "import": "./dist/models.mjs",
+      "require": "./dist/models.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "jest"
+  },
+  "peerDependencies": {
+    "@tanstack/react-query": "^5.83.0",
+    "react": "18.0.0"
+  },
+  "dependencies": {
+    "@capacitor/filesystem": "^8.0.0",
+    "@reduxjs/toolkit": "^2.8.2",
+    "@tanstack/react-query": "^5.83.0",
+    "axios": "^1.11.0",
+    "moment": "^2.30.1",
+    "react-redux": "^9.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.1",
+    "jest": "^29.7.0",
+    "react": "18.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.8.2"
+  },
+  "packageManager": "yarn@1.22.0"
+}