@zl-ui-kit/composables 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1439 @@
+// src/createCacheComputed.ts
+import { tryOnScopeDispose } from "@vueuse/core";
+import { computed } from "vue";
+function createCacheComputed(getter) {
+  const cache = /* @__PURE__ */ new Map();
+  const useComputed = (obj) => {
+    if (!cache.has(obj)) {
+      cache.set(obj, computed(() => getter(obj)));
+    }
+    return cache.get(obj);
+  };
+  tryOnScopeDispose(() => {
+    cache.clear();
+  });
+  return Object.assign(useComputed, {
+    clear: () => cache.clear()
+  });
+}
+
+// src/mergeMessages.ts
+function isPlainObject(value) {
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+function deepMerge(base, override) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    out[key] = isPlainObject(value) && isPlainObject(out[key]) ? deepMerge(out[key], value) : value;
+  }
+  return out;
+}
+function mergeMessages(base, ...overrides) {
+  let result = { ...base ?? {} };
+  for (const override of overrides) {
+    if (!override)
+      continue;
+    result = deepMerge(result, override);
+  }
+  return result;
+}
+
+// src/useDict.ts
+import { computed as computed2, inject, provide, ref } from "vue";
+import { createGlobalState } from "@vueuse/core";
+var useDictStore = createGlobalState(() => {
+  const dictStore = ref({});
+  const loadingKeys = ref({});
+  let globalSource = null;
+  function setDictSource2(source) {
+    globalSource = source;
+  }
+  function getDictSource2() {
+    return globalSource;
+  }
+  async function ensureDict(key, localSource) {
+    if (dictStore.value[key]?.length) {
+      return;
+    }
+    if (loadingKeys.value[key]) {
+      return;
+    }
+    const sources = [localSource, globalSource].filter(Boolean);
+    if (!sources.length) {
+      return;
+    }
+    loadingKeys.value = { ...loadingKeys.value, [key]: true };
+    try {
+      for (const source of sources) {
+        const items = typeof source === "function" ? await source(key) : source[key];
+        if (items?.length) {
+          dictStore.value = { ...dictStore.value, [key]: items };
+          break;
+        }
+      }
+    } finally {
+      loadingKeys.value = { ...loadingKeys.value, [key]: false };
+    }
+  }
+  return { dictStore, loadingKeys, setDictSource: setDictSource2, getDictSource: getDictSource2, ensureDict };
+});
+function setDictSource(source) {
+  useDictStore().setDictSource(source);
+}
+function getDictSource() {
+  return useDictStore().getDictSource();
+}
+var dictInjectKey = /* @__PURE__ */ Symbol("dictInjectKey");
+function useDictProvider(source) {
+  provide(dictInjectKey, { source });
+}
+function useDict(key, options = {}) {
+  const store = useDictStore();
+  const { source } = inject(dictInjectKey, {});
+  if (options.data?.length) {
+    store.dictStore.value = { ...store.dictStore.value, [key]: options.data };
+  } else {
+    store.ensureDict(key, source);
+  }
+  const dict = computed2(() => store.dictStore.value[key] || []);
+  const label = computed2(() => {
+    return dict.value.reduce((acc, item) => {
+      acc[item.value] = item.label;
+      return acc;
+    }, {});
+  });
+  return Object.assign(dict, { label });
+}
+
+// src/useGlobalMessage.ts
+import { ElMessage, ElMessageBox, ElNotification } from "element-plus";
+var confirmPromise = (config, onOk, onCancel) => {
+  const { throwOnOk, throwOnCancel, ...messageBoxOptions } = config;
+  return new Promise((resolve, reject) => {
+    ElMessageBox.confirm(messageBoxOptions.message ?? "", messageBoxOptions.title ?? "", {
+      ...messageBoxOptions,
+      beforeClose: async (action, instance, doneRaw) => {
+        const done = doneRaw;
+        const ctx = { close: done, resolve, reject, instance };
+        if (action === "confirm") {
+          try {
+            await onOk?.(ctx);
+            resolve("Ok");
+            done();
+          } catch (error) {
+            if (throwOnOk) {
+              done(false);
+              reject(error);
+            } else {
+              resolve(false);
+              done();
+            }
+          }
+        } else {
+          try {
+            await onCancel?.(ctx);
+            if (throwOnCancel) {
+              done(false);
+              reject(new Error("Cancel"));
+            } else {
+              resolve("Cancel");
+              done();
+            }
+          } catch (error) {
+            done(false);
+            reject(error);
+          }
+        }
+      }
+    }).catch(() => {
+    });
+  });
+};
+var MessageBox = Object.assign(ElMessageBox, { confirmPromise });
+function useGlobalMessage(_directMode = false) {
+  return { Message: ElMessage, Modal: MessageBox, Notification: ElNotification };
+}
+
+// src/useLocale.ts
+import { toValue as toValue2, watch as watch2 } from "vue";
+import { createI18n } from "vue-i18n";
+
+// src/useMicroGlobalData.ts
+import { isFunction, isPlainObject as isPlainObject2, withResolvers } from "@zl-ui-kit/utils";
+import _microApp from "@micro-zoe/micro-app";
+import { createGlobalState as createGlobalState2, useStorage } from "@vueuse/core";
+import { computed as computed3, customRef, nextTick, readonly, ref as ref2, toValue, watch } from "vue";
+var microApp = window.microApp || _microApp;
+var devMockEnabled = false;
+function enableGlobalDataMock(enabled = true) {
+  devMockEnabled = enabled;
+}
+function createStorages() {
+  return {
+    locale: useStorage("$zl_locale", ""),
+    theme: useStorage("$zl_theme", "light"),
+    token: useStorage("$zl_token", void 0)
+  };
+}
+function createInitialedData(storages) {
+  return {
+    initialed: true,
+    locale: storages.locale.value,
+    theme: storages.theme.value,
+    token: storages.token.value,
+    isI18nKeyVisible: false,
+    roles: [],
+    permissions: [],
+    user: void 0,
+    localeMessages: {},
+    elLocaleMessages: void 0,
+    config: void 0
+  };
+}
+function useDevMockGlobalData() {
+  const storages = createStorages();
+  const globalData = ref2(createInitialedData(storages));
+  function getConfig(key, defaultValue) {
+    return globalData.value.config?.[key] ?? defaultValue;
+  }
+  function isConfig(key, compareValue = "true") {
+    return globalData.value.config?.[key] === compareValue;
+  }
+  async function setAndWaitUntil({ set }) {
+    globalData.value = { ...globalData.value, ...set };
+    await nextTick();
+  }
+  const _toComputed = (prop) => {
+    return computed3({
+      get() {
+        return globalData.value[prop];
+      },
+      set(value) {
+        globalData.value = {
+          ...globalData.value,
+          [prop]: value
+        };
+        return true;
+      }
+    });
+  };
+  updateBodyAttribute("data-theme", storages.theme.value);
+  updateBodyAttribute("data-locale", storages.locale.value);
+  return Object.assign(globalData, {
+    initialed: readonly(_toComputed("initialed")),
+    locale: _toComputed("locale"),
+    theme: _toComputed("theme"),
+    token: _toComputed("token"),
+    isI18nKeyVisible: _toComputed("isI18nKeyVisible"),
+    roles: _toComputed("roles"),
+    permissions: _toComputed("permissions"),
+    user: _toComputed("user"),
+    localeMessages: _toComputed("localeMessages"),
+    elLocaleMessages: _toComputed("elLocaleMessages"),
+    config: _toComputed("config")
+  }, { getConfig, isConfig, setAndWaitUntil });
+}
+var useMicroGlobalData = createGlobalState2(() => {
+  if (devMockEnabled && !window.microApp) {
+    console.warn("[useMicroGlobalData] \u4F7F\u7528\u5F00\u53D1\u6001 mock \u6570\u636E\uFF08enableGlobalDataMock \u5DF2\u5F00\u542F\uFF09");
+    return useDevMockGlobalData();
+  }
+  const storages = createStorages();
+  const triggers = /* @__PURE__ */ new Set();
+  let _computedSetTrigger;
+  const globalData = customRef((track, trigger2) => {
+    _computedSetTrigger = trigger2;
+    return {
+      get() {
+        track();
+        return microApp.getGlobalData() || Object.fromEntries(Object.entries(storages).map(([key, storage]) => [key, toValue(storage)]));
+      },
+      set(value) {
+        microApp.setGlobalData(value);
+        return true;
+      }
+    };
+  });
+  function trigger() {
+    _computedSetTrigger();
+    nextTick(() => {
+      triggers.forEach((fn) => fn());
+    });
+  }
+  microApp.addGlobalDataListener(trigger);
+  if (!globalData.value.initialed) {
+    globalData.value = createInitialedData(storages);
+  }
+  updateBodyAttribute("data-theme", storages.theme.value);
+  updateBodyAttribute("data-locale", storages.locale.value);
+  const storagesKey = Object.keys(storages);
+  watch(() => storagesKey.map((key) => globalData.value[key]), (values) => {
+    values.forEach((value, index) => {
+      const key = storagesKey[index];
+      if (storages[key].value !== value) {
+        storages[key].value = value;
+        if (key === "theme") {
+          updateBodyAttribute("data-theme", value);
+        }
+        if (key === "locale") {
+          updateBodyAttribute("data-locale", value);
+        }
+      }
+    });
+  });
+  const _toComputed = (prop) => {
+    return computed3({
+      get() {
+        return globalData.value[prop];
+      },
+      set(value) {
+        globalData.value = { [prop]: value };
+        return true;
+      }
+    });
+  };
+  function setAndWaitUntil({ set, until }) {
+    if (!set && !until && !isPlainObject2(set) && !isFunction(until)) {
+      return Promise.resolve();
+    }
+    const { resolve, promise } = withResolvers();
+    globalData.value = set;
+    const triggerFn = () => {
+      if (until?.(globalData.value)) {
+        triggers.delete(triggerFn);
+        resolve();
+      }
+    };
+    triggers.add(triggerFn);
+    return promise;
+  }
+  function getConfig(key, defaultValue) {
+    return globalData.value.config?.[key] ?? defaultValue;
+  }
+  function isConfig(key, compareValue = "true") {
+    return globalData.value.config?.[key] === compareValue;
+  }
+  function resetUser() {
+    globalData.value = { user: void 0, roles: [], permissions: [], token: void 0 };
+    storages.token.value = void 0;
+  }
+  return Object.assign(globalData, {
+    initialed: readonly(_toComputed("initialed")),
+    locale: _toComputed("locale"),
+    theme: _toComputed("theme"),
+    token: _toComputed("token"),
+    isI18nKeyVisible: _toComputed("isI18nKeyVisible"),
+    roles: _toComputed("roles"),
+    permissions: _toComputed("permissions"),
+    user: _toComputed("user"),
+    localeMessages: _toComputed("localeMessages"),
+    elLocaleMessages: _toComputed("elLocaleMessages"),
+    config: _toComputed("config"),
+    setAndWaitUntil,
+    getConfig,
+    isConfig,
+    resetUser
+  });
+});
+function updateBodyAttribute(key, value) {
+  ;
+  [document.body, ...document.querySelectorAll("micro-app-body")].forEach((el) => {
+    el.setAttribute(key, String(value ?? ""));
+  });
+}
+
+// src/useLocale.ts
+var elLocaleMessagesStore = {};
+function useLocale(options = {}, loader) {
+  const { locale, localeMessages, elLocaleMessages, isI18nKeyVisible } = useMicroGlobalData();
+  function postTranslation(translated, key) {
+    if (isI18nKeyVisible.value)
+      return key;
+    return options.postTranslation ? options.postTranslation(translated, key) : translated;
+  }
+  const i18n = createI18n({
+    locale: locale.value,
+    ...options,
+    legacy: false,
+    postTranslation
+  });
+  if (options.messages) {
+    localeMessages.value = options.messages;
+  }
+  const loadedLocale = [];
+  watch2(locale, async (value) => {
+    if (!value)
+      return;
+    i18n.global.locale.value = value;
+    if (loader) {
+      if (loadedLocale.includes(value)) {
+        elLocaleMessages.value = elLocaleMessagesStore[value];
+        return;
+      }
+      const messages = await loader(value);
+      loadedLocale.push(value);
+      localeMessages.value = messages.localeMessages;
+      elLocaleMessages.value = messages.elLocaleMessages;
+      elLocaleMessagesStore[value] = messages.elLocaleMessages;
+    }
+  }, { immediate: true });
+  let storeLocale;
+  watch2(isI18nKeyVisible, (visible) => {
+    const currentLocale = toValue2(i18n.global.locale);
+    if (visible) {
+      storeLocale = [currentLocale, i18n.global.getLocaleMessage(currentLocale)];
+      i18n.global.setLocaleMessage(currentLocale, {});
+    } else if (storeLocale) {
+      i18n.global.setLocaleMessage(storeLocale[0], storeLocale[1]);
+      storeLocale = void 0;
+    }
+  });
+  watch2(localeMessages, (messages) => {
+    if (!messages || typeof messages !== "object")
+      return;
+    if (!("locale" in messages)) {
+      for (const [loc2, msg] of Object.entries(messages)) {
+        if (msg && typeof msg === "object")
+          i18n.global.setLocaleMessage(loc2, msg);
+      }
+      return;
+    }
+    const { locale: loc, ...rest } = messages;
+    if (loc)
+      i18n.global.setLocaleMessage(loc, rest);
+  }, { immediate: true });
+  return {
+    i18n,
+    isI18nKeyVisible,
+    locale
+  };
+}
+
+// src/useZlT.ts
+import { useI18n } from "vue-i18n";
+function useZlT() {
+  let t = (key, fallback) => fallback ?? key;
+  try {
+    const globalT = useI18n({ useScope: "global" }).t;
+    t = (key, fallback, params) => {
+      const msg = params ? globalT(key, params) : globalT(key);
+      return msg === key ? fallback ?? key : msg;
+    };
+  } catch {
+  }
+  return { t };
+}
+
+// src/useMicroAction.ts
+import microApp3 from "@micro-zoe/micro-app";
+import { createSharedComposable, tryOnScopeDispose as tryOnScopeDispose2 } from "@vueuse/core";
+import { watch as watch3 } from "vue";
+
+// src/useMicroApp.ts
+import microApp2 from "@micro-zoe/micro-app";
+import { createGlobalState as createGlobalState3 } from "@vueuse/core";
+import { ref as ref3 } from "vue";
+var useMicroApp = createGlobalState3(() => {
+  const apps = ref3([]);
+  function isMicroBase() {
+    return !!window.__MICRO_APP_BASE_APPLICATION__;
+  }
+  function isMicroChild() {
+    return !!window.__MICRO_APP_ENVIRONMENT__;
+  }
+  function updateApps() {
+    apps.value = microApp2.getActiveApps();
+  }
+  function startMicroApp(config = {}) {
+    microApp2.start({
+      ...config,
+      lifeCycles: {
+        mounted(data) {
+          updateApps();
+          config?.lifeCycles?.mounted?.(data);
+        },
+        // micro-app 的卸载生命周期名为 unmount，对外保持 unmounted 语义
+        unmount(data) {
+          updateApps();
+          config?.lifeCycles?.unmounted?.(data);
+        }
+      }
+    });
+    return microApp2;
+  }
+  return { apps, isMicroBase, isMicroChild, updateApps, startMicroApp };
+});
+
+// src/useMicroAction.ts
+var ACTION_PREFIX = "action__";
+var ACTION_ROOT_PREFIX = "action__root__";
+function _action(action, onlyRoot = false) {
+  return `${onlyRoot ? ACTION_ROOT_PREFIX : ACTION_PREFIX}${action}`;
+}
+function isEmitRoot(action) {
+  return action.startsWith(`${ACTION_ROOT_PREFIX}emit-`);
+}
+var useMicroListener = createSharedComposable(() => {
+  const { isMicroBase, isMicroChild, apps } = useMicroApp();
+  const listenerMap = /* @__PURE__ */ new Map();
+  const handler = (data) => {
+    Object.entries(data).forEach(([args, key]) => {
+      if (isEmitRoot(key) && isMicroBase() && isMicroChild()) {
+        window.microApp?.dispatch({ [JSON.stringify(args)]: key });
+        return;
+      }
+      const action = key.replace(ACTION_ROOT_PREFIX, "").replace(ACTION_PREFIX, "");
+      const callbackSet = listenerMap.get(action);
+      if (!callbackSet?.size) {
+        return;
+      }
+      delete data[args];
+      callbackSet.forEach((callback) => callback(...JSON.parse(args)));
+    });
+  };
+  const listeners = [];
+  if (isMicroChild()) {
+    const _microApp2 = window.microApp;
+    _microApp2?.addDataListener(handler);
+    listeners.push(() => {
+      _microApp2?.removeDataListener(handler);
+    });
+  }
+  if (isMicroBase()) {
+    listeners.push(() => {
+      apps.value.forEach((app) => {
+        microApp3.removeDataListener(app, handler);
+      });
+    });
+    watch3(apps, (newApps, oldApps) => {
+      oldApps.forEach((app) => {
+        microApp3.removeDataListener(app, handler);
+      });
+      newApps.forEach((app) => {
+        microApp3.addDataListener(app, handler);
+      });
+    }, { deep: true });
+  }
+  const _ensureGetCallbackSet = (action) => {
+    let callbackSet = listenerMap.get(action);
+    if (!callbackSet) {
+      callbackSet = /* @__PURE__ */ new Set();
+      listenerMap.set(action, callbackSet);
+    }
+    return callbackSet;
+  };
+  const on = (action, callback) => {
+    _ensureGetCallbackSet(action).add(callback);
+  };
+  const off = (action, callback) => {
+    const callbackSet = listenerMap.get(action);
+    if (callbackSet) {
+      callbackSet.delete(callback);
+    }
+  };
+  const once = (action, callback) => {
+    const callbackSet = _ensureGetCallbackSet(action);
+    const handler2 = (...args) => {
+      callback(...args);
+      callbackSet.delete(handler2);
+    };
+    callbackSet.add(handler2);
+  };
+  const dispose = () => {
+    listenerMap.clear();
+    listeners.forEach((fn) => fn());
+  };
+  tryOnScopeDispose2(dispose);
+  return { on, off, once };
+});
+function useMicroAction(action, appName) {
+  const { apps } = useMicroApp();
+  const _actionName = _action(action);
+  return (...args) => {
+    const _apps = !appName ? apps.value : apps.value.filter((app) => app === appName);
+    _apps.forEach((app) => {
+      microApp3.setData(app, { [JSON.stringify(args)]: _actionName });
+    });
+  };
+}
+function useMicroActionAsync(action, appName) {
+  const _actionName = _action(action);
+  const { isMicroBase, isMicroChild } = useMicroApp();
+  if (!isMicroBase()) {
+    return (...args) => {
+      return new Promise((resolve, reject) => {
+        window.microApp?.dispatch({ [JSON.stringify(args)]: _actionName }, (promises) => {
+          Promise.all(promises).then(resolve, reject);
+        });
+      });
+    };
+  }
+  if (isMicroChild()) {
+    return (...args) => {
+      return new Promise((resolve, reject) => {
+        microApp3.setData(appName, { [JSON.stringify(args)]: _actionName }, (promises) => {
+          Promise.all(promises).then(resolve, reject);
+        });
+      });
+    };
+  }
+  return (..._args) => Promise.resolve([]);
+}
+function useMicroResultListener(action, callback) {
+  const { isMicroBase } = useMicroApp();
+  const _actionName = _action(action);
+  const handler = async (data) => {
+    for (const [args, key] of Object.entries(data)) {
+      if (key === _actionName) {
+        delete data[args];
+        return await callback(...JSON.parse(args));
+      }
+    }
+  };
+  const micro = isMicroBase() ? microApp3 : window.microApp;
+  micro?.addDataListener(handler);
+}
+function dispatchMicroAction(action, appName, ...data) {
+  const _actionName = _action(action);
+  return new Promise((resolve) => {
+    microApp3.setData(appName, { [JSON.stringify(data)]: _actionName }, resolve);
+  });
+}
+
+// src/usePageTabs.ts
+import microApp4 from "@micro-zoe/micro-app";
+import { createGlobalState as createGlobalState4 } from "@vueuse/core";
+import { computed as computed4, getCurrentInstance, nextTick as nextTick2, reactive, readonly as readonly2, ref as ref4, shallowReactive, watch as watch4 } from "vue";
+function pushMicroRouter({ micro, url }) {
+  if (!micro || !url)
+    return;
+  const activeApps = microApp4.getActiveApps();
+  if (!activeApps.includes(micro))
+    return;
+  return microApp4.router.push({ name: micro, path: url });
+}
+var createPageTabsState = createGlobalState4(() => {
+  const { on } = useMicroListener();
+  const roots = reactive({});
+  const activeRootKey = ref4(null);
+  const activeRoot = computed4(() => activeRootKey.value ? roots[activeRootKey.value] : null);
+  const pageTabs = computed4(() => {
+    if (!activeRoot.value)
+      return [];
+    return activeRoot.value.tabs.reduce((acc, cur) => {
+      const getChildren = (item) => {
+        if (item.children) {
+          const children = item.children.map((i) => getChildren(i)).flat();
+          Object.assign(children[0], { title: item.title, icon: item.icon });
+          return children;
+        } else {
+          return [item];
+        }
+      };
+      if (cur.children) {
+        return [...acc, ...getChildren(cur)];
+      } else {
+        return [...acc, cur];
+      }
+    }, []);
+  });
+  const current = computed4(() => {
+    return pageTabs.value.find((item) => item.key === activeRoot.value?.activeTabKey);
+  });
+  const micros = shallowReactive({});
+  async function _removePageTabByKey(key, root = activeRoot.value) {
+    const index = root.tabs.findIndex((item) => item.key === key);
+    if (index === -1)
+      return false;
+    const tab = root.tabs[index];
+    try {
+      if (typeof tab.beforeRemove === "function") {
+        const shouldRemove = await tab.beforeRemove();
+        if (shouldRemove === false)
+          return false;
+      }
+      root.tabs.splice(index, 1);
+      const parentTab = root._parentMap[key];
+      delete root._parentMap[key];
+      if (root.activeTabKey === key) {
+        root.activeTabKey = root.tabs.at(index - 1)?.key ?? root.tabs[0]?.key ?? "";
+      }
+      return [tab, parentTab];
+    } catch {
+      return false;
+    }
+  }
+  on("dispatch-page-key-change", ({ key, root }) => {
+    const changedRoot = roots[root];
+    if (!changedRoot)
+      return;
+    changedRoot.activeTabKey = key;
+    activeRootKey.value = root;
+  });
+  on("dispatch-page-key-remove", ({ key, root, isRoot }) => {
+    if (isRoot) {
+      roots[root] = void 0;
+      if (activeRootKey.value === root) {
+        const rootKeys = Object.keys(roots);
+        activeRootKey.value = rootKeys.at(rootKeys.indexOf(root) - 1) ?? null;
+      }
+      return;
+    }
+    const changedRoot = roots[root];
+    if (!changedRoot)
+      return;
+    _removePageTabByKey(key, changedRoot);
+  });
+  watch4(current, (val) => {
+    if (!val?.micro)
+      return;
+    if (!val.isChildMicro)
+      return;
+    if (!micros[val.micro]) {
+      micros[val.micro] = val.url;
+    } else if (val.url) {
+      pushMicroRouter(val);
+    } else {
+      pushMicroRouter({ micro: val.micro, url: val.rootKey });
+    }
+  });
+  return {
+    roots,
+    activeRoot,
+    activeRootKey,
+    micros,
+    pageTabs,
+    current,
+    _removePageTabByKey
+  };
+});
+function usePageTabs() {
+  const { roots, activeRootKey, micros, _removePageTabByKey, ...state } = createPageTabsState();
+  const { isMicroBase } = useMicroApp();
+  const vm = getCurrentInstance();
+  function createPageTabsRoot(root) {
+    if (!roots[root.key]) {
+      const rootTab = { ...root, isRoot: true };
+      roots[root.key] = {
+        tabs: [rootTab],
+        activeTabKey: rootTab.key,
+        _parentMap: shallowReactive({})
+      };
+    }
+    activeRootKey.value = root.key;
+  }
+  function addPageTab(tab, options) {
+    const { update, childMicro = true } = { update: false, ...options };
+    const root = roots[activeRootKey.value];
+    const lastActiveTabKey = root.activeTabKey;
+    root._parentMap[tab.key] = vm;
+    root.activeTabKey = tab.key;
+    const index = root.tabs.findIndex((item) => item.key === tab.key);
+    if (index > -1 && !update) {
+      return false;
+    }
+    let currentTab = { ...tab, _parentTabKey: lastActiveTabKey };
+    if (isComponentTab(tab)) {
+      const { title, key, icon, beforeRemove, component, props, ..._props } = tab;
+      currentTab = { title, key, icon, beforeRemove, component, props: { ...props, ..._props }, _parentTabKey: lastActiveTabKey };
+    } else if (tab.micro && isMicroBase() && childMicro) {
+      currentTab.isChildMicro = true;
+      addMicro(currentTab);
+    }
+    if (index > -1) {
+      root.tabs[index] = currentTab;
+    } else {
+      root.tabs.push(currentTab);
+    }
+    return true;
+  }
+  async function removePageTab(tabOrKey = roots[activeRootKey.value].activeTabKey) {
+    if (!tabOrKey)
+      return;
+    if (typeof tabOrKey === "string") {
+      return _removePageTabByKey(tabOrKey);
+    }
+    if (tabOrKey.isChildRoot) {
+      await _removeChildRoot(tabOrKey);
+    } else if (tabOrKey.isChild) {
+      dispatchMicroAction("dispatch-page-key-remove", tabOrKey.micro, {
+        key: tabOrKey.key,
+        root: tabOrKey.rootKey
+      });
+    } else {
+      return _removePageTabByKey(tabOrKey.key);
+    }
+    return false;
+  }
+  function clearPageTab(rootKey = activeRootKey.value) {
+    const rootKeys = Object.keys(roots);
+    delete roots[rootKey];
+    if (rootKey === activeRootKey.value) {
+      const index = rootKeys.indexOf(rootKey);
+      rootKeys.splice(index, 1);
+      activeRootKey.value = rootKeys.at(index - 1) ?? null;
+    }
+  }
+  function setRootChild(tabs, activeChildTabKey, micro) {
+    if (!activeChildTabKey || micro.startsWith("flowable_"))
+      return;
+    const root = roots[activeRootKey.value];
+    const childRootTab = tabs[0];
+    const childRootTabKey = `${childRootTab.micro}__${childRootTab.key}`;
+    const currentTab = state.pageTabs.value.find((tab) => tab.key === root.activeTabKey);
+    root._parentTabMap ?? (root._parentTabMap = {});
+    if (!root._parentTabMap[childRootTabKey]) {
+      root._parentTabMap[childRootTabKey] = currentTab;
+    }
+    const parentTab = root._parentTabMap[childRootTabKey];
+    function childTabFormatter(tab) {
+      return { ...tab, isChild: true, isChildMicro: !!tab.micro, parentTab, childRootTabKey };
+    }
+    const oldTabs = parentTab.children;
+    if (!oldTabs?.length) {
+      parentTab.children = tabs.map(childTabFormatter);
+    } else {
+      const newTabs = parentTab.children = [];
+      if (tabs.length > oldTabs.length) {
+        newTabs.push(...oldTabs, ...tabs.slice(oldTabs.length).map(childTabFormatter));
+      } else if (tabs.length < oldTabs.length) {
+        const oldChildMap = oldTabs.reduce((acc, cur) => {
+          acc[cur.key] = cur;
+          return acc;
+        }, {});
+        newTabs.push(...tabs.map((tab) => {
+          return oldChildMap[tab.key] || childTabFormatter(tab);
+        }));
+      } else {
+        newTabs.push(...oldTabs);
+      }
+    }
+    root.activeTabKey = activeChildTabKey;
+  }
+  async function removeCurrentTab(callback) {
+    const root = state.activeRoot.value;
+    const removedTab = await _removePageTabByKey(root.activeTabKey);
+    if (!removedTab || typeof callback !== "function")
+      return false;
+    const [tab, parentTab] = removedTab;
+    if (state.pageTabs.value.find((item) => item.key === tab._parentTabKey)) {
+      root.activeTabKey = tab._parentTabKey;
+      await nextTick2();
+      await callback(parentTab?.exposed);
+    }
+    return true;
+  }
+  async function _removeChildRoot(tab) {
+    if (!tab.isChildRoot)
+      return;
+    const root = roots[activeRootKey.value];
+    const childRootKey = `${tab.micro}__${tab.key}`;
+    const parentTab = root._parentTabMap?.[childRootKey];
+    if (!parentTab)
+      return;
+    delete root._parentTabMap?.[childRootKey];
+    const realParentTab = parentTab.parentTab;
+    dispatchMicroAction("dispatch-page-key-remove", tab.micro, {
+      key: tab.key,
+      root: tab.rootKey,
+      isRoot: true
+    });
+    if (realParentTab) {
+      dispatchMicroAction("dispatch-page-key-remove", realParentTab.micro, {
+        key: parentTab.key,
+        root: parentTab.rootKey
+      });
+    } else {
+      _removePageTabByKey(parentTab.key);
+    }
+  }
+  async function setCurrentTab(tab) {
+    const root = roots[activeRootKey.value];
+    if (!tab || !root || root.activeTabKey === tab.key)
+      return;
+    if (tab.isChild) {
+      if (state.current.value?.micro !== tab.micro) {
+        root.activeTabKey = tab.key;
+        await nextTick2();
+      }
+      dispatchMicroAction("dispatch-page-key-change", tab.micro, {
+        key: tab.key,
+        root: tab.rootKey
+      });
+    } else {
+      root.activeTabKey = tab.key;
+    }
+  }
+  function addMicro({ micro, url }) {
+    if (!micro || !url || micros[micro])
+      return false;
+    micros[micro] = url;
+    return true;
+  }
+  return {
+    ...state,
+    roots,
+    micros: readonly2(micros),
+    activeRootKey: readonly2(activeRootKey),
+    addMicro,
+    setRootChild,
+    createPageTabsRoot,
+    addPageTab,
+    removePageTab,
+    removeCurrentTab,
+    clearPageTab,
+    setCurrentTab
+  };
+}
+function isComponentTab(tab) {
+  return !!tab.component;
+}
+
+// src/useRequest/plugins/definePlugin.ts
+function definePlugin(plugin) {
+  return plugin;
+}
+
+// src/useRequest/config.ts
+var GLOBAL_OPTIONS = {};
+function getGlobalOptions() {
+  return GLOBAL_OPTIONS;
+}
+function setGlobalOptions(options) {
+  Object.assign(GLOBAL_OPTIONS, options);
+}
+function clearGlobalOptions() {
+  Object.keys(GLOBAL_OPTIONS).forEach((key) => {
+    delete GLOBAL_OPTIONS[key];
+  });
+}
+var GLOBAL_OPTIONS_PROVIDER_KEY = /* @__PURE__ */ Symbol("GLOBAL_OPTIONS_PROVIDER_KEY");
+var DEFAULT_PAGINATION_OPTIONS = {
+  currentKey: "pageNum",
+  pageSizeKey: "pageSize",
+  totalKey: "total",
+  dataKey: "rows"
+};
+
+// src/useRequest/useDataRequest.ts
+import { computed as computed5 } from "vue";
+
+// src/useRequest/useRequestImpl.ts
+import { tryOnScopeDispose as tryOnScopeDispose3 } from "@vueuse/core";
+import { inject as inject2 } from "vue";
+
+// src/useRequest/createRequest.ts
+import { shallowCopy } from "@zl-ui-kit/utils";
+import { ref as ref5, shallowRef } from "vue";
+function createRequest(service, options = {}, initialState = {}) {
+  const { initialData } = options;
+  const loading = ref5(initialState.loading ?? false);
+  const data = shallowRef(initialData);
+  const error = ref5(void 0);
+  const params = ref5();
+  const plugins = ref5([]);
+  const status = ref5("");
+  const context = {};
+  const onPluginRunner = (event, ...args) => {
+    if (event === "onRequest") {
+      const services = plugins.value.map((plugin) => plugin.onRequest).filter(Boolean);
+      const composedService = () => {
+        let next = args[0];
+        for (const service2 of services) {
+          next = service2(next);
+        }
+        return next();
+      };
+      return { servicePromise: composedService() };
+    } else {
+      return Object.assign({}, ...plugins.value.map((plugin) => plugin[event]?.(...args)));
+    }
+  };
+  const state = { loading, data, error, params, status };
+  const setState = (newState) => {
+    Object.keys(newState).forEach((key) => {
+      if (key in state) {
+        ;
+        state[key].value = newState[key];
+      }
+    });
+  };
+  setState({ status: "pending" });
+  const count = ref5(0);
+  context.runAsync = async (...args) => {
+    setState({ status: "pending" });
+    const currentCount = ++count.value;
+    const { isBreak = false, isReturn = false, ...rest } = onPluginRunner("onBefore", args);
+    if (isBreak) {
+      setState({ status: "finished" });
+      return new Promise(() => {
+      });
+    }
+    setState({ loading: true, params: args, ...rest });
+    if (isReturn) {
+      setState({ status: "finished", loading: false });
+      return rest.data;
+    }
+    options.onBefore?.(args);
+    try {
+      const serviceWrapper = () => new Promise((r) => r(service(...params.value)));
+      let { servicePromise } = onPluginRunner("onRequest", serviceWrapper);
+      if (!servicePromise) {
+        servicePromise = serviceWrapper();
+      }
+      const res = await servicePromise;
+      if (currentCount !== count.value) {
+        return new Promise(() => {
+        });
+      }
+      setState({
+        loading: false,
+        data: res,
+        status: "finished",
+        error: void 0
+      });
+      onPluginRunner("onSuccess", res, args);
+      options.onSuccess?.(res, args);
+      onPluginRunner("onFinally", res, args);
+      options.onFinally?.(args);
+      return res;
+    } catch (error2) {
+      if (currentCount !== count.value) {
+        return new Promise(() => {
+        });
+      }
+      setState({ loading: false, error: error2, status: "finished" });
+      onPluginRunner("onError", error2, args);
+      options.onError?.(error2, args);
+      onPluginRunner("onFinally", error2, args);
+      options.onFinally?.(args);
+      throw error2;
+    }
+  };
+  context.run = (...args) => {
+    context.runAsync(...args).catch((error2) => {
+      if (!options.onError) {
+        console.error(error2);
+      }
+    });
+  };
+  context.cancel = () => {
+    count.value++;
+    setState({ loading: false });
+    onPluginRunner("onCancel");
+  };
+  context.refresh = () => {
+    context.run(...params.value || []);
+  };
+  context.refreshAsync = () => {
+    return context.runAsync(...params.value || []);
+  };
+  context.mutate = ((mutatorOrData) => {
+    const _data = typeof mutatorOrData === "function" ? mutatorOrData(data.value) : mutatorOrData;
+    const mutateData = shallowCopy(_data);
+    setState({ data: mutateData });
+    onPluginRunner("onMutate", mutateData);
+  });
+  return {
+    loading,
+    data,
+    error,
+    params,
+    plugins,
+    status,
+    context
+  };
+}
+
+// src/useRequest/plugins/useDownloadPlugin.ts
+import { fileSave } from "@zl-ui-kit/utils";
+import { toValue as toValue3 } from "vue";
+var useDownloadPlugin_default = definePlugin((_requestInstance, options = {}) => {
+  const { outputFile } = options;
+  if (!outputFile) {
+    return {};
+  }
+  return {
+    onSuccess(res) {
+      if (res instanceof Blob && res.type !== "application/json") {
+        const blob = new Blob([res]);
+        fileSave(blob, toValue3(outputFile));
+      }
+    }
+  };
+});
+
+// src/useRequest/plugins/useLoadingPlugin.ts
+import { promiseTimeout, useTimeoutFn } from "@vueuse/core";
+import { toValue as toValue4 } from "vue";
+var useLoadingPlugin_default = definePlugin((requestInstance, options = {}) => {
+  const { loadingDelay = 0, loadingKeep = 0 } = options;
+  const { start, stop } = useTimeoutFn(
+    () => {
+      if (requestInstance.status.value === "pending") {
+        requestInstance.loading.value = true;
+      }
+    },
+    loadingDelay,
+    { immediate: false }
+  );
+  return {
+    onBefore() {
+      start();
+      return {
+        loading: !toValue4(loadingDelay)
+      };
+    },
+    onRequest(service) {
+      if (!toValue4(loadingKeep))
+        return () => service();
+      return () => Promise.allSettled([
+        service(),
+        promiseTimeout(toValue4(loadingDelay) + toValue4(loadingKeep))
+      ]).then(([res]) => {
+        if (res.status === "fulfilled") {
+          return res.value;
+        } else {
+          return Promise.reject(res.reason);
+        }
+      });
+    },
+    onCancel() {
+      stop();
+    },
+    onFinally() {
+      stop();
+    }
+  };
+});
+
+// src/useRequest/plugins/useReadyPlugin.ts
+import { whenever } from "@vueuse/core";
+import { ref as ref6, toValue as toValue5 } from "vue";
+var useReadyPlugin_default = definePlugin((requestInstance, options = {}) => {
+  const { ready = ref6(true), defaultParams = [] } = options;
+  whenever(() => toValue5(ready), () => {
+    requestInstance.context.run(...defaultParams);
+  }, { flush: "sync" });
+  return {
+    onBefore() {
+      if (!toValue5(ready)) {
+        return { isBreak: true };
+      }
+      return void 0;
+    }
+  };
+});
+
+// src/useRequest/plugins/useRefreshDepsPlugin.ts
+import { watch as watch5 } from "vue";
+var useRefreshDepsPlugin_default = definePlugin((requestInstance, options = {}) => {
+  const { refreshDeps, refreshDepsAction, manual } = options;
+  if (!refreshDeps) {
+    return {};
+  }
+  watch5(refreshDeps, (..._args) => {
+    if (refreshDepsAction) {
+      refreshDepsAction();
+    } else if (!manual) {
+      requestInstance.context.refresh();
+    }
+  });
+  return {};
+});
+
+// src/useRequest/useRequestImpl.ts
+function useRequestImpl(service, options = {}, plugins = []) {
+  const injectOptions = inject2(GLOBAL_OPTIONS_PROVIDER_KEY, {});
+  const _options = {
+    ...getGlobalOptions(),
+    ...injectOptions,
+    ...options
+  };
+  const { manual = false, defaultParams = [] } = _options;
+  const requestInstance = createRequest(service, _options);
+  requestInstance.plugins.value = [...plugins, useLoadingPlugin_default, useReadyPlugin_default, useRefreshDepsPlugin_default, useDownloadPlugin_default].map((plugin) => plugin(requestInstance, _options));
+  if (!manual) {
+    const params = requestInstance.params.value || defaultParams;
+    requestInstance.context.run(...params);
+  }
+  tryOnScopeDispose3(requestInstance.context.cancel);
+  return {
+    __is_use_request: true,
+    loading: requestInstance.loading,
+    data: requestInstance.data,
+    error: requestInstance.error,
+    params: requestInstance.params,
+    status: requestInstance.status,
+    cancel: requestInstance.context.cancel,
+    mutate: requestInstance.context.mutate,
+    run: requestInstance.context.run,
+    runAsync: requestInstance.context.runAsync,
+    refresh: requestInstance.context.refresh,
+    refreshAsync: requestInstance.context.refreshAsync
+  };
+}
+
+// src/useRequest/useRequest.ts
+function useRequest(service, options, plugins = []) {
+  return useRequestImpl(service, options, plugins);
+}
+
+// src/useRequest/useDataRequest.ts
+function useDataRequest(service, options, plugins) {
+  const { dataKey = "data", initialData, ...restOptions } = options || {};
+  const request = useRequest(service, restOptions, plugins);
+  const _data = request.data;
+  const data = computed5(() => {
+    const rawData = _data.value || {};
+    return rawData[dataKey] ?? initialData;
+  });
+  return Object.assign(request, { data });
+}
+
+// src/useRequest/usePageableRequest.ts
+import { isArray } from "@zl-ui-kit/utils";
+import { computed as computed6, inject as inject3 } from "vue";
+function usePaginationRequest(service, options, plugins) {
+  const { pagination = {}, ...restOptions } = options || {};
+  const injectedGlobalOptions = inject3(GLOBAL_OPTIONS_PROVIDER_KEY, {});
+  const { currentKey, pageSizeKey, totalKey, dataKey } = Object.assign({}, DEFAULT_PAGINATION_OPTIONS, getGlobalOptions().pagination, injectedGlobalOptions.pagination, pagination);
+  const finalOptions = {
+    defaultParams: [{ [currentKey]: 1, [pageSizeKey]: 30 }],
+    ...restOptions
+  };
+  const { data: _data, params, run, ...rest } = useRequest(service, finalOptions, plugins);
+  const data = computed6(() => {
+    const rawData = _data.value || {};
+    return isArray(rawData) ? rawData : rawData[dataKey] || [];
+  });
+  const total = computed6(() => {
+    const rawData = _data.value || {};
+    return isArray(rawData) ? rawData.length : rawData[totalKey] || 0;
+  });
+  const current = computed6({
+    get() {
+      return params.value?.[0]?.[currentKey] ?? finalOptions.defaultParams[0]?.[currentKey];
+    },
+    set(val) {
+      changeCurrent(val);
+    }
+  });
+  const pageSize = computed6({
+    get() {
+      return params.value?.[0]?.[pageSizeKey] ?? finalOptions.defaultParams[0]?.[pageSizeKey];
+    },
+    set(val) {
+      changePageSize(val);
+    }
+  });
+  function _paging(paginationParams) {
+    const [oldParams, ...restParams] = params.value || [];
+    run(...[{ ...oldParams, ...paginationParams }, ...restParams]);
+  }
+  function changeCurrent(pageNum) {
+    _paging({ [currentKey]: pageNum });
+  }
+  function changePageSize(size) {
+    _paging({ [pageSizeKey]: size, [currentKey]: 1 });
+  }
+  function changePagination(page, size) {
+    _paging({ [currentKey]: page, [pageSizeKey]: size });
+  }
+  return {
+    data,
+    params,
+    total,
+    current,
+    pageSize,
+    run,
+    changeCurrent,
+    changePageSize,
+    changePagination,
+    ...rest
+  };
+}
+function usePageableRequest(service, options, plugins) {
+  const request = useRequest(service, options, plugins);
+  const _data = request.data;
+  const data = computed6(() => {
+    const rawData = _data.value || [];
+    if (isArray(rawData)) {
+      return rawData;
+    } else {
+      const [param] = request.params.value || [];
+      return { ...rawData, pageNum: param?.pageNum, pageSize: param?.pageSize };
+    }
+  });
+  return Object.assign(request, { data });
+}
+
+// src/useRequest/useRequestProvider.ts
+import { provide as provide2 } from "vue";
+function useRequestProvider(options) {
+  provide2(GLOBAL_OPTIONS_PROVIDER_KEY, options);
+}
+
+// src/useSash.ts
+import { useEventListener } from "@vueuse/core";
+import { toValue as toValue6, useTemplateRef } from "vue";
+function useSash(refName, { start, onMousedown, onMousemove, onMouseup, onDoubleClick } = {}) {
+  const sashElRef = useTemplateRef(refName);
+  function handleSashMousedown(e) {
+    e.preventDefault();
+    const startX = e.clientX;
+    const startY = e.clientY;
+    onMousedown?.(e);
+    const startSnapshot = toValue6(start);
+    const handleMousemove = (e2) => {
+      e2.preventDefault();
+      const dx = e2.clientX - startX;
+      const dy = e2.clientY - startY;
+      onMousemove?.({ dx, dy, start: startSnapshot }, e2);
+    };
+    const handleMouseup = (e2) => {
+      document.removeEventListener("mousemove", handleMousemove);
+      document.removeEventListener("mouseup", handleMouseup);
+      onMouseup?.(e2);
+    };
+    document.addEventListener("mousemove", handleMousemove);
+    document.addEventListener("mouseup", handleMouseup);
+  }
+  useEventListener(sashElRef, "mousedown", handleSashMousedown);
+  if (onDoubleClick) {
+    useEventListener(sashElRef, "dblclick", onDoubleClick);
+  }
+  return {
+    sashElRef
+  };
+}
+
+// src/useServiceType.ts
+function useServiceType(options = {}) {
+  const { platformKey = "zl.service.type", blockchainKey = "blockchain.service.type" } = options;
+  const { isConfig, getConfig } = useMicroGlobalData();
+  const isPlatform = isConfig(platformKey, "platform");
+  const isBlockchain = blockchainKey ? ["0", "1"].includes(getConfig(blockchainKey, "")) : false;
+  return { isPlatform, isBlockchain };
+}
+
+// src/useUKey/index.ts
+import { createSharedComposable as createSharedComposable2, useTimeoutFn as useTimeoutFn2 } from "@vueuse/core";
+import { ref as ref7 } from "vue";
+var useUKey = createSharedComposable2(() => {
+  const { getConfig } = useMicroGlobalData();
+  const port = getConfig("zl.feature.shufflePort", "8080");
+  const sn = ref7("");
+  const getSnResolver = {
+    resolve: (_value) => {
+    },
+    reject: (_reason) => {
+    }
+  };
+  const { start, stop } = useTimeoutFn2(_getSn, 200, { immediate: false });
+  async function _getSn() {
+    try {
+      sn.value = await request({ function: "sn" });
+      getSnResolver.resolve(sn.value);
+      start();
+    } catch {
+      start();
+      sn.value = "";
+    }
+  }
+  const getSn = () => {
+    return new Promise((resolve, reject) => {
+      getSnResolver.resolve = resolve;
+      getSnResolver.reject = reject;
+      _getSn();
+    });
+  };
+  const getUser = (pin) => request({ function: "user", sn: sn.value, pin });
+  const getDevice = async () => {
+    const data = await request({ function: "dn", sn: sn.value });
+    return {
+      ...data,
+      sn: sn.value
+    };
+  };
+  const isUserExists = async () => {
+    const data = await request({ function: "isempty", sn: sn.value });
+    return data === "false";
+  };
+  const getCSR = (data) => request({
+    function: "csr",
+    pin: "111111",
+    C: "CN",
+    ST: "Beijing",
+    L: "Beijing",
+    O: data.partyName,
+    OU: data.nodeLabel,
+    CN: data.userName
+  });
+  const writeCRT = (username, certbase64, newpin) => request({ function: "importcert", sn: sn.value, certbase64, username, newpin });
+  const sendSign = ({ pin, data }) => request({ function: "sm2sign", pin, sn: sn.value, data });
+  async function request(data) {
+    const res = await fetch(`http://127.0.0.1:${port}/function`, {
+      method: "post",
+      body: JSON.stringify(data),
+      headers: {
+        "content-type": "application/json"
+      }
+    });
+    const json = await res.json();
+    if (json.code !== "200") {
+      const error = new Error(json.msg);
+      error.code = json.code;
+      throw error;
+    }
+    return json?.data || json;
+  }
+  return {
+    sn,
+    getSn,
+    getUser,
+    getDevice,
+    isUserExists,
+    getCSR,
+    writeCRT,
+    sendSign,
+    stopHeartbeat: stop
+  };
+});
+export {
+  DEFAULT_PAGINATION_OPTIONS,
+  GLOBAL_OPTIONS_PROVIDER_KEY,
+  clearGlobalOptions,
+  createCacheComputed,
+  definePlugin as defineUseRequestPlugin,
+  dictInjectKey,
+  dispatchMicroAction,
+  enableGlobalDataMock,
+  getDictSource,
+  getGlobalOptions,
+  mergeMessages,
+  setDictSource,
+  setGlobalOptions,
+  useDataRequest,
+  useDict,
+  useDictProvider,
+  useDictStore,
+  useGlobalMessage,
+  useLocale,
+  useMicroAction,
+  useMicroActionAsync,
+  useMicroApp,
+  useMicroGlobalData,
+  useMicroListener,
+  useMicroResultListener,
+  usePageTabs,
+  usePageableRequest,
+  usePaginationRequest,
+  useRequest,
+  useRequestProvider,
+  useSash,
+  useServiceType,
+  useUKey,
+  useZlT
+};
+//# sourceMappingURL=index.js.map