@fctc/interface-logic 4.2.7 → 4.2.9

package/dist/provider.mjs

@@ -63,7 +63,8 @@ var initialState2 = {
     allowed_company_ids: [],
     lang: "vi_VN",
     tz: "Asia/Saigon"
-  }
+  },
+  isLocalMode: false
 };
 var envSlice = createSlice2({
   name: "env",
@@ -2272,9 +2273,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;
     }
@@ -5883,7 +5884,226 @@ var handleClosingSessionService = (env) => {
 
 // src/services/pos-service/load-data-pos-session.ts
 import { useCallback as useCallback31 } 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 = useCallback31(
     ({
       model,
@@ -5894,6 +6114,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 */,
@@ -5920,7 +6148,7 @@ var loadDataPosSessionService = (env) => {
         service
       );
     },
-    [env]
+    [env, isLocalMode]
   );
   return {
     loadDataPosSession
@@ -6253,6 +6481,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
 import { Fragment, jsx as jsx4 } from "react/jsx-runtime";
 var VersionGate = ({ children }) => {
@@ -6640,7 +7007,8 @@ var initialEnvState = {
     lang: "vi_VN",
     tz: "Asia/Saigon"
   },
-  excludeLanguages: []
+  excludeLanguages: [],
+  isLocalMode: false
 };
 var EnvContext = createContext(null);
 function EnvProvider({
@@ -8723,6 +9091,16 @@ var useUpdateOrderStatus = () => {
 };
 var use_update_order_status_default = useUpdateOrderStatus;
 
+// src/hooks/pos/use-init-snapshot.ts
+import { useMutation as useMutation86 } from "@tanstack/react-query";
+var useInitSnapshot = () => {
+  const fileSystem = useFileSystemService();
+  return useMutation86({
+    mutationFn: fileSystem.initSnapshot
+  });
+};
+var use_init_snapshot_default = useInitSnapshot;
+
 // src/provider/service-provider.tsx
 import { jsx as jsx6 } from "react/jsx-runtime";
 var ServiceContext = createContext2(null);
@@ -8841,7 +9219,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__ */ jsx6(ServiceContext.Provider, { value: services, children });
 };

package/dist/services.d.mts

@@ -1,4 +1,5 @@
 import { C as ContextApi, L as LoginCredentialBody, R as ResetPasswordRequest, U as UpdatePasswordRequest, T as TThreadData, h as GetExternalTab, b as GetListParams, a as GetDetailParams, S as SaveParams, D as DeleteParams, O as OnChangeParams, V as ViewData, f as GetViewParams, c as GetSelectionType } from './view-type-CfcWWR0w.mjs';
+import { P as ProgressCb } from './import-snapshot-Ds0gqFFm.mjs';
 
 declare function useActionService(): {
     loadAction: ({ idAction, context, service, xNode, searchParams, }: {
@@ -611,4 +612,10 @@ type MergedService = UnionToIntersection<ServiceReturn<ServiceFactories>>;
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 declare const usePosService: () => MergedService;
 
-export { useActionService, useAuthService, useCompanyService, useDashboardService, useExcelService, useFormService, useKanbanService, useModelService, usePosService, useUserService, useViewService };
+declare function initSnapshot(onProgress?: ProgressCb): Promise<void>;
+
+declare const useFileSystemService: () => {
+    initSnapshot: typeof initSnapshot;
+};
+
+export { useActionService, useAuthService, useCompanyService, useDashboardService, useExcelService, useFileSystemService, useFormService, useKanbanService, useModelService, usePosService, useUserService, useViewService };

package/dist/services.d.ts

@@ -1,4 +1,5 @@
 import { C as ContextApi, L as LoginCredentialBody, R as ResetPasswordRequest, U as UpdatePasswordRequest, T as TThreadData, h as GetExternalTab, b as GetListParams, a as GetDetailParams, S as SaveParams, D as DeleteParams, O as OnChangeParams, V as ViewData, f as GetViewParams, c as GetSelectionType } from './view-type-CfcWWR0w.js';
+import { P as ProgressCb } from './import-snapshot-Ds0gqFFm.js';
 
 declare function useActionService(): {
     loadAction: ({ idAction, context, service, xNode, searchParams, }: {
@@ -611,4 +612,10 @@ type MergedService = UnionToIntersection<ServiceReturn<ServiceFactories>>;
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 declare const usePosService: () => MergedService;
 
-export { useActionService, useAuthService, useCompanyService, useDashboardService, useExcelService, useFormService, useKanbanService, useModelService, usePosService, useUserService, useViewService };
+declare function initSnapshot(onProgress?: ProgressCb): Promise<void>;
+
+declare const useFileSystemService: () => {
+    initSnapshot: typeof initSnapshot;
+};
+
+export { useActionService, useAuthService, useCompanyService, useDashboardService, useExcelService, useFileSystemService, useFormService, useKanbanService, useModelService, usePosService, useUserService, useViewService };