gomtm 0.0.1 → 0.0.3

package/dist/esm/messageTypeRegistry.js

@@ -0,0 +1,36 @@
+import { createRegistry } from "@bufbuild/protobuf";
+import { BotService } from "gomtm/gomtmpb/mtm/sppb/bot_connect";
+import { CmdStartNoVnc, CmdStartSimpleCrawler, ConsumMessageReq, CxPageReq, HelloBotMessage } from "gomtm/gomtmpb/mtm/sppb/bot_pb";
+import { CxService } from "gomtm/gomtmpb/mtm/sppb/cx_connect";
+import { JobService } from "gomtm/gomtmpb/mtm/sppb/job_connect";
+import { MtmService } from "gomtm/gomtmpb/mtm/sppb/mtm_connect";
+import { SpService } from "gomtm/gomtmpb/mtm/sppb/sp_connect";
+const anypbTypeReg = createRegistry(
+  HelloBotMessage,
+  CxPageReq,
+  ConsumMessageReq,
+  CmdStartNoVnc,
+  CmdStartSimpleCrawler
+);
+const allServices = {};
+const registerService = (...s) => {
+  s.map((item) => {
+    const servieTypeName = item.typeName;
+    allServices[servieTypeName] = item;
+  });
+};
+const GetMtmServiceByTypeName = (serviceTypeName) => {
+  return allServices[serviceTypeName];
+};
+registerService(
+  MtmService,
+  SpService,
+  BotService,
+  JobService,
+  CxService
+);
+export {
+  GetMtmServiceByTypeName,
+  allServices,
+  anypbTypeReg
+};

package/dist/esm/mtmFetcher.d.ts

@@ -0,0 +1,13 @@
+import { Message, PartialMessage, ServiceType } from "@bufbuild/protobuf";
+import { MtUnaryCallError } from "./connectquery/utils";
+import { ExtInfo } from "./mtmcore";
+type CustomRequestInit = RequestInit & {
+    enableCache?: boolean;
+    enableLog?: boolean;
+};
+export declare const newMtmFetch: (extInfo: ExtInfo, initGlobal?: CustomRequestInit) => (input: string | URL | globalThis.Request, init?: CustomRequestInit) => Promise<Response>;
+export declare function getMtmApiUrl(backendUrl: string): string;
+export declare function createMtConnectTransport(backendUrl: string, extInfo: ExtInfo): import("@connectrpc/connect").Transport;
+export declare function createClient<T extends ServiceType>(extInfo: ExtInfo, svc: T, options: CustomRequestInit): import("@connectrpc/connect").PromiseClient<T>;
+export declare function mtmCallUnaryMethod<I extends Message<I>, O extends Message<O>>(extInfo: ExtInfo, svc: string, method: string, input?: PartialMessage<I> | undefined): Promise<O | MtUnaryCallError>;
+export {};

package/dist/esm/mtmFetcher.js

