@lasterp/shared 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/node/index.js

@@ -0,0 +1,496 @@
+// src/frappe/provider.tsx
+import { useMemo, createContext } from "react";
+import { FrappeApp } from "frappe-js-sdk";
+
+// src/frappe/socket.ts
+import io from "socket.io-client";
+
+class SocketIO {
+  socket_port;
+  host;
+  port;
+  protocol;
+  url;
+  site_name;
+  socket;
+  constructor(url, site_name, socket_port, tokenParams) {
+    this.socket_port = socket_port ?? "9000";
+    this.host = window.location?.hostname;
+    this.port = window.location?.port ? `:${this.socket_port}` : "";
+    this.protocol = window.location?.protocol === "https:" ? "https" : "http";
+    if (url) {
+      let urlObject = new URL(url);
+      urlObject.port = "";
+      if (socket_port) {
+        urlObject.port = socket_port;
+        this.url = urlObject.toString();
+      } else {
+        this.url = urlObject.toString();
+      }
+    } else {
+      this.url = `${this.protocol}://${this.host}${this.port}/`;
+    }
+    if (site_name) {
+      this.url = `${this.url}${site_name}`;
+    }
+    this.site_name = site_name;
+    this.socket = io(`${this.url}`, {
+      withCredentials: true,
+      secure: this.protocol === "https",
+      extraHeaders: tokenParams && tokenParams.useToken === true ? {
+        Authorization: `${tokenParams.type} ${tokenParams.token?.()}`
+      } : {}
+    });
+  }
+}
+
+// src/frappe/provider.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+var FrappeContext = createContext(null);
+var FrappeProvider = ({
+  url = "",
+  tokenParams,
+  enableSocket = true,
+  socketPort,
+  siteName,
+  children,
+  customHeaders
+}) => {
+  const frappeConfig = useMemo(() => {
+    const frappe = new FrappeApp(url, tokenParams, undefined, customHeaders);
+    return {
+      url,
+      tokenParams,
+      app: frappe,
+      auth: frappe.auth(),
+      db: frappe.db(),
+      call: frappe.call(),
+      file: frappe.file(),
+      socket: enableSocket ? new SocketIO(url, siteName, socketPort, tokenParams).socket : undefined
+    };
+  }, [url, tokenParams, enableSocket, socketPort, siteName, customHeaders]);
+  return /* @__PURE__ */ jsxDEV(FrappeContext.Provider, {
+    value: frappeConfig,
+    children
+  }, undefined, false, undefined, this);
+};
+// src/frappe/hooks/auth.ts
+import { useCallback, useContext, useState, useEffect } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+var useFrappeAuth = () => {
+  const queryClient = useQueryClient();
+  const { auth, tokenParams } = useContext(FrappeContext);
+  const [userID, setUserID] = useState();
+  const getUserCookie = useCallback(() => {
+    const userCookie = document.cookie.split(";").find((c) => c.trim().startsWith("user_id="));
+    if (userCookie) {
+      const userName = userCookie.split("=")[1];
+      if (userName && userName !== "Guest") {
+        setUserID(userName);
+      } else {
+        setUserID(null);
+      }
+    } else {
+      setUserID(null);
+    }
+  }, []);
+  useEffect(() => {
+    if (tokenParams && tokenParams.useToken) {
+      setUserID(null);
+    } else {
+      getUserCookie();
+    }
+  }, [tokenParams, getUserCookie]);
+  const {
+    data: currentUser,
+    error,
+    isLoading,
+    isFetching: isValidating
+  } = useQuery({
+    queryKey: ["currentUser", { tokenParams, userID }],
+    queryFn: () => auth.getLoggedInUser(),
+    enabled: !!(tokenParams?.useToken || userID),
+    retry: false,
+    refetchOnWindowFocus: false,
+    staleTime: Infinity
+  });
+  const loginMutation = useMutation({
+    mutationFn: (credentials) => auth.loginWithUsernamePassword(credentials),
+    onSuccess: () => {
+      getUserCookie();
+      queryClient.invalidateQueries({ queryKey: ["currentUser"] });
+    }
+  });
+  const logoutMutation = useMutation({
+    mutationFn: () => auth.logout(),
+    onSuccess: () => {
+      setUserID(null);
+      queryClient.setQueryData(["currentUser"], null);
+    }
+  });
+  return {
+    isLoading: userID === undefined || isLoading,
+    currentUser,
+    isValidating,
+    error,
+    login: loginMutation.mutateAsync,
+    logout: logoutMutation.mutateAsync,
+    updateCurrentUser: () => queryClient.invalidateQueries({ queryKey: ["currentUser"] }),
+    getUserCookie
+  };
+};
+// src/frappe/hooks/call.ts
+import { useContext as useContext2 } from "react";
+import { useMutation as useMutation2, useQuery as useQuery2 } from "@tanstack/react-query";
+
+// src/frappe/utils.ts
+function encodeQueryData(data) {
+  const ret = [];
+  for (let d in data)
+    ret.push(encodeURIComponent(d) + "=" + encodeURIComponent(data[d]));
+  return ret.join("&");
+}
+
+// src/frappe/hooks/call.ts
+var useFrappeGetCall = (method, params, options, type = "GET") => {
+  const { call } = useContext2(FrappeContext);
+  const urlParams = encodeQueryData(params ?? {});
+  const url = `${method}?${urlParams}`;
+  const queryKey = ["frappeCall", type, method, url];
+  const { data, error, isLoading, isFetching, refetch } = useQuery2({
+    queryKey,
+    queryFn: type === "GET" ? () => call.get(method, params) : () => call.post(method, params),
+    enabled: (options?.enabled ?? true) && !!method,
+    staleTime: options?.staleTime,
+    retry: options?.retry ?? false
+  });
+  return {
+    data,
+    error,
+    isLoading,
+    isFetching,
+    refetch
+  };
+};
+var useFrappeMutation = (method, httpMethod) => {
+  const { call: frappeCall } = useContext2(FrappeContext);
+  const queryKey = ["frappeCall", httpMethod, method];
+  const { mutateAsync, data, isPending, error, isSuccess, reset } = useMutation2({
+    mutationKey: queryKey,
+    mutationFn: (params) => {
+      if (httpMethod === "POST")
+        return frappeCall.post(method, params);
+      if (httpMethod === "PUT")
+        return frappeCall.put(method, params);
+      return frappeCall.delete(method, params);
+    }
+  });
+  return {
+    call: (params) => mutateAsync(params),
+    result: data ?? null,
+    loading: isPending,
+    error,
+    isCompleted: isSuccess,
+    reset
+  };
+};
+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 useFrappeGetDocCount = (doctype, filters, debug = false, options) => {
+  const { url, db } = useContext3(FrappeContext);
+  const queryKey = ["docCount", url, doctype, filters ?? [], debug];
+  const { data, error, isLoading, isFetching, refetch } = useQuery3({
+    queryKey,
+    queryFn: () => db.getCount(doctype, filters, debug),
+    enabled: !!doctype,
+    ...options
+  });
+  return {
+    data,
+    error,
+    isLoading,
+    isFetching,
+    refetch
+  };
+};
+// src/frappe/hooks/create.ts
+import { useContext as useContext4 } from "react";
+import { useMutation as useMutation3 } from "@tanstack/react-query";
+var useFrappeCreateDoc = () => {
+  const { db } = useContext4(FrappeContext);
+  const { mutateAsync, isPending, error, isSuccess, reset } = useMutation3({
+    mutationFn: ({ doctype, doc }) => db.createDoc(doctype, doc)
+  });
+  const createDoc = (doctype, doc) => mutateAsync({ doctype, doc });
+  return {
+    createDoc,
+    loading: isPending,
+    error,
+    isCompleted: isSuccess,
+    reset
+  };
+};
+// src/frappe/hooks/delete.ts
+import { useContext as useContext5 } from "react";
+import { useMutation as useMutation4 } from "@tanstack/react-query";
+var useFrappeDeleteDoc = () => {
+  const { db } = useContext5(FrappeContext);
+  const { mutateAsync, isPending, error, isSuccess, reset } = useMutation4({
+    mutationFn: ({ doctype, docname }) => db.deleteDoc(doctype, docname)
+  });
+  const deleteDoc = (doctype, docname) => mutateAsync({ doctype, docname });
+  return {
+    deleteDoc,
+    loading: isPending,
+    error,
+    isCompleted: isSuccess,
+    reset
+  };
+};
+// src/frappe/hooks/event.ts
+import { useCallback as useCallback2, useContext as useContext6, useState as useState2, useEffect as useEffect2 } from "react";
+var useFrappeEventListener = (eventName, callback) => {
+  const { socket } = useContext6(FrappeContext);
+  useEffect2(() => {
+    if (socket === undefined) {
+      console.warn("Socket is not enabled. Please enable socket in FrappeProvider.");
+    }
+    let listener = socket?.on(eventName, callback);
+    return () => {
+      listener?.off(eventName);
+    };
+  }, [eventName, callback, socket]);
+};
+var useFrappeDocumentEventListener = (doctype, docname, onUpdateCallback, emitOpenCloseEventsOnMount = true) => {
+  const { socket } = useContext6(FrappeContext);
+  const [viewers, setViewers] = useState2([]);
+  useEffect2(() => {
+    if (socket === undefined) {
+      console.warn("Socket is not enabled. Please enable socket in FrappeProvider.");
+    }
+    socket?.emit("doc_subscribe", doctype, docname);
+    const onReconnect = () => {
+      socket?.emit("doc_subscribe", doctype, docname);
+    };
+    socket?.io.on("reconnect", onReconnect);
+    if (emitOpenCloseEventsOnMount) {
+      socket?.emit("doc_open", doctype, docname);
+    }
+    return () => {
+      socket?.emit("doc_unsubscribe", doctype, docname);
+      if (emitOpenCloseEventsOnMount) {
+        socket?.emit("doc_close", doctype, docname);
+      }
+      socket?.io.off("reconnect", onReconnect);
+    };
+  }, [doctype, docname, emitOpenCloseEventsOnMount, socket]);
+  useFrappeEventListener("doc_update", onUpdateCallback);
+  const emitDocOpen = useCallback2(() => {
+    socket?.emit("doc_open", doctype, docname);
+  }, [doctype, docname, socket]);
+  const emitDocClose = useCallback2(() => {
+    socket?.emit("doc_close", doctype, docname);
+  }, [doctype, docname, socket]);
+  const onViewerEvent = useCallback2((data) => {
+    if (data.doctype === doctype && data.docname === docname) {
+      setViewers(data.users);
+    }
+  }, [doctype, docname]);
+  useFrappeEventListener("doc_viewers", onViewerEvent);
+  return {
+    viewers,
+    emitDocOpen,
+    emitDocClose
+  };
+};
+var useFrappeDocTypeEventListener = (doctype, onListUpdateCallback) => {
+  const { socket } = useContext6(FrappeContext);
+  useEffect2(() => {
+    if (socket === undefined) {
+      console.warn("Socket is not enabled. Please enable socket in FrappeProvider.");
+    }
+    socket?.emit("doctype_subscribe", doctype);
+    const onReconnect = () => {
+      socket?.emit("doctype_subscribe", doctype);
+    };
+    socket?.io.on("reconnect", onReconnect);
+    return () => {
+      socket?.emit("doctype_unsubscribe", doctype);
+      socket?.io.off("reconnect", onReconnect);
+    };
+  }, [doctype, socket]);
+  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 useFrappeFileUpload = () => {
+  const { file } = useContext7(FrappeContext);
+  const [progress, setProgress] = useState3(0);
+  const {
+    mutateAsync,
+    isPending,
+    error,
+    isSuccess,
+    reset: resetMutation
+  } = useMutation5({
+    mutationFn: ({ f, args, apiPath }) => {
+      setProgress(0);
+      return file.uploadFile(f, args, (completed, total) => {
+        if (total)
+          setProgress(Math.round(completed / total * 100));
+      }, apiPath).then((r) => {
+        setProgress(100);
+        return r.data.message;
+      });
+    }
+  });
+  const upload = (f, args, apiPath) => mutateAsync({ f, args, apiPath });
+  const reset = () => {
+    setProgress(0);
+    resetMutation();
+  };
+  return {
+    upload,
+    progress,
+    loading: isPending,
+    error: error ?? null,
+    isCompleted: isSuccess,
+    reset
+  };
+};
+// src/frappe/hooks/get.ts
+import { useContext as useContext8 } from "react";
+import { useQuery as useQuery4 } from "@tanstack/react-query";
+var useFrappeGetDoc = (doctype, name, options) => {
+  const { url, db } = useContext8(FrappeContext);
+  const queryKey = ["doc", url, doctype, name];
+  const { data, error, isLoading, isFetching, refetch } = useQuery4({
+    queryKey,
+    queryFn: () => db.getDoc(doctype, name),
+    enabled: !!name,
+    staleTime: options?.staleTime ?? 5 * 60 * 1000,
+    retry: options?.retry ?? false
+  });
+  return {
+    data,
+    error,
+    isLoading,
+    isFetching,
+    refetch
+  };
+};
+// src/frappe/hooks/list.ts
+import { useContext as useContext9 } from "react";
+import {
+  useQuery as useQuery5
+} from "@tanstack/react-query";
+var useFrappeGetDocList = (doctype, args, options) => {
+  const { url, db } = useContext9(FrappeContext);
+  const queryKey = ["docList", url, doctype, args ?? null];
+  const { data, error, isLoading, isFetching, refetch } = useQuery5({
+    queryKey,
+    queryFn: () => db.getDocList(doctype, args),
+    ...options
+  });
+  return {
+    data,
+    error: error ?? null,
+    isLoading,
+    isFetching,
+    refetch
+  };
+};
+// src/frappe/hooks/prefetch.ts
+import { useCallback as useCallback3, useContext as useContext10 } from "react";
+import { useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+var useFrappePrefetchDoc = (doctype, name, options) => {
+  const queryClient = useQueryClient2();
+  const { url, db } = useContext10(FrappeContext);
+  const preloadDoc = useCallback3(() => {
+    if (!name)
+      return;
+    const queryKey = ["doc", url, doctype, name];
+    queryClient.prefetchQuery({
+      queryKey,
+      queryFn: () => db.getDoc(doctype, name),
+      staleTime: options?.staleTime ?? 5 * 60 * 1000
+    });
+  }, [doctype, name, queryClient, options?.staleTime]);
+  return preloadDoc;
+};
+// src/frappe/hooks/search.ts
+import { useEffect as useEffect3, useState as useState4 } from "react";
+var useSearch = (doctype, text, filters = [], limit = 20, debounce = 250) => {
+  const debouncedText = useDebounce(text, debounce);
+  return useFrappeGetCall("frappe.desk.search.search_link", {
+    doctype,
+    page_length: limit,
+    txt: debouncedText,
+    filters: JSON.stringify(filters ?? [])
+  });
+};
+var useDebounce = (value, delay) => {
+  const [debouncedValue, setDebouncedValue] = useState4(value);
+  useEffect3(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+};
+// src/frappe/hooks/update.ts
+import { useContext as useContext11 } from "react";
+import { useMutation as useMutation6 } from "@tanstack/react-query";
+var useFrappeUpdateDoc = () => {
+  const { db } = useContext11(FrappeContext);
+  const { mutateAsync, isPending, error, isSuccess, reset } = useMutation6({
+    mutationFn: ({ doctype, docname, doc }) => db.updateDoc(doctype, docname, doc)
+  });
+  const updateDoc = (doctype, docname, doc) => mutateAsync({ doctype, docname, doc });
+  return {
+    updateDoc,
+    loading: isPending,
+    error,
+    isCompleted: isSuccess,
+    reset
+  };
+};
+// src/utils/char.ts
+import { camelize, decamelize, camelizeKeys, decamelizeKeys } from "humps";
+function equalsIgnoreCase(str1, str2) {
+  return str1.localeCompare(str2, undefined, { sensitivity: "accent" }) === 0;
+}
+export {
+  useSearch,
+  useFrappeUpdateDoc,
+  useFrappePutCall,
+  useFrappePrefetchDoc,
+  useFrappePostCall,
+  useFrappeGetDocList,
+  useFrappeGetDocCount,
+  useFrappeGetDoc,
+  useFrappeGetCall,
+  useFrappeFileUpload,
+  useFrappeEventListener,
+  useFrappeDocumentEventListener,
+  useFrappeDocTypeEventListener,
+  useFrappeDeleteDoc,
+  useFrappeDeleteCall,
+  useFrappeCreateDoc,
+  useFrappeAuth,
+  equalsIgnoreCase,
+  decamelizeKeys,
+  decamelize,
+  camelizeKeys,
+  camelize,
+  FrappeProvider,
+  FrappeContext
+};