@fctc/interface-logic 4.4.0 → 4.4.1

package/dist/services.mjs

@@ -50,6 +50,58 @@ var UriConstants = /* @__PURE__ */ ((UriConstants2) => {
 // src/utils/format.ts
 import moment from "moment";
 
+// src/constants/model/model-constant.ts
+var LoadDataModel = /* @__PURE__ */ ((LoadDataModel2) => {
+  LoadDataModel2["ACCOUNT_CASH_ROUNDING"] = "account.cash.rounding";
+  LoadDataModel2["ACCOUNT_FISCAL_POSITION"] = "account.fiscal.position";
+  LoadDataModel2["ACCOUNT_FISCAL_POSITION_TAX"] = "account.fiscal.position.tax";
+  LoadDataModel2["ACCOUNT_TAX"] = "account.tax";
+  LoadDataModel2["ACCOUNT_TAX_GROUP"] = "account.tax.group";
+  LoadDataModel2["DECIMAL_PRECISION"] = "decimal.precision";
+  LoadDataModel2["IR_MODULE_MODULE"] = "ir.module.module";
+  LoadDataModel2["IR_UI_VIEW"] = "ir.ui.view";
+  LoadDataModel2["POS_BILL"] = "pos.bill";
+  LoadDataModel2["POS_CATEGORY"] = "pos.category";
+  LoadDataModel2["POS_CONFIG"] = "pos.config";
+  LoadDataModel2["POS_NOTE"] = "pos.note";
+  LoadDataModel2["POS_ORDER"] = "pos.order";
+  LoadDataModel2["POS_ORDER_LINE"] = "pos.order.line";
+  LoadDataModel2["POS_PACK_OPERATION_LOT"] = "pos.pack.operation.lot";
+  LoadDataModel2["POS_PAYMENT"] = "pos.payment";
+  LoadDataModel2["POS_PAYMENT_METHOD"] = "pos.payment.method";
+  LoadDataModel2["POS_PRINTER"] = "pos.printer";
+  LoadDataModel2["POS_SESSION"] = "pos.session";
+  LoadDataModel2["POS_PREPARATION_DISPLAY_DISPLAY"] = "pos_preparation_display.display";
+  LoadDataModel2["PRODUCT_ATTRIBUTE"] = "product.attribute";
+  LoadDataModel2["PRODUCT_ATTRIBUTE_CUSTOM_VALUE"] = "product.attribute.custom.value";
+  LoadDataModel2["PRODUCT_CATEGORY"] = "product.category";
+  LoadDataModel2["PRODUCT_COMBO"] = "product.combo";
+  LoadDataModel2["PRODUCT_COMBO_ITEM"] = "product.combo.item";
+  LoadDataModel2["PRODUCT_PACKAGING"] = "product.packaging";
+  LoadDataModel2["PRODUCT_PRICELIST"] = "product.pricelist";
+  LoadDataModel2["PRODUCT_PRICELIST_ITEM"] = "product.pricelist.item";
+  LoadDataModel2["PRODUCT_PRODUCT"] = "product.product";
+  LoadDataModel2["PRODUCT_TAG"] = "product.tag";
+  LoadDataModel2["PRODUCT_TEMPLATE_ATTRIBUTE_LINE"] = "product.template.attribute.line";
+  LoadDataModel2["PRODUCT_TEMPLATE_ATTRIBUTE_VALUE"] = "product.template.attribute.value";
+  LoadDataModel2["RES_COMPANY"] = "res.company";
+  LoadDataModel2["RES_COUNTRY"] = "res.country";
+  LoadDataModel2["RES_COUNTRY_STATE"] = "res.country.state";
+  LoadDataModel2["RES_CURRENCY"] = "res.currency";
+  LoadDataModel2["RES_LANG"] = "res.lang";
+  LoadDataModel2["RES_PARTNER"] = "res.partner";
+  LoadDataModel2["RES_USERS"] = "res.users";
+  LoadDataModel2["STOCK_PICKING_TYPE"] = "stock.picking.type";
+  LoadDataModel2["UOM_CATEGORY"] = "uom.category";
+  LoadDataModel2["UOM_UOM"] = "uom.uom";
+  LoadDataModel2["LOYALTY_PROGRAM"] = "loyalty.program";
+  LoadDataModel2["LOYALTY_RULE"] = "loyalty.rule";
+  LoadDataModel2["RESTAURANT_TABLE"] = "restaurant.table";
+  LoadDataModel2["RESTAURANT_FLOOR"] = "restaurant.floor";
+  LoadDataModel2["POS_MAKE_PAYMENT"] = "pos.make.payment";
+  return LoadDataModel2;
+})(LoadDataModel || {});
+
 // src/utils/domain/py_tokenizer.ts
 var TokenizerError = class extends Error {
 };
@@ -2178,13 +2230,6 @@ function cleanObject(obj) {
   }
   return result;
 }
-var extractIdFromDomain = (domain) => {
-  if (!domain || !Array.isArray(domain)) return null;
-  const idCond = domain.find(
-    ([field, operator]) => field === "id" && operator === "="
-  );
-  return idCond ? Number(idCond[2]) : null;
-};
 
 // src/provider/react-query-provider.tsx
 import { useState as useState2 } from "react";
@@ -2237,7 +2282,7 @@ var initialState2 = {
     lang: "vi_VN",
     tz: "Asia/Saigon"
   },
-  isLocalMode: false
+  isSupaMode: false
 };
 var envSlice = createSlice2({
   name: "env",
@@ -2844,7 +2889,7 @@ function useEnv() {
 }
 
 // src/provider/service-provider.tsx
-import { createContext as createContext2, useContext as useContext2 } from "react";
+import { createContext as createContext3, useContext as useContext3 } from "react";
 
 // src/hooks/auth/use-forgot-password.ts
 import { useMutation } from "@tanstack/react-query";
@@ -3148,544 +3193,7 @@ var getASessionService = (env) => {
 
 // src/services/pos-service/add-entity.ts
 import { useCallback as useCallback4 } from "react";
-
-// src/services/filesystem-service/file-service.ts
-import { Directory, Encoding, Filesystem } from "@capacitor/filesystem";
-var fileService = {
-  read: async (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;
-    }
-  },
-  write: async (path, data) => {
-    await Filesystem.writeFile({
-      path,
-      data,
-      directory: Directory.Data,
-      encoding: Encoding.UTF8,
-      recursive: true
-    });
-  },
-  writeAtomic: async (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
-    });
-  },
-  delete: async (path) => {
-    try {
-      await Filesystem.deleteFile({
-        path,
-        directory: Directory.Data
-      });
-    } catch {
-    }
-  },
-  exists: async (path) => {
-    try {
-      await Filesystem.stat({
-        path,
-        directory: Directory.Data
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  },
-  mkdir: async (path) => {
-    try {
-      await Filesystem.mkdir({
-        path,
-        directory: Directory.Data,
-        recursive: true
-      });
-    } catch (e) {
-      if (!String(e?.message).includes("Exists")) {
-        throw e;
-      }
-    }
-  },
-  list: async (path) => {
-    return Filesystem.readdir({
-      path,
-      directory: Directory.Data
-    });
-  },
-  getUri: async (path) => {
-    return Filesystem.getUri({
-      path,
-      directory: Directory.Data
-    });
-  }
-};
-
-// src/services/filesystem-service/json-worker.ts
-function createWorkerBlob() {
-  const workerCode = `
-    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) });
-      }
-    });
-  `;
-  const blob = new Blob([workerCode], { type: "application/javascript" });
-  return URL.createObjectURL(blob);
-}
-function spawnParseWorker(raw) {
-  return new Promise((resolve, reject) => {
-    const workerUrl = createWorkerBlob();
-    const worker = new Worker(workerUrl);
-    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));
-      }
-      URL.revokeObjectURL(workerUrl);
-      worker.terminate();
-    };
-    worker.onerror = (err) => {
-      reject(err);
-      URL.revokeObjectURL(workerUrl);
-      worker.terminate();
-    };
-    worker.postMessage({ id, cmd: "parse", payload: raw });
-  });
-}
-function spawnStringifyWorker(obj) {
-  return new Promise((resolve, reject) => {
-    const workerUrl = createWorkerBlob();
-    const worker = new Worker(workerUrl);
-    worker.onmessage = (ev) => {
-      const { ok, result, error } = ev.data;
-      if (ok) resolve(result);
-      else reject(new Error(error));
-      URL.revokeObjectURL(workerUrl);
-      worker.terminate();
-    };
-    worker.onerror = (err) => {
-      reject(err);
-      URL.revokeObjectURL(workerUrl);
-      worker.terminate();
-    };
-    worker.postMessage({ cmd: "stringify", payload: obj });
-  });
-}
-
-// 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_DIR = `${DATA_DIR}/models`;
-var MODELS_META_DIR = `${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_DIR}/${encodeURIComponent(model)}.json`,
-      metaFile: `${MODELS_META_DIR}/${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_DIR}/${encodeURIComponent(model)}.json`;
-    const tmpMetaPath = `${TMP_PREFIX}/${encodeURIComponent(model)}.meta.json`;
-    const finalMetaPath = `${MODELS_META_DIR}/${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/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_DIR2 = "pos/models";
-var MODELS_META_DIR2 = "pos/models_meta";
-async function loadModelData(modelName, includeMeta = true) {
-  const key = `model:${modelName}:meta:${includeMeta}`;
-  const cached = memoryCache.get(key);
-  if (cached) return cached;
-  const dataPath = `${MODELS_DIR2}/${encodeURIComponent(modelName)}.json`;
-  const metaPath = `${MODELS_META_DIR2}/${encodeURIComponent(
-    modelName
-  )}.meta.json`;
-  const rawData = await fileService.read(dataPath);
-  if (!rawData) return null;
-  const parsedData = await spawnParseWorker(rawData);
-  const data = Array.isArray(parsedData) ? parsedData : [];
-  if (!includeMeta) {
-    const result2 = { data };
-    memoryCache.set(key, result2, 1e3 * 60 * 60);
-    return result2;
-  }
-  const rawMeta = await fileService.read(metaPath);
-  let fields = [];
-  let relations = {};
-  if (rawMeta) {
-    const parsedMeta = await spawnParseWorker(rawMeta);
-    fields = parsedMeta?.fields ?? [];
-    relations = parsedMeta?.relations ?? {};
-  }
-  const result = {
-    data,
-    fields,
-    relations
-  };
-  memoryCache.set(key, result, 1e3 * 60 * 60);
-  return result;
-}
-async function loadData(includeMeta = true) {
-  try {
-    const listResult = await fileService.list(MODELS_DIR2);
-    if (!listResult || !Array.isArray(listResult.files)) {
-      console.log("No models found");
-      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_DIR2}/${fileName}`;
-      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 metaPath = `${MODELS_META_DIR2}/${encodeURIComponent(
-        modelName
-      )}.meta.json`;
-      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;
-  } catch (error) {
-    console.error("Error loading data:", error);
-    throw error;
-  }
-}
-
-// src/services/filesystem-service/snapshot-helper.ts
-var createEmptySnapshot = () => {
-  return {
-    data: []
-  };
-};
-var generateNextId = (existingIds, startFrom = 1) => {
-  if (!existingIds || existingIds.length === 0) {
-    return startFrom;
-  }
-  const maxId = Math.max(...existingIds, startFrom - 1);
-  return maxId + 1;
-};
-var loadSnapshot = async ({
-  modelName
-}) => {
-  try {
-    const snapshot = await loadModelData(modelName);
-    if (!snapshot || typeof snapshot !== "object") {
-      console.warn("invalid snapshot, creating new one");
-      return createEmptySnapshot();
-    }
-    return {
-      data: Array.isArray(snapshot.data) ? snapshot.data : []
-    };
-  } catch (error) {
-    console.error("Failed to load snapshot:", error);
-    return createEmptySnapshot();
-  }
-};
-var getExistingIds = (snapshot) => {
-  return snapshot.data.map((order) => order.id).filter((id) => typeof id === "number");
-};
-var saveSnapshot = async ({
-  snapshot,
-  modelName
-}) => {
-  try {
-    await import_snapshot_default({
-      data: JSON.stringify({
-        [modelName]: snapshot
-      })
-    });
-    return true;
-  } catch (error) {
-    console.error("failed to save snapshot:", error);
-    return false;
-  }
-};
-var addRecordResponseHandler = ({
-  modelName,
-  id,
-  data
-}) => {
-  if (modelName === "restaurant.floor" /* RESTAURANT_FLOOR */ || modelName === "res.partner" /* RES_PARTNER */) {
-    return [[id, ""]];
-  }
-  return data;
-};
-
-// src/services/filesystem-service/model-repository.ts
-var ModelRepository = class {
-  getAll = async ({ modelName }) => {
-    try {
-      const snapshot = await loadSnapshot({
-        modelName
-      });
-      return snapshot.data;
-    } catch (error) {
-      console.error("failed to get all records:", error);
-      return [];
-    }
-  };
-  getRecord = async ({
-    id,
-    modelName
-  }) => {
-    try {
-      const snapshot = await loadSnapshot({
-        modelName
-      });
-      return snapshot.data.find((record) => record.id === id) || null;
-    } catch (error) {
-      console.error("failed to get record:", error);
-      return null;
-    }
-  };
-  addRecord = async ({
-    newRecord,
-    modelName
-  }) => {
-    try {
-      const snapshot = await loadSnapshot({
-        modelName
-      });
-      const existingIds = getExistingIds(snapshot);
-      const newId = generateNextId(existingIds, snapshot.data.length);
-      snapshot.data.push({
-        ...newRecord,
-        id: newId
-      });
-      const saved = await saveSnapshot({
-        snapshot,
-        modelName
-      });
-      if (!saved) {
-        console.error("failed to add new record");
-        return [];
-      }
-      console.log("lib data:", snapshot.data);
-      const response = addRecordResponseHandler({
-        id: newId,
-        modelName,
-        data: snapshot.data
-      });
-      return response;
-    } catch (error) {
-      console.error("failed to add new record:", error);
-      return [];
-    }
-  };
-  updateRecord = async ({
-    id,
-    update,
-    modelName
-  }) => {
-    try {
-      const snapshot = await loadSnapshot({
-        modelName
-      });
-      const index = snapshot.data.findIndex((record) => record.id === id);
-      if (index === -1) {
-        console.error(`record with id ${id} not found`);
-        return false;
-      }
-      snapshot.data[index] = {
-        ...snapshot.data[index],
-        ...update
-      };
-      return await saveSnapshot({
-        snapshot,
-        modelName
-      });
-    } catch (error) {
-      console.error("error updating record:", error);
-      return false;
-    }
-  };
-  deleteRecord = async ({
-    id,
-    modelName
-  }) => {
-    try {
-      const snapshot = await loadSnapshot({
-        modelName
-      });
-      const before = snapshot.data.length;
-      snapshot.data = snapshot.data.filter((record) => record.id !== id);
-      if (snapshot.data.length === before) {
-        console.error(`record with id ${id} not found`);
-        return false;
-      }
-      return await saveSnapshot({
-        snapshot,
-        modelName
-      });
-    } catch (error) {
-      console.error("error deleting record:", error);
-      return false;
-    }
-  };
-};
-
-// src/services/pos-service/add-entity.ts
 var addEntityService = (env) => {
-  const isLocalMode = env?.isLocalMode;
-  const repo = new ModelRepository();
   const addEntity = useCallback4(
     ({
       model,
@@ -3694,12 +3202,6 @@ var addEntityService = (env) => {
       service,
       isCreateEndpoint = false
     }) => {
-      if (isLocalMode) {
-        return repo.addRecord({
-          newRecord: values,
-          modelName: model
-        });
-      }
       const jsonData = {
         model,
         values
@@ -3716,7 +3218,7 @@ var addEntityService = (env) => {
         service
       );
     },
-    [env, isLocalMode]
+    [env]
   );
   return {
     addEntity
@@ -3838,8 +3340,6 @@ var createEInvoiceService = (env) => {
 // src/services/pos-service/create-entity.ts
 import { useCallback as useCallback8 } from "react";
 var createEntityService = (env) => {
-  const isLocalMode = env?.isLocalMode;
-  const repo = new ModelRepository();
   const createEntity = useCallback8(
     ({
       model,
@@ -3847,12 +3347,6 @@ var createEntityService = (env) => {
       xNode,
       service
     }) => {
-      if (isLocalMode) {
-        return repo.addRecord({
-          newRecord: args[0],
-          modelName: model
-        });
-      }
       const jsonData = {
         model,
         method: "create" /* CREATE */,
@@ -3870,7 +3364,7 @@ var createEntityService = (env) => {
         service
       );
     },
-    [env, isLocalMode]
+    [env]
   );
   return {
     createEntity
@@ -3955,8 +3449,6 @@ var createSessionService = (env) => {
 // src/services/pos-service/delete-entity.ts
 import { useCallback as useCallback11 } from "react";
 var deleteEntityService = (env) => {
-  const isLocalMode = env?.isLocalMode;
-  const repo = new ModelRepository();
   const deleteEntity = useCallback11(
     ({
       model,
@@ -3965,14 +3457,6 @@ var deleteEntityService = (env) => {
       service,
       method
     }) => {
-      if (isLocalMode) {
-        const id = ids[0];
-        if (!id) return;
-        return repo.deleteRecord({
-          modelName: model,
-          id
-        });
-      }
       const jsonData = {
         model,
         ids,
@@ -3990,7 +3474,7 @@ var deleteEntityService = (env) => {
         service
       );
     },
-    [env, isLocalMode]
+    [env]
   );
   return {
     deleteEntity
@@ -4067,8 +3551,6 @@ var getCurrentUserService = (env) => {
 // src/services/pos-service/get-list.ts
 import { useCallback as useCallback14 } from "react";
 var getListService = (env) => {
-  const isLocalMode = env?.isLocalMode;
-  const repo = new ModelRepository();
   const getList = useCallback14(
     async ({
       model,
@@ -4079,12 +3561,6 @@ var getListService = (env) => {
       offset,
       limit
     }) => {
-      if (isLocalMode) {
-        const data = await repo.getAll({
-          modelName: model
-        });
-        return data;
-      }
       const jsonData = {
         model,
         method: "web_search_read" /* WEB_SEARCH_READ */,
@@ -4107,7 +3583,7 @@ var getListService = (env) => {
         service
       );
     },
-    [env, isLocalMode]
+    [env]
   );
   return {
     getList
@@ -4436,8 +3912,41 @@ var handleClosingSessionService = (env) => {
 
 // src/services/pos-service/load-data-pos-session.ts
 import { useCallback as useCallback23 } from "react";
+
+// src/provider/supabase-provider.tsx
+import { createContext as createContext2, useContext as useContext2, useMemo } from "react";
+import { createClient } from "@supabase/supabase-js";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var SupabaseContext = createContext2(null);
+var useSupabase = () => {
+  const context = useContext2(SupabaseContext);
+  if (!context) {
+    throw new Error(
+      "useSupabase must be used within a SupabaseProvider or check your env config"
+    );
+  }
+  return context;
+};
+
+// src/services/pos-service/load-data-pos-session.ts
+var MODEL_TO_TABLE = {
+  ["account.tax" /* ACCOUNT_TAX */]: "account_taxes",
+  ["res.company" /* RES_COMPANY */]: "companies",
+  ["res.partner" /* RES_PARTNER */]: "customers",
+  ["res.users" /* RES_USERS */]: "employees",
+  ["loyalty.program" /* LOYALTY_PROGRAM */]: "loyalty_programs",
+  ["loyalty.rule" /* LOYALTY_RULE */]: "loyalty_rules",
+  ["pos.order.line" /* POS_ORDER_LINE */]: "order_lines",
+  ["pos.order" /* POS_ORDER */]: "orders",
+  ["pos.payment.method" /* POS_PAYMENT_METHOD */]: "payment_methods",
+  ["pos.payment" /* POS_PAYMENT */]: "payments",
+  ["product.category" /* PRODUCT_CATEGORY */]: "product_categories",
+  ["product.product" /* PRODUCT_PRODUCT */]: "products",
+  ["restaurant.floor" /* RESTAURANT_FLOOR */]: "restaurant_floors",
+  ["restaurant.table" /* RESTAURANT_TABLE */]: "restaurant_tables"
+};
 var loadDataPosSessionService = (env) => {
-  const isLocalMode = env?.isLocalMode;
+  const supabase = useSupabase();
   const loadDataPosSession = useCallback23(
     async ({
       model,
@@ -4448,10 +3957,6 @@ var loadDataPosSessionService = (env) => {
       modelsToLoad = [],
       searchParams
     }) => {
-      if (isLocalMode) {
-        const data = await loadData();
-        return data;
-      }
       const jsonData = {
         model,
         method: "load_data" /* LOAD_DATA */,
@@ -4478,10 +3983,59 @@ var loadDataPosSessionService = (env) => {
         service
       );
     },
-    [env, isLocalMode]
+    [env]
   );
+  const loadDataPosSessionSupabase = useCallback23(async () => {
+    try {
+      const allModels = Object.values(LoadDataModel);
+      const promises = allModels.map(async (modelName) => {
+        const tableName = MODEL_TO_TABLE[modelName];
+        if (!tableName) {
+          return {
+            modelName,
+            data: [],
+            fields: {},
+            relations: {}
+          };
+        }
+        const { data, error } = await supabase.from(tableName).select("*");
+        if (error) {
+          console.error(`Error loading ${modelName}:`, error);
+          return {
+            modelName,
+            data: [],
+            fields: {},
+            relations: {}
+          };
+        }
+        return {
+          modelName,
+          data: data || [],
+          fields: {},
+          relations: {}
+        };
+      });
+      const results = await Promise.all(promises);
+      const response = results.reduce(
+        (acc, { modelName, data, fields, relations }) => {
+          acc[modelName] = {
+            data,
+            fields,
+            relations
+          };
+          return acc;
+        },
+        {}
+      );
+      return response;
+    } catch (error) {
+      console.error("Error loading data from Supabase:", error);
+      return {};
+    }
+  }, [supabase]);
   return {
-    loadDataPosSession
+    loadDataPosSession,
+    loadDataPosSessionSupabase
   };
 };
 
@@ -4703,8 +4257,6 @@ var updateClosedSessionService = (env) => {
 // src/services/pos-service/update-entity.ts
 import { useCallback as useCallback30 } from "react";
 var updateEntityService = (env) => {
-  const isLocalMode = env?.isLocalMode;
-  const repo = new ModelRepository();
   const updateEntity = useCallback30(
     ({
       model,
@@ -4714,15 +4266,6 @@ var updateEntityService = (env) => {
       xNode,
       service
     }) => {
-      if (isLocalMode) {
-        const id = extractIdFromDomain(domain);
-        if (!id) return;
-        return repo.updateRecord({
-          update: values,
-          modelName: model,
-          id
-        });
-      }
       const jsonData = {
         model,
         domain,
@@ -4740,7 +4283,7 @@ var updateEntityService = (env) => {
         service
       );
     },
-    [env, isLocalMode]
+    [env]
   );
   return {
     updateEntity
@@ -4950,19 +4493,16 @@ 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/hooks/pos/use-complete-current-stage.ts
-import { useMutation as useMutation87 } from "@tanstack/react-query";
+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);
+import { jsx as jsx7 } from "react/jsx-runtime";
+var ServiceContext = createContext3(null);
 
 // src/provider/meta-provider.tsx
 import { useEffect as useEffect3 } from "react";
-import { Fragment as Fragment2, jsx as jsx7 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx8 } from "react/jsx-runtime";
 
 // src/services/action-service/index.ts
 function useActionService() {
@@ -7114,57 +6654,12 @@ function useDashboardService() {
   );
   return { readGroup, getDataChart };
 }
-
-// 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,