@@ -0,0 +1,145 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { createPromiseClient } from "@connectrpc/connect";
+import { createConnectTransport } from "@connectrpc/connect-web";
+import { camelCase, merge } from "lodash";
+import { fetchMiddleWithCache } from "./http/fetchMiddleWithCache";
+import { GetMtmServiceByTypeName, anypbTypeReg } from "./messageTypeRegistry";
+import { HeaderMtmHost } from "./consts";
+import { extGetMemBackend, extGetSitehost, extGetToken } from "./mtmcore";
+const newMtmFetch = (extInfo, initGlobal) => {
+  return (input, init) => __async(void 0, null, function* () {
+    if (init) {
+      delete init.mode;
+      delete init.credentials;
+    }
+    const req = merge(init, initGlobal, {
+      redirect: "follow"
+    }) || {};
+    const token = extGetToken(extInfo);
+    if (token) {
+      req.headers.set("Authorization", `Bearer ${token}`);
+    }
+    const siteHost = extGetSitehost(extInfo);
+    if (siteHost) {
+      req.headers.set(HeaderMtmHost, siteHost);
+    }
+    let fetcher = fetch;
+    if (req.enableCache) {
+      fetcher = fetchMiddleWithCache(fetch);
+    }
+    if (req.enableLog) {
+      fetcher = fetchWithLoger(fetcher);
+    }
+    try {
+      const responseData = yield fetcher(input, init);
+      return responseData;
+    } catch (e) {
+      console.error("mtmfetch error", e);
+      const errorRsp = {
+        error_code: "-1",
+        error_message: (e == null ? void 0 : e.toString()) || "unknow error"
+      };
+      const errorResponse = new Response(JSON.stringify(errorRsp), {
+        status: 200,
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      return errorResponse;
+    }
+  });
+};
+function getMtmApiUrl(backendUrl) {
+  return backendUrl + "/api";
+}
+function createMtConnectTransport(backendUrl, extInfo) {
+  return createConnectTransport({
+    baseUrl: getMtmApiUrl(backendUrl),
+    fetch: newMtmFetch(extInfo),
+    jsonOptions: {
+      typeRegistry: anypbTypeReg
+    }
+  });
+}
+function createClient(extInfo, svc, options) {
+  const backendUrl = extGetMemBackend(extInfo);
+  return createPromiseClient(svc, createConnectTransport({
+    baseUrl: getMtmApiUrl(backendUrl || ""),
+    fetch: newMtmFetch(extInfo, __spreadValues({}, options))
+  }));
+}
+function mtmCallUnaryMethod(extInfo, svc, method, input) {
+  return __async(this, null, function* () {
+    if (!method) {
+      throw new Error(`missing method: "${method}"`);
+    }
+    const service = GetMtmServiceByTypeName(svc);
+    if (!service) {
+      throw new Error(`not service by name ${svc}`);
+    }
+    const methodName = camelCase(method);
+    console.log(`[unary] ${svc}.${methodName}`, input);
+    const client = createClient(extInfo, service, {
+      enableCache: false
+    });
+    try {
+      const result = yield client[methodName](input);
+      return result;
+    } catch (e) {
+      console.error("[mtmCallUnaryMethod error]", e.stack);
+      const errorRsp = {
+        error_code: "-2",
+        error_message: (e == null ? void 0 : e.toString()) || "unknow error"
+      };
+      return errorRsp;
+    }
+  });
+}
+function fetchWithLoger(fetcher) {
+  return (input, init) => __async(this, null, function* () {
+    const response = yield fetcher(input, init);
+    return response;
+  });
+}
+export {
+  createClient,
+  createMtConnectTransport,
+  getMtmApiUrl,
+  mtmCallUnaryMethod,
+  newMtmFetch
+};

package/dist/esm/mtmcore.d.ts

@@ -0,0 +1,5 @@
+export type ExtInfo = (key: string) => string | null | undefined;
+export declare const extGetToken: (extInfo: ExtInfo) => string | null | undefined;
+export declare const extGetMemBackend: (extInfo: ExtInfo) => string | null | undefined;
+export declare const extGetSitehost: (extInfo: ExtInfo) => string | null | undefined;
+export declare const headersGet: (name: string, headers: Record<string, any>) => any;

package/dist/esm/mtmcore.js

@@ -0,0 +1,19 @@
+import { ExtKey_Hostname, ExtKey_mtmaccessToken, ExtKey_mtmbackend } from "./consts";
+const extGetToken = (extInfo) => {
+  return extInfo(ExtKey_mtmaccessToken);
+};
+const extGetMemBackend = (extInfo) => {
+  return extInfo(ExtKey_mtmbackend);
+};
+const extGetSitehost = (extInfo) => {
+  return extInfo(ExtKey_Hostname);
+};
+const headersGet = (name, headers) => {
+  return headers[name];
+};
+export {
+  extGetMemBackend,
+  extGetSitehost,
+  extGetToken,
+  headersGet
+};

package/dist/esm/providers/GomtmProvider.d.ts

@@ -0,0 +1,68 @@
+import { Dispatch, PropsWithChildren } from 'react';
+import React from 'react';
+export declare const mtmAppStore: {
+    get: <Value>(atom: import("jotai").Atom<Value>) => Value;
+    set: <Value_1, Args extends unknown[], Result>(atom: import("jotai").WritableAtom<Value_1, Args, Result>, ...args: Args) => Result;
+    sub: (atom: import("jotai").Atom<unknown>, listener: () => void) => () => void;
+    dev_subscribe_store?: ((l: (action: {
+        type: "write";
+        flushed: Set<import("jotai").Atom<unknown>>;
+    } | {
+        type: "async-write";
+        flushed: Set<import("jotai").Atom<unknown>>;
+    } | {
+        type: "sub";
+        flushed: Set<import("jotai").Atom<unknown>>;
+    } | {
+        type: "unsub";
+    } | {
+        type: "restore";
+        flushed: Set<import("jotai").Atom<unknown>>;
+    }) => void, rev: 2) => () => void) | undefined;
+    dev_get_mounted_atoms?: (() => IterableIterator<import("jotai").Atom<unknown>>) | undefined;
+    dev_get_atom_state?: ((a: import("jotai").Atom<unknown>) => ({
+        d: Map<import("jotai").Atom<unknown>, any & ({
+            e: unknown;
+        } | {
+            v: unknown;
+        })>;
+    } & ({
+        e: unknown;
+    } | {
+        v: unknown;
+    })) | undefined) | undefined;
+    dev_get_mounted?: ((a: import("jotai").Atom<unknown>) => {
+        l: Set<() => void>;
+        t: Set<import("jotai").Atom<unknown>>;
+        u?: (() => void) | undefined;
+    } | undefined) | undefined;
+    dev_restore_atoms?: ((values: Iterable<readonly [import("jotai").Atom<unknown>, unknown]>) => void) | undefined;
+};
+export type ActionHandler = (props: {
+    action: string;
+    values?: any;
+}) => void;
+interface IAppContext {
+    extKv: Record<string, any>;
+    token?: string | null;
+    hostname?: string | null;
+    backendUrl?: string | null;
+    trpcBackendUrl?: string | null;
+    isDebug?: boolean;
+    debugData?: any;
+    setDebugData: Dispatch<any>;
+    isOpenDebugView?: boolean;
+    setOpenDebugView: Dispatch<React.SetStateAction<boolean>>;
+}
+export declare function GomtmProvider(props: {
+    initExtKv: Record<string, any | undefined>;
+} & PropsWithChildren): React.JSX.Element;
+export declare function useMtmApp(): IAppContext;
+export declare const useMtmBackendUrl: () => string | null | undefined;
+export declare const useHostname: () => string;
+export declare const useExtInfo: () => (key: string) => string | null | undefined;
+export declare const useToken: () => {
+    token: string;
+    setToken: (newToken: string) => void;
+};
+export {};

package/dist/esm/providers/GomtmProvider.js

@@ -0,0 +1,100 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useMemo, useState } from "react";
+import { MtReactQueryProvider } from "gomtm/providers/ReactQueryProvider";
+import { Provider } from "jotai";
+import { ExtKey_Hostname, ExtKey_SelfBackend, ExtKey_mtmaccessToken, ExtKey_mtmbackend, MtM_TOKEN_NAME } from "../consts";
+import { MtConnectProvider } from "./MtConnectProvider";
+import { createStore } from "jotai";
+import { getCookie } from "../clientlib";
+const mtmAppStore = createStore();
+const AppContext = createContext(void 0);
+function GomtmProvider(props) {
+  const { children, initExtKv } = props;
+  const [isOpenDebugView, setOpenDebugView] = useState(false);
+  const [debugData, setDebugData] = useState(null);
+  const [isDebug, setIsDebug] = useState(false);
+  const trpcBackendUrl = useMemo(() => {
+    return initExtKv[ExtKey_SelfBackend];
+  }, [initExtKv]);
+  const backendUrl = useMemo(() => {
+    return initExtKv[ExtKey_mtmbackend];
+  }, [initExtKv]);
+  const hostname = useMemo(() => {
+    return initExtKv[ExtKey_Hostname];
+  }, [initExtKv]);
+  const token = useMemo(() => {
+    return initExtKv[ExtKey_mtmaccessToken];
+  }, [initExtKv]);
+  return /* @__PURE__ */ jsx(Provider, { store: mtmAppStore, children: /* @__PURE__ */ jsx(AppContext.Provider, { value: {
+    extKv: initExtKv,
+    token,
+    hostname,
+    backendUrl,
+    isDebug,
+    // setIsDebug: toggleDebug,
+    // meta, setMeta,
+    debugData,
+    setDebugData,
+    isOpenDebugView,
+    setOpenDebugView,
+    trpcBackendUrl
+  }, children: /* @__PURE__ */ jsx(MtReactQueryProvider, { children: /* @__PURE__ */ jsx(MtConnectProvider, { children }) }) }) });
+}
+function useMtmApp() {
+  const mtappContext = useContext(AppContext);
+  if (mtappContext === void 0) {
+    throw new Error("useMtmApp must be used within a MtAppProvider");
+  }
+  return mtappContext;
+}
+const useMtmBackendUrl = () => {
+  const { backendUrl } = useMtmApp();
+  return backendUrl;
+};
+const useHostname = () => {
+  const { hostname } = useMtmApp();
+  if (hostname)
+    return hostname;
+  return window.location.host;
+};
+const useExtInfo = () => {
+  const backendUrl = useMtmBackendUrl();
+  const siteHost = useHostname();
+  const { token } = useMtmApp();
+  const fn = useCallback((key) => {
+    switch (key) {
+      case ExtKey_mtmbackend:
+        return backendUrl;
+      case ExtKey_Hostname:
+        return siteHost;
+      case ExtKey_mtmaccessToken:
+        return token;
+      case ExtKey_SelfBackend:
+        return;
+      default:
+        throw new Error(`extinfo key error: ${key}`);
+    }
+  }, [backendUrl, siteHost, token]);
+  return fn;
+};
+const useToken = () => {
+  const [token] = useState(typeof window != "undefined" ? getCookie(MtM_TOKEN_NAME) : "");
+  return {
+    token: token || "",
+    setToken: (newToken) => {
+      if (typeof window != "undefined") {
+        document.cookie = `${MtM_TOKEN_NAME}=${newToken}`;
+      }
+    }
+  };
+};
+export {
+  GomtmProvider,
+  mtmAppStore,
+  useExtInfo,
+  useHostname,
+  useMtmApp,
+  useMtmBackendUrl,
+  useToken
+};

package/dist/esm/providers/MtConnectProvider.d.ts

@@ -0,0 +1,2 @@
+import { PropsWithChildren } from "react";
+export declare const MtConnectProvider: (props: PropsWithChildren) => import("react").JSX.Element;

package/dist/esm/providers/MtConnectProvider.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { createMtConnectTransport } from "gomtm/mtmFetcher";
+import { useMemo } from "react";
+import { TransportProvider } from "../connectquery";
+import { useExtInfo, useMtmBackendUrl } from "./GomtmProvider";
+const MtConnectProvider = (props) => {
+  const { children } = props;
+  const backendUrl = useMtmBackendUrl();
+  const extInfo = useExtInfo();
+  const transport = useMemo(() => {
+    return createMtConnectTransport(backendUrl || "", extInfo);
+  }, [backendUrl, extInfo]);
+  return /* @__PURE__ */ jsx(TransportProvider, { transport, children });
+};
+export {
+  MtConnectProvider
+};

package/dist/esm/providers/ReactQueryProvider.d.ts

@@ -0,0 +1,4 @@
+import { PropsWithChildren } from 'react';
+export declare const MtReactQueryProvider: (props: PropsWithChildren) => import("react").JSX.Element;
+export declare function RqErrorBoundary(props: PropsWithChildren): import("react").JSX.Element;
+export declare function RqErrorBoundaryUseHook(props: PropsWithChildren): import("react").JSX.Element;

package/dist/esm/providers/ReactQueryProvider.js

@@ -0,0 +1,63 @@
+"use client";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import {
+  QueryClient,
+  QueryClientProvider,
+  QueryErrorResetBoundary,
+  useQueryErrorResetBoundary
+} from "@tanstack/react-query";
+import { ReactQueryStreamedHydration } from "@tanstack/react-query-next-experimental";
+import { ErrorBoundary } from "react-error-boundary";
+const MtReactQueryProvider = (props) => {
+  const { children } = props;
+  const [queryClient] = useState(() => new QueryClient({
+    // 这里的参数需要 正确设置，因为 设置不正确可能会导致 hydrate 莫名其妙的错误。
+    // 其中，默认参数，经测试 hydrate ssr 没问题
+    defaultOptions: {
+      queries: {
+        refetchOnWindowFocus: false,
+        // default: true
+        staleTime: Infinity,
+        refetchOnMount: false,
+        refetchOnReconnect: false,
+        retry: false
+      }
+    }
+  }));
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx(RqErrorBoundary, { children: /* @__PURE__ */ jsx(ReactQueryStreamedHydration, { children }) }) }) });
+};
+function RqErrorBoundary(props) {
+  const { children } = props;
+  return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(QueryErrorResetBoundary, { children: ({ reset }) => /* @__PURE__ */ jsx(
+    ErrorBoundary,
+    {
+      onReset: reset,
+      fallbackRender: ({ resetErrorBoundary, error }) => /* @__PURE__ */ jsxs("div", { className: "green-red-100 prose dark:prose-invert container mx-auto p-8 text-lg", children: [
+        /* @__PURE__ */ jsx("div", { className: " pb-8 text-center", children: "some thing error" }),
+        /* @__PURE__ */ jsx("div", { children: error == null ? void 0 : error.toString() }),
+        /* @__PURE__ */ jsx("div", { className: "flex items-center justify-center p-8", children: /* @__PURE__ */ jsx("button", { onClick: () => resetErrorBoundary(), children: "Retry" }) })
+      ] }),
+      children
+    }
+  ) }) });
+}
+function RqErrorBoundaryUseHook(props) {
+  const { reset } = useQueryErrorResetBoundary();
+  return /* @__PURE__ */ jsx(
+    ErrorBoundary,
+    {
+      onReset: reset,
+      fallbackRender: ({ resetErrorBoundary }) => /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("div", { children: "There was an error\uFF08RqErrorBoundaryUseHook\uFF09!" }),
+        /* @__PURE__ */ jsx("button", { onClick: () => resetErrorBoundary(), children: "Try again" })
+      ] }),
+      children: props.children
+    }
+  );
+}
+export {
+  MtReactQueryProvider,
+  RqErrorBoundary,
+  RqErrorBoundaryUseHook
+};

