react-toolkits 2.26.0 → 2.27.0

package/lib/chunk-Z7GW3RVV.js

@@ -0,0 +1,658 @@
+import { createStore, create, useStore } from 'zustand';
+import { App } from 'antd';
+import { createContext, useRef, useContext, useMemo } from 'react';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import { jwtDecode } from 'jwt-decode';
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { useQueryClient } from '@tanstack/react-query';
+import ky from 'ky';
+import { useNavigate } from 'react-router-dom';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function createVisibilityStore() {
+  return create()((set, get) => ({
+    open: /* @__PURE__ */ new Map(),
+    usedIds: /* @__PURE__ */ new Set(),
+    isOpen(uuid) {
+      return get().open.get(uuid) ?? false;
+    },
+    show(uuid) {
+      set({ open: new Map(get().open).set(uuid, true) });
+    },
+    hide(uuid) {
+      set({ open: new Map(get().open).set(uuid, false) });
+    },
+    hideAll() {
+      set({ open: /* @__PURE__ */ new Map() });
+    },
+    checkUniqueness(uuid) {
+      return !get().usedIds.has(uuid);
+    },
+    registerIds(uuid) {
+      const { usedIds } = get();
+      if (usedIds.has(uuid)) return false;
+      set({ usedIds: new Set(usedIds).add(uuid) });
+      return true;
+    },
+    cleanup(uuid) {
+      const { open, usedIds } = get();
+      const newOpen = new Map(open);
+      const newUsedIds = new Set(usedIds);
+      newOpen.delete(uuid);
+      newUsedIds.delete(uuid);
+      set({ open: newOpen, usedIds: newUsedIds });
+    }
+  }));
+}
+__name(createVisibilityStore, "createVisibilityStore");
+
+// src/utils/generateId.ts
+var globalCounter = 0;
+var generateId = /* @__PURE__ */ __name(() => {
+  const timestamp = Date.now();
+  const random = Math.floor(Math.random() * 1e3);
+  const counter = ++globalCounter % 1e3;
+  return timestamp * 1e6 + random * 1e3 + counter;
+}, "generateId");
+
+// src/utils/mixedStorage.ts
+var mixedStorage = {
+  getItem(name) {
+    return sessionStorage.getItem(name) ?? localStorage.getItem(name);
+  },
+  setItem(name, value) {
+    sessionStorage.setItem(name, value);
+    localStorage.setItem(name, value);
+  },
+  removeItem(name) {
+    sessionStorage.removeItem(name);
+    localStorage.removeItem(name);
+  }
+};
+
+// src/constants/index.ts
+var SSO_URL = "https://idaas.ifunplus.cn/enduser/api/application/plugin_FunPlus/sso/v1";
+var APP_ID_HEADER = "App-ID";
+var FRONTEND_ROUTE_PREFIX = "/console/";
+var PermissionMode = /* @__PURE__ */ ((PermissionMode2) => {
+  PermissionMode2["GAME_SCOPED"] = "game_scoped";
+  PermissionMode2["GROUP_BASED"] = "group_based";
+  PermissionMode2["DIRECT_GAME"] = "direct_game";
+  return PermissionMode2;
+})(PermissionMode || {});
+var WILDCARD = "*";
+
+// src/locale/zh_CN.ts
+var locale = {
+  global: {
+    noEntitlement: "\u65E0\u6743\u9650\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458",
+    name: "\u540D\u79F0",
+    creationTime: "\u521B\u5EFA\u65F6\u95F4",
+    operation: "\u64CD\u4F5C",
+    update: "\u66F4\u65B0",
+    edit: "\u7F16\u8F91",
+    delete: "\u5220\u9664",
+    selectAll: "\u5168\u9009",
+    game: "\u6E38\u620F",
+    user: "\u7528\u6237",
+    role: "\u89D2\u8272",
+    username: "\u7528\u6237\u540D",
+    password: "\u5BC6\u7801",
+    label: "\u6807\u7B7E",
+    method: "\u65B9\u6CD5",
+    route: "\u8DEF\u7531",
+    request: "\u8BF7\u6C42",
+    response: "\u54CD\u5E94",
+    add: "\u6DFB\u52A0",
+    signIn: "\u767B\u5F55",
+    projectGroup: "\u9879\u76EE\u7EC4",
+    view: "\u67E5\u770B",
+    back: "\u8FD4\u56DE"
+  },
+  SignIn: {
+    title: "\u767B\u5F55\u65B9\u5F0F",
+    signInWithIDass: "IDass \u767B\u5F55",
+    unregistered: "\u60A8\u8FD8\u672A\u5728\u5E73\u53F0\u6CE8\u518C\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458",
+    welcome: "\u6B22\u8FCE"
+  },
+  NotFound: {
+    subTitle: "\u8BBF\u95EE\u7684\u9875\u9762\u4E0D\u5B58\u5728",
+    buttonText: "\u8FD4\u56DE\u9996\u9875"
+  },
+  FilterFormWrapper: {
+    confirmText: "\u67E5\u8BE2",
+    resetText: "\u91CD\u7F6E"
+  },
+  FormModal: {
+    confirmText: "\u786E\u8BA4",
+    cancelText: "\u53D6\u6D88"
+  },
+  GameSelect: {
+    label: "\u5F53\u524D\u6E38\u620F",
+    placeholder: "\u8BF7\u9009\u62E9\u6E38\u620F"
+  },
+  RequireGame: {
+    description: "\u8BF7\u9009\u62E9\u6E38\u620F"
+  },
+  UserDropdown: {
+    signOutText: "\u767B\u51FA"
+  },
+  User: {
+    createTitle: "\u521B\u5EFA\u7528\u6237",
+    createSuccessfully: "\u7528\u6237\u521B\u5EFA\u6210\u529F",
+    updateTitle: "\u66F4\u65B0\u7528\u6237",
+    updateSuccessfully: "\u7528\u6237\u66F4\u65B0\u6210\u529F",
+    deleteTitle: "\u5220\u9664\u7528\u6237",
+    deleteContent: "\u786E\u5B9A\u8981\u5220\u9664\u7528\u6237 <%= user %> \u5417\uFF1F",
+    deleteSuccessfully: "\u7528\u6237\u5220\u9664\u6210\u529F"
+  },
+  Role: {
+    createTitle: "\u521B\u5EFA\u89D2\u8272",
+    createSuccessfully: "\u89D2\u8272\u521B\u5EFA\u6210\u529F",
+    updateTitle: "\u66F4\u65B0\u89D2\u8272",
+    updateSuccessfully: "\u89D2\u8272\u66F4\u65B0\u6210\u529F",
+    deleteTitle: "\u5220\u9664\u89D2\u8272",
+    deleteContent: "\u786E\u5B9A\u8981\u5220\u9664\u89D2\u8272 <%= role %> \u5417\uFF1F",
+    deleteSuccessfully: "\u89D2\u8272\u5220\u9664\u6210\u529F"
+  },
+  PermissionList: {
+    failedDescription: "\u83B7\u53D6\u6743\u9650\u5217\u8868\u5931\u8D25",
+    baseSectionTitle: "\u5E73\u53F0\u57FA\u7840\u6743\u9650",
+    gameSectionTitle: "\u6E38\u620F\u6743\u9650",
+    gameSectionDescription: "\u8BF7\u5148\u9009\u62E9\u6E38\u620F",
+    gameSelectPlaceholder: "\u8BF7\u5148\u9009\u62E9\u6E38\u620F",
+    removeText: "\u79FB\u9664",
+    addText: "\u6DFB\u52A0\u6E38\u620F\u6743\u9650"
+  },
+  RoleDetail: {
+    title: "\u89D2\u8272\u8BE6\u60C5"
+  },
+  InfiniteList: {
+    loadingText: "\u52A0\u8F7D\u4E2D",
+    reachEndText: "\u5DF2\u7ECF\u5230\u5E95\u4E86",
+    loadMoreText: "\u52A0\u8F7D\u66F4\u591A"
+  }
+};
+var zh_CN_default = locale;
+
+// src/stores/context.ts
+var defaultContextSlice = {
+  locale: zh_CN_default,
+  useGameApiV2: false,
+  isGlobalMode: false,
+  gameScoped: false,
+  loginPath: "/sign_in",
+  homePath: "/",
+  permissionMode: "game_scoped" /* GAME_SCOPED */,
+  sidebarWidth: 250
+};
+var createContextSlice = /* @__PURE__ */ __name(() => ({
+  ...defaultContextSlice
+}), "createContextSlice");
+
+// src/stores/game.ts
+var createGameSlice = /* @__PURE__ */ __name((set) => ({
+  setAppId: /* @__PURE__ */ __name((id) => set(() => ({ appId: id })), "setAppId")
+}), "createGameSlice");
+
+// src/stores/layout.ts
+var createLayoutSlice = /* @__PURE__ */ __name((set) => ({
+  collapsed: false,
+  toggleCollapsed: /* @__PURE__ */ __name(() => set((s) => ({ collapsed: !s.collapsed })), "toggleCollapsed")
+}), "createLayoutSlice");
+var decodeToken = /* @__PURE__ */ __name((token) => {
+  if (!token) return null;
+  try {
+    return jwtDecode(token);
+  } catch {
+    return null;
+  }
+}, "decodeToken");
+var createTokenSlice = /* @__PURE__ */ __name((set) => ({
+  token: void 0,
+  user: null,
+  setToken: /* @__PURE__ */ __name((token) => set(() => ({ token, user: decodeToken(token) })), "setToken"),
+  clearToken: /* @__PURE__ */ __name(() => set(() => ({ token: void 0, user: null })), "clearToken")
+}), "createTokenSlice");
+
+// src/stores/index.ts
+function createSliceAdapter(set, get, key) {
+  const sliceSet = /* @__PURE__ */ __name((partial, replace) => {
+    if (replace) {
+      const update = typeof partial === "function" ? partial(get()[key]) : partial;
+      set({ ...get(), [key]: update }, true);
+    } else if (typeof partial === "function") {
+      set((state) => {
+        const updated = { ...state[key], ...partial(state[key]) };
+        return { [key]: updated };
+      });
+    } else {
+      set((state) => {
+        const updated = { ...state[key], ...partial };
+        return { [key]: updated };
+      });
+    }
+  }, "sliceSet");
+  const sliceGet = /* @__PURE__ */ __name(() => get()[key], "sliceGet");
+  return { set: sliceSet, get: sliceGet };
+}
+__name(createSliceAdapter, "createSliceAdapter");
+var createToolkitsStore = /* @__PURE__ */ __name((initProps) => {
+  return createStore()(
+    persist(
+      (set, get, store) => {
+        const createSlice = /* @__PURE__ */ __name((key, creator) => {
+          const adapter = createSliceAdapter(set, get, key);
+          const sliceStore = store;
+          return creator(adapter.set, adapter.get, sliceStore);
+        }, "createSlice");
+        const tokenSlice = createSlice("token", createTokenSlice);
+        const gameSlice = createSlice("game", createGameSlice);
+        const layoutSlice = createSlice("layout", createLayoutSlice);
+        const contextSlice = createSlice("context", createContextSlice);
+        return {
+          context: {
+            ...contextSlice,
+            ...initProps
+          },
+          token: tokenSlice,
+          game: gameSlice,
+          layout: layoutSlice,
+          clear: /* @__PURE__ */ __name(() => {
+            get().token.clearToken();
+            store.persist.clearStorage();
+          }, "clear")
+        };
+      },
+      {
+        name: "ToolkitsStore",
+        storage: createJSONStorage(() => mixedStorage),
+        partialize: /* @__PURE__ */ __name((state) => ({
+          token: state.token.token,
+          appId: state.game.appId,
+          user: state.token.user,
+          collapsed: state.layout.collapsed
+        }), "partialize"),
+        merge: /* @__PURE__ */ __name((persistedState, currentState) => {
+          const { token, user, appId, collapsed } = persistedState;
+          return {
+            ...currentState,
+            token: { ...currentState.token, token, user },
+            game: { ...currentState.game, appId },
+            layout: { ...currentState.layout, collapsed: collapsed ?? currentState.layout.collapsed }
+          };
+        }, "merge")
+      }
+    )
+  );
+}, "createToolkitsStore");
+var ToolkitsContext = createContext(null);
+function useToolkitsStore(selector) {
+  const store = useContext(ToolkitsContext);
+  if (!store) {
+    const componentStack = new Error().stack;
+    const componentName = componentStack?.split("\n")[2]?.trim() || "Unknown";
+    throw new Error(
+      `Missing ToolkitsProvider in the tree. Component "${componentName}" must be wrapped with <ToolkitsProvider>. Please ensure ToolkitsProvider is rendered above this component in the component tree.`
+    );
+  }
+  return useStore(store, selector ?? ((state) => state));
+}
+__name(useToolkitsStore, "useToolkitsStore");
+var ToolkitsProvider = /* @__PURE__ */ __name((props) => {
+  const { children, ...restProps } = props;
+  const storeRef = useRef(void 0);
+  const parentStore = useContext(ToolkitsContext);
+  if (!storeRef.current) {
+    const parentContext = parentStore?.getState().context ?? {};
+    storeRef.current = createToolkitsStore({ ...parentContext, ...restProps });
+  }
+  if (!storeRef.current.getState().context.loginPath) {
+    throw new Error('ToolkitsProvider: \u8BF7\u914D\u7F6E "loginPath"');
+  }
+  return /* @__PURE__ */ jsx(ToolkitsContext.Provider, { value: storeRef.current, children: /* @__PURE__ */ jsx(App, { children: /* @__PURE__ */ jsx(Fragment, { children }) }) });
+}, "ToolkitsProvider");
+{
+  ToolkitsProvider.displayName = "ToolkitsProvider";
+}
+var ToolkitsProvider_default = ToolkitsProvider;
+var SUCCESS_RESPONSE_CODES = [0, 1, 200];
+var HTTP_STATUS = {
+  OK: 200,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  UNREGISTERED: 412
+};
+var REQUEST_TIMEOUT = 3e4;
+var extractErrorMessage = /* @__PURE__ */ __name((data) => {
+  if (!data || typeof data !== "object") {
+    return "Unknown error";
+  }
+  return data.msg || data.message || data.error || "Unknown error";
+}, "extractErrorMessage");
+var isStatusCodeSuccess = /* @__PURE__ */ __name((config) => {
+  const { value, allowedCodes } = config;
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if (typeof value !== "number") {
+    return false;
+  }
+  return allowedCodes.includes(value);
+}, "isStatusCodeSuccess");
+var isSuccessResponse = /* @__PURE__ */ __name((data, status) => {
+  if (status < HTTP_STATUS.OK || status >= 300) {
+    return false;
+  }
+  if (!data || typeof data !== "object") {
+    return true;
+  }
+  const statusChecks = [
+    { field: "code", value: data.code, allowedCodes: SUCCESS_RESPONSE_CODES },
+    { field: "status", value: data.status, allowedCodes: SUCCESS_RESPONSE_CODES },
+    { field: "errno", value: data.errno, allowedCodes: SUCCESS_RESPONSE_CODES }
+  ];
+  const hasBusinessStatusCode = statusChecks.some((config) => config.value !== void 0 && config.value !== null);
+  if (hasBusinessStatusCode) {
+    return statusChecks.every(
+      (config) => config.value === void 0 || config.value === null || isStatusCodeSuccess(config)
+    );
+  }
+  return true;
+}, "isSuccessResponse");
+var processResponseByType = /* @__PURE__ */ __name(async (response, responseType) => {
+  switch (responseType) {
+    case "blob":
+      return response.blob();
+    case "text":
+      return response.text();
+    case "arrayBuffer":
+      return response.arrayBuffer();
+    case "formData":
+      return response.formData();
+    case "json":
+    default:
+      return response.json();
+  }
+}, "processResponseByType");
+var useKy = /* @__PURE__ */ __name((config) => {
+  const { baseURL } = config || {};
+  const { notification } = App.useApp();
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+  const {
+    token: { token },
+    context: { isGlobalMode, loginPath, apiBaseUrl },
+    game: { appId },
+    clear
+  } = useToolkitsStore();
+  const handleUnauthorized = /* @__PURE__ */ __name(() => {
+    clear();
+    queryClient.clear();
+    navigate(loginPath);
+  }, "handleUnauthorized");
+  const handleUnregistered = /* @__PURE__ */ __name(() => {
+    clear();
+    queryClient.clear();
+    if (loginPath) {
+      const url = new URL(loginPath, window.location.origin);
+      url.searchParams.set("unregistered", "true");
+      navigate(url.toString());
+    }
+  }, "handleUnregistered");
+  const handleForbidden = /* @__PURE__ */ __name(() => {
+    notification.error({
+      title: "\u8BBF\u95EE\u88AB\u7981\u6B62",
+      description: "\u60A8\u6CA1\u6709\u6743\u9650\u8BBF\u95EE\u6B64\u8D44\u6E90\u3002"
+    });
+  }, "handleForbidden");
+  const createResponseHandler = /* @__PURE__ */ __name((responseType) => {
+    return async (_request, _options, response) => {
+      if (responseType === "blob" || responseType === "arrayBuffer" || responseType === "text" || responseType === "formData") {
+        return response;
+      }
+      let data;
+      try {
+        data = await response.clone().json();
+      } catch {
+        return response;
+      }
+      if (isSuccessResponse(data, response.status)) {
+        return new Response(JSON.stringify(data), {
+          status: response.status,
+          statusText: response.statusText,
+          headers: response.headers
+        });
+      }
+      const errorMessage = extractErrorMessage(data);
+      notification.error({
+        title: "Request failed",
+        description: errorMessage
+      });
+      const error = new Error(errorMessage);
+      error.response = response;
+      error.data = data;
+      throw error;
+    };
+  }, "createResponseHandler");
+  const handleHttpStatusError = /* @__PURE__ */ __name((status, data) => {
+    switch (status) {
+      case HTTP_STATUS.UNAUTHORIZED:
+        handleUnauthorized();
+        break;
+      case HTTP_STATUS.UNREGISTERED:
+        handleUnregistered();
+        break;
+      case HTTP_STATUS.FORBIDDEN:
+        handleForbidden();
+        break;
+      default: {
+        const errorMessage = extractErrorMessage(data) || `HTTP ${status} Error`;
+        notification.error({
+          title: "Request failed",
+          description: errorMessage
+        });
+        break;
+      }
+    }
+  }, "handleHttpStatusError");
+  const instance = useMemo(() => {
+    return ky.create({
+      prefixUrl: baseURL ?? apiBaseUrl,
+      retry: 0,
+      timeout: REQUEST_TIMEOUT,
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      hooks: {
+        beforeRequest: [
+          (request2) => {
+            if (token) {
+              request2.headers.set("Authorization", `Bearer ${token}`);
+            }
+            if (!request2.headers.has(APP_ID_HEADER)) {
+              if (isGlobalMode || !appId) {
+                request2.headers.set(APP_ID_HEADER, "global");
+              } else {
+                request2.headers.set(APP_ID_HEADER, encodeURIComponent(String(appId)));
+              }
+            }
+          }
+        ],
+        beforeError: [
+          async (error) => {
+            const { response } = error;
+            if (response) {
+              const status = response.status;
+              let data;
+              try {
+                const contentType = response.headers.get("content-type") || "";
+                if (contentType.includes("application/json") || contentType.startsWith("text/")) {
+                  data = await response.clone().json();
+                }
+              } catch {
+              }
+              handleHttpStatusError(status, data);
+            } else {
+              notification.error({
+                title: "Network Error",
+                description: error.message || "Network request failed"
+              });
+            }
+            return error;
+          }
+        ]
+      }
+    });
+  }, [baseURL, token, isGlobalMode, appId, notification, loginPath, clear, queryClient, apiBaseUrl]);
+  const makeRequest = /* @__PURE__ */ __name(async (method, url, data, requestOptions) => {
+    const { responseType, ...kyOptions } = requestOptions || {};
+    const finalOptions = {
+      ...kyOptions,
+      hooks: {
+        ...kyOptions.hooks,
+        afterResponse: [...kyOptions.hooks?.afterResponse || [], createResponseHandler(responseType)]
+      }
+    };
+    let response;
+    if (data) {
+      response = await instance(url, { method, json: data, ...finalOptions });
+    } else {
+      response = await instance(url, { method, ...finalOptions });
+    }
+    return processResponseByType(response, responseType);
+  }, "makeRequest");
+  const get = /* @__PURE__ */ __name((url, options2) => {
+    return makeRequest("GET", url, void 0, options2);
+  }, "get");
+  const post = /* @__PURE__ */ __name((url, data, options2) => {
+    return makeRequest("POST", url, data, options2);
+  }, "post");
+  const put = /* @__PURE__ */ __name((url, data, options2) => {
+    return makeRequest("PUT", url, data, options2);
+  }, "put");
+  const del = /* @__PURE__ */ __name((url, options2) => {
+    return makeRequest("DELETE", url, void 0, options2);
+  }, "del");
+  const patch = /* @__PURE__ */ __name((url, data, options2) => {
+    return makeRequest("PATCH", url, data, options2);
+  }, "patch");
+  const options = /* @__PURE__ */ __name((url, requestOptions) => {
+    return makeRequest("OPTIONS", url, void 0, requestOptions);
+  }, "options");
+  const head = /* @__PURE__ */ __name((url, requestOptions) => {
+    return makeRequest("HEAD", url, void 0, requestOptions);
+  }, "head");
+  const request = /* @__PURE__ */ __name((requestOptions) => {
+    const { url, ...requestOpts } = requestOptions;
+    return makeRequest(requestOpts.method || "GET", url, void 0, requestOpts);
+  }, "request");
+  return {
+    get,
+    post,
+    put,
+    delete: del,
+    patch,
+    options,
+    head,
+    request,
+    instance
+  };
+}, "useKy");
+var extractData = /* @__PURE__ */ __name((response) => {
+  if (response && typeof response === "object" && "data" in response && response.data !== void 0) {
+    return response.data;
+  }
+  return response;
+}, "extractData");
+var useHttpRequest = /* @__PURE__ */ __name((config) => {
+  const kyClient = useKy(config);
+  return {
+    get: /* @__PURE__ */ __name((url, options) => {
+      return kyClient.get(url, options).then(extractData);
+    }, "get"),
+    post: /* @__PURE__ */ __name((url, data, options) => {
+      return kyClient.post(url, data, options).then(extractData);
+    }, "post"),
+    put: /* @__PURE__ */ __name((url, data, options) => {
+      return kyClient.put(url, data, options).then(extractData);
+    }, "put"),
+    delete: /* @__PURE__ */ __name((url, options) => {
+      return kyClient.delete(url, options).then(extractData);
+    }, "delete"),
+    patch: /* @__PURE__ */ __name((url, data, options) => {
+      return kyClient.patch(url, data, options).then(extractData);
+    }, "patch"),
+    options: /* @__PURE__ */ __name((url, requestOptions) => {
+      return kyClient.options(url, requestOptions).then(extractData);
+    }, "options"),
+    head: /* @__PURE__ */ __name((url, requestOptions) => {
+      return kyClient.head(url, requestOptions).then(extractData);
+    }, "head"),
+    request: /* @__PURE__ */ __name((requestOptions) => {
+      return kyClient.request(requestOptions).then(extractData);
+    }, "request")
+  };
+}, "useHttpRequest");
+var useHttpGet = /* @__PURE__ */ __name((config) => {
+  const http = useHttpRequest(config);
+  return http.get;
+}, "useHttpGet");
+var useHttpPost = /* @__PURE__ */ __name((config) => {
+  const http = useHttpRequest(config);
+  return http.post;
+}, "useHttpPost");
+
+// src/queryKeys.ts
+var queryKeys = {
+  // 权限相关
+  permissions: {
+    check: /* @__PURE__ */ __name((permissions, mode) => ["permissions", "check", permissions, mode], "check"),
+    allPermissions: ["permissions", "all"],
+    allPermissionsV2: ["permissions", "allV2"]
+  },
+  // 用户相关
+  users: {
+    all: ["users"],
+    detail: /* @__PURE__ */ __name((id) => ["users", "detail", id], "detail"),
+    create: ["users", "create"],
+    update: ["users", "update"],
+    delete: ["users", "delete"]
+  },
+  // 角色相关
+  roles: {
+    all: ["roles"],
+    detail: /* @__PURE__ */ __name((name, mode) => ["roles", "detail", name, mode], "detail"),
+    create: /* @__PURE__ */ __name((mode) => ["roles", "create", mode], "create"),
+    update: /* @__PURE__ */ __name((mode) => ["roles", "update", mode], "update"),
+    delete: ["roles", "delete"]
+  },
+  // 菜单相关
+  menus: {
+    all: ["menus"],
+    navbar: /* @__PURE__ */ __name((appId) => ["menus", "navbar", appId], "navbar"),
+    detail: /* @__PURE__ */ __name((id) => ["menus", "detail", id], "detail"),
+    create: ["menus", "create"],
+    update: ["menus", "update"],
+    delete: ["menus", "delete"]
+  },
+  // 枚举相关
+  enums: {
+    gameGroups: ["enums", "gameGroups"],
+    gameIds: /* @__PURE__ */ __name((gameGroups) => ["enums", "gameIds", gameGroups], "gameIds")
+  },
+  // 游戏相关
+  games: {
+    all: ["games", "all"]
+  },
+  // 认证相关
+  auth: {
+    ticketLogin: /* @__PURE__ */ __name((ticket) => ["auth", "ticket-login", ticket], "ticketLogin")
+  }
+};
+
+export { APP_ID_HEADER, FRONTEND_ROUTE_PREFIX, PermissionMode, SSO_URL, ToolkitsProvider_default, WILDCARD, __name, createVisibilityStore, generateId, mixedStorage, queryKeys, useHttpGet, useHttpPost, useKy, useToolkitsStore };
+//# sourceMappingURL=chunk-Z7GW3RVV.js.map
+//# sourceMappingURL=chunk-Z7GW3RVV.js.map