@lasterp/shared 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/{rn/index.rn.js → index.cjs}

@@ -1,10 +1,138 @@
 "use client";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  useVariantSelector: () => useVariantSelector,
+  useSearch: () => useSearch,
+  useLocale: () => useLocale,
+  useFrappeUpdateDoc: () => useFrappeUpdateDoc,
+  useFrappePutCall: () => useFrappePutCall,
+  useFrappePrefetchDoc: () => useFrappePrefetchDoc,
+  useFrappePostCall: () => useFrappePostCall,
+  useFrappeGetMeta: () => useFrappeGetMeta,
+  useFrappeGetDocList: () => useFrappeGetDocList,
+  useFrappeGetDocCount: () => useFrappeGetDocCount,
+  useFrappeGetDoc: () => useFrappeGetDoc,
+  useFrappeGetCall: () => useFrappeGetCall,
+  useFrappeFileUpload: () => useFrappeFileUpload,
+  useFrappeEventListener: () => useFrappeEventListener,
+  useFrappeDocumentEventListener: () => useFrappeDocumentEventListener,
+  useFrappeDocTypeEventListener: () => useFrappeDocTypeEventListener,
+  useFrappeDeleteDoc: () => useFrappeDeleteDoc,
+  useFrappeDeleteCall: () => useFrappeDeleteCall,
+  useFrappeCreateDoc: () => useFrappeCreateDoc,
+  useFrappeAuth: () => useFrappeAuth,
+  screenFormSchema: () => screenFormSchema,
+  modelFormSchema: () => modelFormSchema,
+  itemFormSchema: () => itemFormSchema,
+  equalsIgnoreCase: () => equalsIgnoreCase,
+  decamelizeKeys: () => import_humps.decamelizeKeys,
+  decamelize: () => import_humps.decamelize,
+  colourFormSchema: () => colourFormSchema,
+  camelizeKeys: () => import_humps.camelizeKeys,
+  camelize: () => import_humps.camelize,
+  LocaleProvider: () => LocaleProvider,
+  FrappeProvider: () => FrappeProvider,
+  FrappeContext: () => FrappeContext,
+  COLOR_SYSTEMS: () => COLOR_SYSTEMS,
+  ATTRIBUTES: () => ATTRIBUTES
+});
+module.exports = __toCommonJS(exports_src);
+// src/catalog/schema.ts
+var import_zod = require("zod");
+var ATTRIBUTES = ["Colour", "Storage", "Memory", "Screen"];
+var COLOR_SYSTEMS = [
+  "White",
+  "Black",
+  "Yellow",
+  "Red",
+  "Green",
+  "Blue",
+  "Purple",
+  "Orange",
+  "Pink",
+  "Brown",
+  "Gray",
+  "Silver",
+  "Gold"
+];
+var colourFormSchema = import_zod.z.object({
+  color: import_zod.z.string().min(1, "Color is required"),
+  color_hex: import_zod.z.string().optional(),
+  color_system: import_zod.z.enum(COLOR_SYSTEMS).optional(),
+  images: import_zod.z.array(import_zod.z.union([import_zod.z.instanceof(File), import_zod.z.string()])).default([])
+});
+var screenFormSchema = import_zod.z.object({
+  screen: import_zod.z.string().min(1, "Screen is required"),
+  height: import_zod.z.number().positive().optional(),
+  width: import_zod.z.number().positive().optional(),
+  weight: import_zod.z.number().positive().optional()
+});
+var modelFormSchema = import_zod.z.object({
+  model: import_zod.z.string().min(1, "Model is required"),
+  sim_card_type: import_zod.z.string().optional(),
+  connectivity: import_zod.z.array(import_zod.z.string())
+});
+var itemFormSchema = import_zod.z.object({
+  item_code: import_zod.z.string().min(1, "Item is required"),
+  item_group: import_zod.z.string().optional(),
+  brand: import_zod.z.string().optional(),
+  os: import_zod.z.string().optional(),
+  release_year: import_zod.z.number().int().min(1900).max(2100).optional(),
+  attributes: import_zod.z.array(import_zod.z.enum(ATTRIBUTES)),
+  colours: import_zod.z.array(colourFormSchema),
+  storages: import_zod.z.array(import_zod.z.string()),
+  memories: import_zod.z.array(import_zod.z.string()),
+  screens: import_zod.z.array(screenFormSchema),
+  models: import_zod.z.array(modelFormSchema)
+});
 // src/frappe/provider.tsx