package/dist/esm/providers/userContext.d.ts

@@ -0,0 +1,14 @@
+import { PlainMessage } from '@bufbuild/protobuf';
+import React, { PropsWithChildren } from 'react';
+import { UserinfoRes } from '../gomtmpb/mtm/sppb/mtm_pb';
+export declare function UserProvider(props: {} & PropsWithChildren): React.JSX.Element;
+export declare function useUser(): {
+    isLogined: boolean;
+    userInfo?: PlainMessage<UserinfoRes> | undefined;
+};
+export declare function useIsAdmin(): boolean | undefined;
+export declare function useRoles(): string[];
+export declare function isRoleMatch(currentRoles: string[], allowRoles?: string[]): boolean;
+export declare const useAuth: () => {
+    login: import("@tanstack/react-query").UseMutationResult<import("../gomtmpb/mtm/sppb/mtm_pb").LoginReply, import("@connectrpc/connect").ConnectError, import("@bufbuild/protobuf").PartialMessage<import("../gomtmpb/mtm/sppb/mtm_pb").LoginReq>>;
+};

package/dist/esm/providers/userContext.js

@@ -0,0 +1,99 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { jsx } from "react/jsx-runtime";
+import { useSearchParams } from "next/navigation";
+import React, { useMemo } from "react";
+import { useMutation, useSuspenseQuery } from "../connectquery";
+import { LOGIN_CALLBACK_URL_KEY, MtM_TOKEN_NAME } from "../consts";
+import { login, userinfo } from "../gomtmpb/mtm/sppb/mtm-MtmService_connectquery";
+import { useToken } from "./GomtmProvider";
+const UserContext = React.createContext(void 0);
+function UserProvider(props) {
+  const { children } = props;
+  const query = useSuspenseQuery(userinfo, {});
+  return /* @__PURE__ */ jsx(UserContext.Provider, { value: {
+    userInfo: query.data
+  }, children });
+}
+function useUser() {
+  var _a, _b;
+  const context = React.useContext(UserContext);
+  if (context === void 0) {
+    throw new Error("useUserContext must be used within a UserProvider");
+  }
+  return __spreadProps(__spreadValues({}, context), {
+    isLogined: !!((_b = (_a = context.userInfo) == null ? void 0 : _a.userInfo) == null ? void 0 : _b.ID)
+  });
+}
+function useIsAdmin() {
+  const user = useUser();
+  const isAdmin = useMemo(() => {
+    var _a, _b, _c;
+    return ((_a = user.userInfo) == null ? void 0 : _a.userInfo) && ((_c = (_b = user.userInfo) == null ? void 0 : _b.userInfo) == null ? void 0 : _c.roles.findIndex((x) => x == "admin")) >= 0;
+  }, [user.userInfo]);
+  return isAdmin;
+}
+function useRoles() {
+  const user = useUser();
+  const roles = useMemo(() => {
+    var _a, _b;
+    return ((_b = (_a = user.userInfo) == null ? void 0 : _a.userInfo) == null ? void 0 : _b.roles) || [];
+  }, [user.userInfo]);
+  return roles;
+}
+function isRoleMatch(currentRoles, allowRoles) {
+  if (!currentRoles) {
+    return true;
+  }
+  if (!(allowRoles == null ? void 0 : allowRoles.length)) {
+    return true;
+  }
+  for (const roleName of allowRoles) {
+    const ok = currentRoles.find((x) => x == roleName);
+    if (ok) {
+      return true;
+    }
+  }
+  return false;
+}
+const useAuth = () => {
+  const searchs = useSearchParams();
+  const { token, setToken } = useToken();
+  const loginMutation = useMutation(login, {
+    onSuccess(data, variables, context) {
+      console.log("set token", data.accessToken);
+      setToken(data.accessToken);
+      document.cookie = `${MtM_TOKEN_NAME}=${data.accessToken}`;
+      const backUrl = searchs.get(LOGIN_CALLBACK_URL_KEY) || "/";
+    }
+  });
+  return {
+    login: loginMutation
+  };
+};
+export {
+  UserProvider,
+  isRoleMatch,
+  useAuth,
+  useIsAdmin,
+  useRoles,
+  useUser
+};

package/dist/esm/utils.d.ts

@@ -0,0 +1 @@
+export declare function sha256WithAlphabets(message: any): Promise<string>;

package/dist/esm/utils.js

@@ -0,0 +1,32 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+function sha256WithAlphabets(message) {
+  return __async(this, null, function* () {
+    const buffer = new TextEncoder().encode(message);
+    const hashBuffer = yield crypto.subtle.digest("SHA-256", buffer);
+    const hashBase64 = btoa(String.fromCharCode(...new Uint8Array(hashBuffer)));
+    const alphabetsOnly = hashBase64.replace(/[^a-zA-Z]/g, "");
+    return alphabetsOnly;
+  });
+}
+export {
+  sha256WithAlphabets
+};