@fctc/interface-logic 4.2.7 → 4.2.8

package/dist/provider.js

@@ -106,7 +106,8 @@ var initialState2 = {
     allowed_company_ids: [],
     lang: "vi_VN",
     tz: "Asia/Saigon"
-  }
+  },
+  isLocalMode: false
 };
 var envSlice = (0, import_toolkit2.createSlice)({
   name: "env",
@@ -2315,9 +2316,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;
     }
@@ -5926,7 +5927,221 @@ var handleClosingSessionService = (env) => {
 
 // src/services/pos-service/load-data-pos-session.ts
 var import_react33 = require("react");
+
+// src/services/filesystem-service/file-service.ts
+var import_filesystem = require("@capacitor/filesystem");
+var fileService = {
+  async read(path) {
+    try {
+      const res = await import_filesystem.Filesystem.readFile({
+        path,
+        directory: import_filesystem.Directory.Data,
+        encoding: import_filesystem.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 import_filesystem.Filesystem.writeFile({
+      path,
+      data,
+      directory: import_filesystem.Directory.Data,
+      encoding: import_filesystem.Encoding.UTF8,
+      recursive: true
+    });
+  },
+  async writeAtomic(path, data) {
+    const tempPath = path + ".tmp";
+    await import_filesystem.Filesystem.writeFile({
+      path: tempPath,
+      data,
+      directory: import_filesystem.Directory.Data,
+      encoding: import_filesystem.Encoding.UTF8,
+      recursive: true
+    });
+    try {
+      await import_filesystem.Filesystem.deleteFile({
+        path,
+        directory: import_filesystem.Directory.Data
+      });
+    } catch {
+    }
+    await import_filesystem.Filesystem.rename({
+      from: tempPath,
+      to: path,
+      directory: import_filesystem.Directory.Data
+    });
+  },
+  async delete(path) {
+    try {
+      await import_filesystem.Filesystem.deleteFile({
+        path,
+        directory: import_filesystem.Directory.Data
+      });
+    } catch {
+    }
+  },
+  async exists(path) {
+    try {
+      await import_filesystem.Filesystem.stat({
+        path,
+        directory: import_filesystem.Directory.Data
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async mkdir(path) {
+    try {
+      await import_filesystem.Filesystem.mkdir({
+        path,
+        directory: import_filesystem.Directory.Data,
+        recursive: true
+      });
+    } catch (e) {
+      if (!String(e?.message).includes("Exists")) {
+        throw e;
+      }
+    }
+  },
+  async list(path) {
+    return import_filesystem.Filesystem.readdir({
+      path,
+      directory: import_filesystem.Directory.Data
+    });
+  },
+  async getUri(path) {
+    return import_filesystem.Filesystem.getUri({
+      path,
+      directory: import_filesystem.Directory.Data
+    });
+  }
+};
+
+// src/services/filesystem-service/json-worker.ts
+var import_meta = {};
+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 listResult = await fileService.list(MODELS_DIR);
+  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 fileName = file.name;
+    const modelName = fileName.replace(/\.json$/, "");
+    const dataPath = `${MODELS_DIR}/${fileName}`;
+    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 = (0, import_react33.useCallback)(
     ({
       model,
@@ -5937,6 +6152,9 @@ var loadDataPosSessionService = (env) => {
       modelsToLoad = [],
       searchParams
     }) => {
+      if (isLocalMode) {
+        return loadData();
+      }
       const jsonData = {
         model,
         method: "load_data" /* LOAD_DATA */,
@@ -5963,7 +6181,7 @@ var loadDataPosSessionService = (env) => {
         service
       );
     },
-    [env]
+    [env, isLocalMode]
   );
   return {
     loadDataPosSession
@@ -6296,6 +6514,145 @@ var usePosService = () => {
   return service;
 };
 
+// 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
+  };
+};
+
 // src/provider/version-gate-provider.tsx
 var import_jsx_runtime4 = require("react/jsx-runtime");
 var VersionGate = ({ children }) => {
@@ -6683,7 +7040,8 @@ var initialEnvState = {
     lang: "vi_VN",
     tz: "Asia/Saigon"
   },
-  excludeLanguages: []
+  excludeLanguages: [],
+  isLocalMode: false
 };
 var EnvContext = (0, import_react43.createContext)(null);
 function EnvProvider({
@@ -8766,6 +9124,16 @@ var useUpdateOrderStatus = () => {
 };
 var use_update_order_status_default = useUpdateOrderStatus;
 
+// src/hooks/pos/use-init-snapshot.ts
+var import_react_query113 = require("@tanstack/react-query");
+var useInitSnapshot = () => {
+  const fileSystem = useFileSystemService();
+  return (0, import_react_query113.useMutation)({
+    mutationFn: fileSystem.initSnapshot
+  });
+};
+var use_init_snapshot_default = useInitSnapshot;
+
 // src/provider/service-provider.tsx
 var import_jsx_runtime6 = require("react/jsx-runtime");
 var ServiceContext = (0, import_react45.createContext)(null);
@@ -8884,7 +9252,8 @@ var ServiceProvider = ({
     useGetCity: use_get_city_default,
     useGetWard: use_get_ward_default,
     useGetCountry: use_get_country_default,
-    useGetPartnerTitle: use_get_partner_title_default
+    useGetPartnerTitle: use_get_partner_title_default,
+    useInitSnapshot: use_init_snapshot_default
   };
   return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(ServiceContext.Provider, { value: services, children });
 };