-import { useMemo, createContext } from "react";
-import { FrappeApp } from "frappe-js-sdk";
+var import_react = require("react");
+var import_frappe_js_sdk = require("frappe-js-sdk");
 
 // src/frappe/socket.ts
-import io from "socket.io-client";
+var import_socket = __toESM(require("socket.io-client"));
 
 class SocketIO {
   socket_port;
@@ -35,7 +163,7 @@ class SocketIO {
       this.url = `${this.url}${site_name}`;
     }
     this.site_name = site_name;
-    this.socket = io(`${this.url}`, {
+    this.socket = import_socket.default(`${this.url}`, {
       withCredentials: true,
       secure: this.protocol === "https",
       extraHeaders: tokenParams && tokenParams.useToken === true ? {
@@ -46,9 +174,9 @@ class SocketIO {
 }
 
 // src/frappe/provider.tsx
-import { jsx } from "react/jsx-runtime";
+var jsx_runtime = require("react/jsx-runtime");
 
-var FrappeContext = createContext(null);
+var FrappeContext = import_react.createContext(null);
 var FrappeProvider = ({
   url = "",
   tokenParams,
@@ -58,8 +186,8 @@ var FrappeProvider = ({
   children,
   customHeaders
 }) => {
-  const frappeConfig = useMemo(() => {
-    const frappe = new FrappeApp(url, tokenParams, undefined, customHeaders);
+  const config = import_react.useMemo(() => {
+    const frappe = new import_frappe_js_sdk.FrappeApp(url, tokenParams, undefined, customHeaders);
     return {
       url,
       tokenParams,
@@ -71,19 +199,19 @@ var FrappeProvider = ({
       socket: enableSocket ? new SocketIO(url, siteName, socketPort, tokenParams).socket : undefined
     };
   }, [url, tokenParams, enableSocket, socketPort, siteName, customHeaders]);
-  return /* @__PURE__ */ jsx(FrappeContext.Provider, {
-    value: frappeConfig,
+  return /* @__PURE__ */ jsx_runtime.jsx(FrappeContext.Provider, {
+    value: config,
     children
   });
 };
 // src/frappe/hooks/auth.ts
-import { useCallback, useContext, useState, useEffect } from "react";
-import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+var import_react2 = require("react");
+var import_react_query = require("@tanstack/react-query");
 var useFrappeAuth = () => {
-  const queryClient = useQueryClient();
-  const { auth, tokenParams } = useContext(FrappeContext);
-  const [userID, setUserID] = useState();
-  const getUserCookie = useCallback(() => {
+  const queryClient = import_react_query.useQueryClient();
+  const { auth, tokenParams } = import_react2.useContext(FrappeContext);
+  const [userID, setUserID] = import_react2.useState();
+  const getUserCookie = import_react2.useCallback(() => {
     const userCookie = document.cookie.split(";").find((c) => c.trim().startsWith("user_id="));
     if (userCookie) {
       const userName = userCookie.split("=")[1];
@@ -96,7 +224,7 @@ var useFrappeAuth = () => {
       setUserID(null);
     }
   }, []);
-  useEffect(() => {
+  import_react2.useEffect(() => {
     if (tokenParams && tokenParams.useToken) {
       setUserID(null);
     } else {
@@ -108,7 +236,7 @@ var useFrappeAuth = () => {
     error,
     isLoading,
     isFetching: isValidating
-  } = useQuery({
+  } = import_react_query.useQuery({
     queryKey: ["currentUser", { tokenParams, userID }],
     queryFn: () => auth.getLoggedInUser(),
     enabled: !!(tokenParams?.useToken || userID),
@@ -116,14 +244,14 @@ var useFrappeAuth = () => {
     refetchOnWindowFocus: false,
     staleTime: Infinity
   });
-  const loginMutation = useMutation({
+  const loginMutation = import_react_query.useMutation({
     mutationFn: (credentials) => auth.loginWithUsernamePassword(credentials),
     onSuccess: () => {
       getUserCookie();
       queryClient.invalidateQueries({ queryKey: ["currentUser"] });
     }
   });
-  const logoutMutation = useMutation({
+  const logoutMutation = import_react_query.useMutation({
     mutationFn: () => auth.logout(),
     onSuccess: () => {
       setUserID(null);
@@ -142,8 +270,8 @@ var useFrappeAuth = () => {
   };
 };
 // src/frappe/hooks/call.ts
-import { useContext as useContext2 } from "react";
-import { useMutation as useMutation2, useQuery as useQuery2 } from "@tanstack/react-query";
+var import_react3 = require("react");
+var import_react_query2 = require("@tanstack/react-query");
 
 // src/frappe/utils.ts
 function encodeQueryData(data) {
@@ -155,13 +283,21 @@ function encodeQueryData(data) {
 
 // src/frappe/hooks/call.ts
 var useFrappeGetCall = (method, params, options, type = "GET") => {
-  const { call } = useContext2(FrappeContext);
+  const { call } = import_react3.useContext(FrappeContext);
   const urlParams = encodeQueryData(params ?? {});
   const url = `${method}?${urlParams}`;
   const queryKey = ["frappeCall", type, method, url];
-  const { data, error, isLoading, isFetching, refetch } = useQuery2({
+  const { data, error, isLoading, isFetching, refetch } = import_react_query2.useQuery({
     queryKey,
-    queryFn: type === "GET" ? () => call.get(method, params) : () => call.post(method, params),
+    queryFn: async () => {
+      if (type === "GET") {
+        const response = await call.get(method, params);
+        return response.message;
+      } else {
+        const response = await call.post(method, params);
+        return response.message;
+      }
+    },
     enabled: (options?.enabled ?? true) && !!method,
     staleTime: options?.staleTime,
     retry: options?.retry ?? false
@@ -175,9 +311,9 @@ var useFrappeGetCall = (method, params, options, type = "GET") => {
   };
 };
 var useFrappeMutation = (method, httpMethod) => {
-  const { call: frappeCall } = useContext2(FrappeContext);
+  const { call: frappeCall } = import_react3.useContext(FrappeContext);
   const queryKey = ["frappeCall", httpMethod, method];
-  const { mutateAsync, data, isPending, error, isSuccess, reset } = useMutation2({
+  const { mutateAsync, data, isPending, error, isSuccess, reset } = import_react_query2.useMutation({
     mutationKey: queryKey,
     mutationFn: (params) => {
       if (httpMethod === "POST")
@@ -200,12 +336,12 @@ var useFrappePostCall = (method) => useFrappeMutation(method, "POST");
 var useFrappePutCall = (method) => useFrappeMutation(method, "PUT");
 var useFrappeDeleteCall = (method) => useFrappeMutation(method, "DELETE");
 // src/frappe/hooks/count.ts
-import { useContext as useContext3 } from "react";
-import { useQuery as useQuery3 } from "@tanstack/react-query";
+var import_react4 = require("react");
+var import_react_query3 = require("@tanstack/react-query");
 var useFrappeGetDocCount = (doctype, filters, debug = false, options) => {
-  const { url, db } = useContext3(FrappeContext);
+  const { url, db } = import_react4.useContext(FrappeContext);
   const queryKey = ["docCount", url, doctype, filters ?? [], debug];
-  const { data, error, isLoading, isFetching, refetch } = useQuery3({
+  const { data, error, isLoading, isFetching, refetch } = import_react_query3.useQuery({
     queryKey,
     queryFn: () => db.getCount(doctype, filters, debug),
     enabled: !!doctype,
@@ -220,11 +356,11 @@ var useFrappeGetDocCount = (doctype, filters, debug = false, options) => {
   };
 };
 // src/frappe/hooks/create.ts
-import { useContext as useContext4 } from "react";
-import { useMutation as useMutation3 } from "@tanstack/react-query";
+var import_react5 = require("react");
+var import_react_query4 = require("@tanstack/react-query");
 var useFrappeCreateDoc = () => {
-  const { db } = useContext4(FrappeContext);
-  const { mutateAsync, isPending, error, isSuccess, reset } = useMutation3({
+  const { db } = import_react5.useContext(FrappeContext);
+  const { mutateAsync, isPending, error, isSuccess, reset } = import_react_query4.useMutation({
     mutationFn: ({ doctype, doc }) => db.createDoc(doctype, doc)
   });
   const createDoc = (doctype, doc) => mutateAsync({ doctype, doc });
@@ -237,11 +373,11 @@ var useFrappeCreateDoc = () => {
   };
 };
 // src/frappe/hooks/delete.ts
-import { useContext as useContext5 } from "react";
-import { useMutation as useMutation4 } from "@tanstack/react-query";
+var import_react6 = require("react");
+var import_react_query5 = require("@tanstack/react-query");
 var useFrappeDeleteDoc = () => {
-  const { db } = useContext5(FrappeContext);
-  const { mutateAsync, isPending, error, isSuccess, reset } = useMutation4({
+  const { db } = import_react6.useContext(FrappeContext);
+  const { mutateAsync, isPending, error, isSuccess, reset } = import_react_query5.useMutation({
     mutationFn: ({ doctype, docname }) => db.deleteDoc(doctype, docname)
   });
   const deleteDoc = (doctype, docname) => mutateAsync({ doctype, docname });
@@ -254,10 +390,10 @@ var useFrappeDeleteDoc = () => {
   };
 };
 // src/frappe/hooks/event.ts
-import { useCallback as useCallback2, useContext as useContext6, useState as useState2, useEffect as useEffect2 } from "react";
+var import_react7 = require("react");
 var useFrappeEventListener = (eventName, callback) => {
-  const { socket } = useContext6(FrappeContext);
-  useEffect2(() => {
+  const { socket } = import_react7.useContext(FrappeContext);
+  import_react7.useEffect(() => {
     if (socket === undefined) {
       console.warn("Socket is not enabled. Please enable socket in FrappeProvider.");
     }
@@ -268,9 +404,9 @@ var useFrappeEventListener = (eventName, callback) => {
   }, [eventName, callback, socket]);
 };
 var useFrappeDocumentEventListener = (doctype, docname, onUpdateCallback, emitOpenCloseEventsOnMount = true) => {
-  const { socket } = useContext6(FrappeContext);
-  const [viewers, setViewers] = useState2([]);
-  useEffect2(() => {
+  const { socket } = import_react7.useContext(FrappeContext);
+  const [viewers, setViewers] = import_react7.useState([]);
+  import_react7.useEffect(() => {
     if (socket === undefined) {
       console.warn("Socket is not enabled. Please enable socket in FrappeProvider.");
     }
@@ -291,13 +427,13 @@ var useFrappeDocumentEventListener = (doctype, docname, onUpdateCallback, emitOp
     };
   }, [doctype, docname, emitOpenCloseEventsOnMount, socket]);
   useFrappeEventListener("doc_update", onUpdateCallback);
-  const emitDocOpen = useCallback2(() => {
+  const emitDocOpen = import_react7.useCallback(() => {
     socket?.emit("doc_open", doctype, docname);
   }, [doctype, docname, socket]);
-  const emitDocClose = useCallback2(() => {
+  const emitDocClose = import_react7.useCallback(() => {
     socket?.emit("doc_close", doctype, docname);
   }, [doctype, docname, socket]);
-  const onViewerEvent = useCallback2((data) => {
+  const onViewerEvent = import_react7.useCallback((data) => {
     if (data.doctype === doctype && data.docname === docname) {
       setViewers(data.users);
     }
@@ -310,8 +446,8 @@ var useFrappeDocumentEventListener = (doctype, docname, onUpdateCallback, emitOp
   };
 };
 var useFrappeDocTypeEventListener = (doctype, onListUpdateCallback) => {
-  const { socket } = useContext6(FrappeContext);
-  useEffect2(() => {
+  const { socket } = import_react7.useContext(FrappeContext);
+  import_react7.useEffect(() => {
     if (socket === undefined) {
       console.warn("Socket is not enabled. Please enable socket in FrappeProvider.");
     }
@@ -328,18 +464,18 @@ var useFrappeDocTypeEventListener = (doctype, onListUpdateCallback) => {
   useFrappeEventListener("list_update", onListUpdateCallback);
 };
 // src/frappe/hooks/file.ts
-import { useContext as useContext7, useState as useState3 } from "react";
-import { useMutation as useMutation5 } from "@tanstack/react-query";
+var import_react8 = require("react");
+var import_react_query6 = require("@tanstack/react-query");
 var useFrappeFileUpload = () => {
-  const { file } = useContext7(FrappeContext);
-  const [progress, setProgress] = useState3(0);
+  const { file } = import_react8.useContext(FrappeContext);
+  const [progress, setProgress] = import_react8.useState(0);
   const {
     mutateAsync,
     isPending,
     error,
     isSuccess,
     reset: resetMutation
-  } = useMutation5({
+  } = import_react_query6.useMutation({
     mutationFn: ({ f, args, apiPath }) => {
       setProgress(0);
       return file.uploadFile(f, args, (completed, total) => {
@@ -366,15 +502,15 @@ var useFrappeFileUpload = () => {
   };
 };
 // src/frappe/hooks/get.ts
-import { useContext as useContext8 } from "react";
-import { useQuery as useQuery4 } from "@tanstack/react-query";
+var import_react9 = require("react");
+var import_react_query7 = require("@tanstack/react-query");
 var useFrappeGetDoc = (doctype, name, options) => {
-  const { url, db } = useContext8(FrappeContext);
+  const { url, db } = import_react9.useContext(FrappeContext);
   const queryKey = ["doc", url, doctype, name];
-  const { data, error, isLoading, isFetching, refetch } = useQuery4({
+  const { data, error, isLoading, isFetching, refetch } = import_react_query7.useQuery({
     queryKey,
     queryFn: () => db.getDoc(doctype, name),
-    enabled: !!name,
+    enabled: options?.enabled ?? true,
     staleTime: options?.staleTime ?? 5 * 60 * 1000,
     retry: options?.retry ?? false
   });
@@ -387,14 +523,12 @@ var useFrappeGetDoc = (doctype, name, options) => {
   };
 };
 // src/frappe/hooks/list.ts
-import { useContext as useContext9 } from "react";
-import {
-  useQuery as useQuery5
-} from "@tanstack/react-query";
+var import_react10 = require("react");
+var import_react_query8 = require("@tanstack/react-query");
 var useFrappeGetDocList = (doctype, args, options) => {
-  const { url, db } = useContext9(FrappeContext);
+  const { url, db } = import_react10.useContext(FrappeContext);
   const queryKey = ["docList", url, doctype, args ?? null];
-  const { data, error, isLoading, isFetching, refetch } = useQuery5({
+  const { data, error, isLoading, isFetching, refetch } = import_react_query8.useQuery({
     queryKey,
     queryFn: () => db.getDocList(doctype, args),
     ...options
@@ -408,12 +542,12 @@ var useFrappeGetDocList = (doctype, args, options) => {
   };
 };
 // src/frappe/hooks/prefetch.ts
-import { useCallback as useCallback3, useContext as useContext10 } from "react";
-import { useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+var import_react11 = require("react");
+var import_react_query9 = require("@tanstack/react-query");
 var useFrappePrefetchDoc = (doctype, name, options) => {
-  const queryClient = useQueryClient2();
-  const { url, db } = useContext10(FrappeContext);
-  const preloadDoc = useCallback3(() => {
+  const queryClient = import_react_query9.useQueryClient();
+  const { url, db } = import_react11.useContext(FrappeContext);
+  const preloadDoc = import_react11.useCallback(() => {
     if (!name)
       return;
     const queryKey = ["doc", url, doctype, name];
@@ -426,7 +560,7 @@ var useFrappePrefetchDoc = (doctype, name, options) => {
   return preloadDoc;
 };
 // src/frappe/hooks/search.ts
-import { useEffect as useEffect3, useState as useState4 } from "react";
+var import_react12 = require("react");
 var useSearch = (doctype, text, filters = [], limit = 20, debounce = 250) => {
   const debouncedText = useDebounce(text, debounce);
   return useFrappeGetCall("frappe.desk.search.search_link", {
@@ -437,8 +571,8 @@ var useSearch = (doctype, text, filters = [], limit = 20, debounce = 250) => {
   });
 };
 var useDebounce = (value, delay) => {
-  const [debouncedValue, setDebouncedValue] = useState4(value);
-  useEffect3(() => {
+  const [debouncedValue, setDebouncedValue] = import_react12.useState(value);
+  import_react12.useEffect(() => {
     const handler = setTimeout(() => {
       setDebouncedValue(value);
     }, delay);
@@ -449,11 +583,11 @@ var useDebounce = (value, delay) => {
   return debouncedValue;
 };
 // src/frappe/hooks/update.ts
-import { useContext as useContext11 } from "react";
-import { useMutation as useMutation6 } from "@tanstack/react-query";
+var import_react13 = require("react");
+var import_react_query10 = require("@tanstack/react-query");
 var useFrappeUpdateDoc = () => {
-  const { db } = useContext11(FrappeContext);
-  const { mutateAsync, isPending, error, isSuccess, reset } = useMutation6({
+  const { db } = import_react13.useContext(FrappeContext);
+  const { mutateAsync, isPending, error, isSuccess, reset } = import_react_query10.useMutation({
     mutationFn: ({ doctype, docname, doc }) => db.updateDoc(doctype, docname, doc)
   });
   const updateDoc = (doctype, docname, doc) => mutateAsync({ doctype, docname, doc });
@@ -465,8 +599,31 @@ var useFrappeUpdateDoc = () => {
     reset
   };
 };
+// src/frappe/hooks/meta.ts
+var import_react14 = require("react");
+var import_react_query11 = require("@tanstack/react-query");
+var useFrappeGetMeta = (doctype, options) => {
+  const { url, call } = import_react14.useContext(FrappeContext);
+  const { data, error, isLoading, isFetching, refetch } = import_react_query11.useQuery({
+    queryKey: ["meta", url, doctype],
+    queryFn: async () => {
+      const response = await call.get("lasterp.api.get_meta", { doctype });
+      return response.message;
+    },
+    enabled: !!doctype,
+    staleTime: options?.staleTime ?? Infinity,
+    retry: options?.retry ?? false
+  });
+  return {
+    data,
+    error,
+    isLoading,
+    isFetching,
+    refetch
+  };
+};
 // src/hooks/use-variant-selector/hook.ts
-import { useCallback as useCallback4, useMemo as useMemo2, useState as useState5 } from "react";
+var import_react15 = require("react");
 
 // src/hooks/use-variant-selector/utils.ts
 function findVariant(variants, specs, caseInsensitive) {
@@ -499,21 +656,21 @@ function findVariants(variants, specs, caseInsensitive) {
 // src/hooks/use-variant-selector/hook.ts
 var useVariantSelector = (props) => {
   const { variants, attributes, defaultId } = props;
-  const [selectedSpecs, setSelectedSpecs] = useState5(() => {
+  const [selectedSpecs, setSelectedSpecs] = import_react15.useState(() => {
     if (defaultId) {
       const variant = variants.find((v) => v.id === defaultId);
       return variant?.specs || {};
     }
     return {};
   });
-  const variantId = useMemo2(() => {
+  const variantId = import_react15.useMemo(() => {
     const complete = attributes.every((attr) => selectedSpecs[attr.key]);
     if (!complete)
       return;
     const variant = findVariant(variants, selectedSpecs);
     return variant?.id;
   }, [variants, selectedSpecs, attributes]);
-  const options = useMemo2(() => {
+  const options = import_react15.useMemo(() => {
     const result = {};
     attributes.forEach((attr, attrIndex) => {
       const constraints = {};
@@ -536,7 +693,7 @@ var useVariantSelector = (props) => {
     });
     return result;
   }, [variants, attributes, selectedSpecs]);
-  const onOptionSelect = useCallback4((key, value) => {
+  const onOptionSelect = import_react15.useCallback((key, value) => {
     setSelectedSpecs((prev) => {
       const newSpecs = { ...prev, [key]: value };
       const attrIndex = attributes.findIndex((a) => a.key === key);
@@ -570,84 +727,54 @@ var useVariantSelector = (props) => {
     getOptions: (key) => options[key] || []
   };
 };
-// src/utils/char.ts
-import { camelize, decamelize, camelizeKeys, decamelizeKeys } from "humps";
-function equalsIgnoreCase(str1, str2) {
-  return str1.localeCompare(str2, undefined, { sensitivity: "accent" }) === 0;
+// src/locale/provider.tsx
+var import_react16 = require("react");
+var jsx_runtime2 = require("react/jsx-runtime");
+function translate(message, replace, messages = {}) {
+  let translated = messages[message] ?? message;
+  replace?.forEach((val, i) => {
+    translated = translated.replace(`{${i}}`, String(val));
+  });
+  return translated;
 }
-// src/context/server-provider.rn.tsx
-import {
-  useCallback as useCallback5,
-  useEffect as useEffect4,
-  useRef
-} from "react";
-import { useLogto } from "@logto/rn";
-import { jsx as jsx2 } from "react/jsx-runtime";
-var TOKEN_STALE_MS = 50 * 60 * 1000;
-function ServerProvider({
-  frappeUrl,
-  siteName,
-  resource,
+var LocaleContext = import_react16.createContext((message) => message);
+function LocaleProvider({
+  method,
+  language,
+  storage,
   children
 }) {
-  const { getAccessToken, isAuthenticated } = useLogto();
-  const tokenRef = useRef("");
-  const fetchedAtRef = useRef(0);
-  const isRefreshingRef = useRef(false);
-  const refresh = useCallback5(async () => {
-    const token = await getAccessToken(resource);
-    if (token) {
-      tokenRef.current = token;
-      fetchedAtRef.current = Date.now();
-    }
-  }, [getAccessToken, resource]);
-  useEffect4(() => {
-    if (isAuthenticated)
-      refresh();
-  }, [isAuthenticated, refresh]);
-  const getToken = useCallback5(() => {
-    if (!isRefreshingRef.current && fetchedAtRef.current > 0 && Date.now() - fetchedAtRef.current > TOKEN_STALE_MS) {
-      isRefreshingRef.current = true;
-      refresh().finally(() => {
-        isRefreshingRef.current = false;
-      });
-    }
-    return tokenRef.current;
-  }, [refresh]);
-  return /* @__PURE__ */ jsx2(FrappeProvider, {
-    url: frappeUrl,
-    siteName,
-    customHeaders: siteName ? { "X-Frappe-Site-Name": siteName } : undefined,
-    enableSocket: false,
-    tokenParams: { useToken: true, token: getToken, type: "Bearer" },
+  const [messages, setMessages] = import_react16.useState({});
+  import_react16.useEffect(() => {
+    if (!storage)
+      return;
+    const key = `locale:${language}`;
+    Promise.resolve(storage.getItem(key)).then((cached) => {
+      if (cached)
+        setMessages(JSON.parse(cached));
+    }).catch(() => {});
+  }, [language, storage]);
+  const { data, isLoading } = useFrappeGetCall(method, { lang: language }, { staleTime: Infinity });
+  import_react16.useEffect(() => {
+    if (!data)
+      return;
+    setMessages(data);
+    storage?.setItem(`locale:${language}`, JSON.stringify(data));
+  }, [data, language, storage]);
+  const __ = import_react16.useCallback((message, replace) => translate(message, replace, messages), [messages]);
+  if (isLoading && Object.keys(messages).length === 0)
+    return null;
+  return /* @__PURE__ */ jsx_runtime2.jsx(LocaleContext.Provider, {
+    value: __,
     children
   });
 }
-export {
-  useVariantSelector,
-  useSearch,
-  useFrappeUpdateDoc,
-  useFrappePutCall,
-  useFrappePrefetchDoc,
-  useFrappePostCall,
-  useFrappeGetDocList,
-  useFrappeGetDocCount,
-  useFrappeGetDoc,
-  useFrappeGetCall,
-  useFrappeFileUpload,
-  useFrappeEventListener,
-  useFrappeDocumentEventListener,
-  useFrappeDocTypeEventListener,
-  useFrappeDeleteDoc,
-  useFrappeDeleteCall,
-  useFrappeCreateDoc,
-  useFrappeAuth,
-  equalsIgnoreCase,
-  decamelizeKeys,
-  decamelize,
-  camelizeKeys,
-  camelize,
-  ServerProvider,
-  FrappeProvider,
-  FrappeContext
-};
+function useLocale() {
+  const __ = import_react16.useContext(LocaleContext);
+  return { __ };
+}
+// src/utils/char.ts
+var import_humps = require("humps");
+function equalsIgnoreCase(str1, str2) {
+  return str1.localeCompare(str2, undefined, { sensitivity: "accent" }) === 0;
+}