cnhis-design-vue 3.1.14-beta.2 → 3.1.14-beta.5

package/es/packages/select-person/src/utils/index.d.ts

@@ -0,0 +1,12 @@
+export declare const filterTree: ({ value, data, prop, filter, filterXor, children, visible, filterChildren, callback }: {
+    value?: string | undefined;
+    data?: any[] | undefined;
+    prop?: string | undefined;
+    filter?: boolean | undefined;
+    filterXor?: boolean | undefined;
+    children?: string | undefined;
+    visible?: string | undefined;
+    filterChildren?: boolean | undefined;
+    callback?: Function | undefined;
+}) => any[] | undefined;
+export declare const deepTraversalFirst: (node: any, nodeList?: any[]) => any[];

package/es/packages/select-person/src/utils/index.js

@@ -0,0 +1,84 @@
+const filterTree = ({
+  value = "",
+  data = [],
+  prop = "title",
+  filter = false,
+  filterXor = false,
+  children = "children",
+  visible = "visible",
+  filterChildren = true,
+  callback
+}) => {
+  visible = visible || "visible";
+  children = children || "children";
+  prop = prop || "text";
+  const filterNodeMethod = function(value2, data2) {
+    if (!value2) {
+      return true;
+    }
+    let flag = (data2[prop] || "").indexOf(value2) !== -1;
+    return filterXor ? !flag : flag;
+  };
+  const setVisible = (tree, isVisible) => {
+    if (!(tree == null ? void 0 : tree.length))
+      return;
+    tree.forEach((item) => {
+      var _a;
+      item[visible] = isVisible;
+      ((_a = item[children]) == null ? void 0 : _a.length) && setVisible(item[children], isVisible);
+    });
+  };
+  const traverse = function(node) {
+    const childNodes = node[children] || [];
+    childNodes.forEach((child) => {
+      child[visible] = !node.root && !filterChildren && node[visible] || filterNodeMethod.call(child, value, child);
+      traverse(child);
+      callback && callback(child);
+    });
+    if (childNodes.length) {
+      let allHidden = true;
+      allHidden = !childNodes.some((child) => child[visible]);
+      if (!node[visible]) {
+        node[visible] = allHidden === false;
+      } else {
+        setVisible(childNodes, true);
+      }
+    }
+  };
+  let totalData = {
+    root: true
+  };
+  totalData[children] = data;
+  traverse(totalData);
+  if (filter) {
+    let copyData = data.slice();
+    let filterHandle = (filterData) => {
+      return filterData.filter((item, index) => {
+        var _a;
+        if (item[visible]) {
+          if (item[children]) {
+            item[children] = filterHandle(item[children]);
+          }
+          if (!((_a = item[children]) == null ? void 0 : _a.length)) {
+            item[children] = void 0;
+          }
+          return true;
+        }
+        return false;
+      });
+    };
+    return filterHandle(copyData);
+  }
+};
+const deepTraversalFirst = (node, nodeList = []) => {
+  if (node !== null) {
+    nodeList.push(node);
+    if (node.children && node.children.length > 0) {
+      let children = node.children;
+      deepTraversalFirst(children[0], nodeList);
+    }
+  }
+  return nodeList;
+};
+
+export { deepTraversalFirst, filterTree };

package/es/packages/select-person/style/index.css

@@ -0,0 +1,193 @@
+.people-tree {
+  display: flex;
+}
+.people-tree .people-tree-item {
+  width: 50%;
+  padding: 22px 12px 0;
+  max-height: 376px;
+  height: 376px;
+  overflow-y: auto;
+}
+.people-tree .people-tree-item.people-tree-left {
+  display: flex;
+  flex-direction: column;
+}
+.people-tree .people-tree-item:first-child {
+  border-right: 1px solid #e8e8e8;
+}
+.people-tree .people-tree-item .tag-item {
+  box-sizing: border-box;
+  color: #212121;
+  font-size: 14px;
+  list-style: none;
+  display: inline-flex;
+  align-items: center;
+  height: 24px;
+  line-height: 24px;
+  margin-right: 8px;
+  margin-bottom: 4px;
+  padding: 0 6px;
+  white-space: nowrap;
+  background: rgba(213, 213, 213, 0.2);
+  border: 1px solid rgba(0, 0, 0, 0.14);
+  border-radius: 4px;
+  transition: all 0.3s cubic-bezier(0.215, 0.61, 0.355, 1);
+}
+.people-tree .people-tree-item .tag-item.isRoot {
+  background: rgba(85, 133, 245, 0.08);
+  border: 1px solid rgba(85, 133, 245, 0.5);
+  color: #5585f5;
+}
+.people-tree .people-tree-item .tag-item.isRoot .tag-close {
+  color: #5585f5;
+}
+.people-tree .people-tree-item .tag-item.isRoot .tag-close:hover {
+  color: rgba(85, 133, 245, 0.6);
+}
+.people-tree .people-tree-item .tag-item .tag-close {
+  display: inline-block;
+  font-size: 14px;
+  margin-left: 3px;
+  color: #969696;
+  font-weight: 700;
+  cursor: pointer;
+  transition: all 0.3s;
+}
+.people-tree .people-tree-item .tag-item .tag-close:hover {
+  color: rgba(85, 133, 245, 0.6);
+}
+.people-tree .people-tree-item .tag-item .tag-close:active {
+  color: #fff;
+}
+.people-tree .people-tree-item .no-data-tips {
+  height: 200px;
+  width: 100%;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  font-size: 16px;
+  font-weight: 700;
+}
+.people-tree .people-tree-item .c-title {
+  font-size: 14px;
+  font-family: PingFangSC-Regular, PingFang SC;
+  font-weight: 400;
+  color: #212121;
+}
+.people-tree .people-tree-item .c-sub-title {
+  font-size: 12px;
+  font-family: PingFangSC-Regular, PingFang SC;
+  color: #4e4e4e;
+}
+.people-tree .people-tree-item .p-title {
+  font-size: 14px;
+  font-family: PingFangSC-Medium, PingFang SC;
+  font-weight: 500;
+  color: #212121;
+}
+.people-tree .people-tree-item.tags-box {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-start;
+  align-items: flex-start;
+  align-content: flex-start;
+}
+.df {
+  display: flex;
+}
+.search-input-icon {
+  color: rgba(0, 0, 0, 0.4);
+  margin-bottom: -2px;
+}
+.main-tree-container {
+  overflow-y: auto;
+}
+.df {
+  display: flex;
+}
+.search-tree-wrap .search-tree-item {
+  display: flex;
+  align-items: center;
+}
+.search-tree-wrap .name-wrap {
+  width: 48px;
+  height: 48px;
+  background: #7d88b5;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 50%;
+  margin-right: 13px;
+}
+.search-tree-wrap .name-wrap .name {
+  font-size: 16px;
+  color: #ffffff;
+  margin-bottom: 0;
+  line-height: 16px;
+}
+.search-tree-wrap .info-wrap {
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  display: flex;
+  flex-direction: column;
+}
+.search-tree-wrap .info-wrap-top {
+  align-items: flex-end;
+  margin: 0;
+  margin-bottom: 1px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.search-tree-wrap .info-wrap-title {
+  margin-bottom: 0;
+  font-size: 16px;
+  font-family: PingFangSC-Regular, PingFang SC;
+  font-weight: 400;
+  color: #4e4e4e;
+  line-height: 16px;
+}
+.search-tree-wrap .info-wrap-title .c-title {
+  font-size: 14px;
+  font-family: PingFangSC-Regular, PingFang SC;
+  font-weight: 400;
+  color: #212121;
+}
+.search-tree-wrap .info-wrap-title .c-sub-title {
+  font-size: 12px;
+  font-family: PingFangSC-Regular, PingFang SC;
+  color: #4e4e4e;
+}
+.search-tree-wrap .info-wrap-desc {
+  margin-left: 10px;
+  margin-bottom: 0;
+  font-size: 12px;
+  line-height: 17px;
+  color: #aeaeae;
+}
+.search-tree-wrap .info-wrap-position {
+  margin-bottom: 0;
+  font-size: 12px;
+  color: #7d88b5;
+  line-height: 17px;
+}
+.load-more-btn-wrap {
+  display: flex;
+  justify-content: center;
+  height: 35px;
+  line-height: 35px;
+  cursor: pointer;
+  padding-top: 10px;
+  box-sizing: border-box;
+}
+.load-more-btn-wrap .search-input-icon {
+  font-size: 16px;
+  color: rgba(0, 0, 0, 0.4);
+  margin-right: 14px;
+}
+.load-more-btn-wrap .load-more-btn {
+  font-size: 12px;
+  color: #747c8e;
+  line-height: 12px;
+}

package/es/packages/shortcut-provider/index.d.ts

@@ -0,0 +1,17 @@
+import { SFCWithInstall } from '../../../es/src/types';
+export * from './src/hooks';
+export * from './src/types';
+declare const ShortcutProvider: SFCWithInstall<import("vue").DefineComponent<{
+    cacheKey: StringConstructor;
+}, {
+    shortcutWrapperRef: import("vue").Ref<HTMLElement | undefined>;
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        cacheKey: StringConstructor;
+    }>> & {
+        [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+    }>>;
+    manager: import("./src/hooks").ShortcutManager;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    cacheKey: StringConstructor;
+}>>, {}>>;
+export default ShortcutProvider;

package/es/packages/shortcut-provider/index.js

@@ -0,0 +1,13 @@
+import { COMPONENT_NAMESPACE } from '../../src/global/variable';
+import { safeComponentRegister } from '../../src/utils';
+import './src/ShortcutProvider.js';
+import script from './src/ShortcutProvider.vue_vue_type_script_setup_true_lang.js';
+export { ShortcutManager, useShortcuts } from './src/hooks/useShortcuts.js';
+export { useShortcutSignature } from './src/hooks/useShortcutSignature.js';
+
+const ShortcutProvider = script;
+ShortcutProvider.install = function(app) {
+  safeComponentRegister(app, ShortcutProvider, COMPONENT_NAMESPACE + "ShortcutProvider");
+};
+
+export { ShortcutProvider as default };

package/es/packages/shortcut-provider/src/ShortcutProvider.js

@@ -0,0 +1,4 @@
+import script from './ShortcutProvider.vue_vue_type_script_setup_true_lang.js';
+export { default } from './ShortcutProvider.vue_vue_type_script_setup_true_lang.js';
+
+script.__file = "packages/shortcut-provider/src/ShortcutProvider.vue";

package/es/packages/shortcut-provider/src/ShortcutProvider.vue.d.ts

@@ -0,0 +1,15 @@
+import { ShortcutManager } from '../../../../es/packages/shortcut-provider';
+declare const _default: import("vue").DefineComponent<{
+    cacheKey: StringConstructor;
+}, {
+    shortcutWrapperRef: import("vue").Ref<HTMLElement | undefined>;
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        cacheKey: StringConstructor;
+    }>> & {
+        [x: `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+    }>>;
+    manager: ShortcutManager;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    cacheKey: StringConstructor;
+}>>, {}>;
+export default _default;

package/es/packages/shortcut-provider/src/ShortcutProvider.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,32 @@
+import { defineComponent, ref, provide, onBeforeUnmount, openBlock, createElementBlock, renderSlot } from 'vue';
+import { InjectionShortcutManager } from '../../../packages/shortcut-provider/src/constants';
+import { ShortcutManager } from '../../../packages/shortcut-provider';
+
+var script = /* @__PURE__ */ defineComponent({
+  __name: "ShortcutProvider",
+  props: {
+    cacheKey: String
+  },
+  setup(__props) {
+    const props = __props;
+    const shortcutWrapperRef = ref();
+    const manager = new ShortcutManager(shortcutWrapperRef, props.cacheKey).start();
+    provide(InjectionShortcutManager, manager);
+    onBeforeUnmount(() => {
+      manager.destroy();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("section", {
+        ref_key: "shortcutWrapperRef",
+        ref: shortcutWrapperRef,
+        "is-shortcut-capture": "",
+        class: "shortcut-provider",
+        tabindex: -9999
+      }, [
+        renderSlot(_ctx.$slots, "default")
+      ], 512);
+    };
+  }
+});
+
+export { script as default };

package/es/packages/shortcut-provider/src/constants/index.d.ts

@@ -0,0 +1,7 @@
+import { InjectionKey } from 'vue';
+import { ShortcutManager } from '../../../../../es/packages/shortcut-provider/src/hooks';
+export declare enum ShortcutStatus {
+    INACTIVE = 0,
+    ACTIVE = 1
+}
+export declare const InjectionShortcutManager: InjectionKey<ShortcutManager>;

package/es/packages/shortcut-provider/src/constants/index.js

@@ -0,0 +1,8 @@
+var ShortcutStatus = /* @__PURE__ */ ((ShortcutStatus2) => {
+  ShortcutStatus2[ShortcutStatus2["INACTIVE"] = 0] = "INACTIVE";
+  ShortcutStatus2[ShortcutStatus2["ACTIVE"] = 1] = "ACTIVE";
+  return ShortcutStatus2;
+})(ShortcutStatus || {});
+const InjectionShortcutManager = Symbol("InjectionShortcutManager");
+
+export { InjectionShortcutManager, ShortcutStatus };

package/es/packages/shortcut-provider/src/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useShortcuts';
+export * from './useShortcutSignature';

package/es/packages/shortcut-provider/src/hooks/index.js

@@ -0,0 +1,2 @@
+export { ShortcutManager, useShortcuts } from './useShortcuts.js';
+export { useShortcutSignature } from './useShortcutSignature.js';

package/es/packages/shortcut-provider/src/hooks/useShortcutSignature.d.ts

@@ -0,0 +1,4 @@
+export declare function useShortcutSignature(): {
+    signatureRef: import("vue").Ref<() => string>;
+    shortcut: import("vue").ComputedRef<string>;
+};

package/es/packages/shortcut-provider/src/hooks/useShortcutSignature.js

@@ -0,0 +1,12 @@
+import { ref, computed } from 'vue';
+import { transformKey2DisplaySignature } from '../../../../packages/shortcut-provider/src/utils';
+
+function useShortcutSignature() {
+  const signatureRef = ref(() => "");
+  const shortcut = computed(() => {
+    return transformKey2DisplaySignature(signatureRef.value());
+  });
+  return { signatureRef, shortcut };
+}
+
+export { useShortcutSignature };

package/es/packages/shortcut-provider/src/hooks/useShortcuts.d.ts

@@ -0,0 +1,30 @@
+import { ShortcutItem, ShortcutOption, ShortcutSignatureInfo } from '../../../../../es/packages/shortcut-provider/src/types';
+import { MaybeRef } from '@vueuse/core';
+export declare class ShortcutManager {
+    private readonly shortcutCallbackMap;
+    private readonly shortcutCache;
+    private readonly environmentEle;
+    private handle?;
+    static log(message: string, dryRun?: boolean): string;
+    constructor(environmentEle?: MaybeRef<HTMLElement | undefined>, cacheKey?: string);
+    get traverse(): unknown[];
+    query(key: string): any;
+    updateState(key: string, state?: boolean): void;
+    update(key: string, info: KeyboardEvent | Partial<ShortcutSignatureInfo>): void;
+    register(shortcutItem: ShortcutItem): {
+        stop: () => void;
+        signature: () => string;
+    };
+    start(): this;
+    destroy(): void;
+}
+export declare function useShortcuts(glob?: boolean): {
+    register: (shortcut: ShortcutOption) => {
+        stop: () => void;
+        signature: () => string;
+    };
+    traverse: () => unknown[];
+    query: (key: string) => any;
+    update: (key: string, info: KeyboardEvent | Partial<ShortcutSignatureInfo>) => void;
+    updateState: (key: string, state?: boolean) => void;
+};

package/es/packages/shortcut-provider/src/hooks/useShortcuts.js

@@ -0,0 +1,157 @@
+import { ShortcutStatus, InjectionShortcutManager } from '../../../../packages/shortcut-provider/src/constants';
+import { getKeySignature, getDisplaySignature, isKeyboardEvent, findAncestor, isShortcutProvider } from '../../../../packages/shortcut-provider/src/utils';
+import { reactive, unref, getCurrentInstance, inject, onBeforeUnmount } from 'vue';
+import { useStorage, useEventListener, useDebounceFn } from '@vueuse/core';
+import { pick, omit, isFunction, isString } from 'lodash-es';
+
+class ShortcutManager {
+  constructor(environmentEle, cacheKey = "__shortcut__glob") {
+    this.shortcutCallbackMap = reactive(/* @__PURE__ */ new Map());
+    this.environmentEle = environmentEle || window;
+    this.shortcutCache = useStorage(cacheKey, {}, localStorage, {
+      listenToStorageChanges: true,
+      deep: true
+    });
+  }
+  static log(message, dryRun = false) {
+    const _message = `[ShortcutManager] ${message}`;
+    !dryRun && console.warn(_message);
+    return _message;
+  }
+  get traverse() {
+    return [...Object.values(this.shortcutCache.value)].sort((a, b) => (a.order || 0) - (b.order || 0));
+  }
+  query(key) {
+    return this.shortcutCache.value[key];
+  }
+  updateState(key, state) {
+    this.query(key) && (this.query(key).disabled = !!state);
+  }
+  update(key, info) {
+    var _a;
+    const oldKeySignature = (_a = this.query(key)) == null ? void 0 : _a.currentKeySignature;
+    if (oldKeySignature === getKeySignature(info))
+      return;
+    if (Object.values(this.shortcutCache.value).some((v) => v.currentKeySignature === getKeySignature(info))) {
+      throw `\u91CD\u590D\u7684\u5FEB\u6377\u952E=> ${getDisplaySignature(info)}`;
+    }
+    const item = this.query(key);
+    if (!item)
+      return;
+    item.currentKeySignature = getKeySignature(info);
+    this.shortcutCallbackMap.set(getKeySignature(info), this.shortcutCallbackMap.get(oldKeySignature));
+    this.shortcutCallbackMap.delete(oldKeySignature);
+  }
+  register(shortcutItem) {
+    const item = this.query(shortcutItem.key);
+    if (item) {
+      item.status = ShortcutStatus.ACTIVE;
+      this.shortcutCallbackMap.set(item.currentKeySignature, shortcutItem.callback);
+      Object.assign(item, pick(shortcutItem, ["debounce", "debounceOption", "label", "defaultShortcut", "order", "key"]));
+      return createHandler(item);
+    }
+    this.shortcutCache.value[shortcutItem.key] = omit(shortcutItem, ["callback"]);
+    this.shortcutCallbackMap.set(shortcutItem.currentKeySignature, shortcutItem.callback);
+    return createHandler(this.shortcutCache.value[shortcutItem.key]);
+    function createHandler(shortcut) {
+      return {
+        stop: () => {
+          shortcut.status = ShortcutStatus.INACTIVE;
+        },
+        signature: () => shortcut.currentKeySignature
+      };
+    }
+  }
+  start() {
+    if (this.handle) {
+      ShortcutManager.log(`\u8BF7\u52FF\u91CD\u590D\u542F\u52A8=>${this}`);
+      return this;
+    }
+    this.handle = async (event) => {
+      if (!isKeyboardEvent(event))
+        return;
+      const providerWrapper = findAncestor(event.target, isShortcutProvider);
+      if (providerWrapper && providerWrapper !== unref(this.environmentEle)) {
+        return;
+      }
+      const keySignature = getKeySignature(event);
+      const callback = this.shortcutCallbackMap.get(keySignature);
+      if (!callback)
+        return;
+      const shortcutItem = Object.values(this.shortcutCache.value).find((item) => item.currentKeySignature === keySignature);
+      if (!shortcutItem || shortcutItem.status !== ShortcutStatus.ACTIVE || shortcutItem.disabled)
+        return;
+      callback();
+    };
+    useEventListener(this.environmentEle, "keyup", this.handle, { capture: true });
+    return this;
+  }
+  destroy() {
+    var _a;
+    this.handle && ((_a = unref(this.environmentEle)) == null ? void 0 : _a.removeEventListener("keyup", this.handle, { capture: true }));
+    this.handle = void 0;
+    this.shortcutCallbackMap.clear();
+  }
+}
+const globManager = new ShortcutManager().start();
+function useShortcuts(glob = false) {
+  function useManager() {
+    if (getCurrentInstance() && !glob) {
+      return inject(InjectionShortcutManager, globManager);
+    } else {
+      ShortcutManager.log("\u975Esetup\u8BED\u5883\u4E0B\u7684shortcut\u5C06\u5F71\u54CD\u5168\u5C40");
+      return globManager;
+    }
+  }
+  const manager = useManager();
+  function createShortcutItem(shortcut) {
+    return {
+      ...shortcut,
+      currentKeySignature: getKeySignature(shortcut.defaultShortcut),
+      key: keyFor(shortcut),
+      status: ShortcutStatus.ACTIVE,
+      disabled: false,
+      callback: callbackFor(shortcut)
+    };
+    function callbackFor(shortcut2) {
+      var _a, _b;
+      if (!isFunction(shortcut2.callback)) {
+        throw new Error(ShortcutManager.log(`\u975E\u6CD5\u7684callback\u7C7B\u578B=>${shortcut2.callback}`, true));
+      }
+      if (!shortcut2.debounce)
+        return shortcut2.callback;
+      return useDebounceFn(shortcut2.callback, (_b = (_a = shortcut2.debounceOption) == null ? void 0 : _a.duration) != null ? _b : 300);
+    }
+    function keyFor(shortcut2) {
+      const key = shortcut2.key || shortcut2.label;
+      if (!isString(key)) {
+        throw new Error(ShortcutManager.log(`\u975E\u6CD5\u7684key\u7C7B\u578B=>${key}`, true));
+      }
+      return key;
+    }
+  }
+  function register(shortcut) {
+    const { stop, signature } = manager.register(createShortcutItem(shortcut));
+    if (getCurrentInstance()) {
+      onBeforeUnmount(stop);
+    } else {
+      ShortcutManager.log("\u5728\u975Esetup\u8BED\u5883\u4E0B\u4F7F\u7528register\u51FD\u6570,\u7EC4\u4EF6\u9500\u6BC1\u65F6\u9700\u8981\u624B\u52A8\u8C03\u7528stop\u51FD\u6570\u4F7F\u5FEB\u6377\u952E\u5931\u6D3B");
+    }
+    return { stop, signature };
+  }
+  function traverse() {
+    return glob ? globManager.traverse : manager.traverse;
+  }
+  function query(key) {
+    return manager.query(key);
+  }
+  function update(key, info) {
+    manager.update(key, info);
+  }
+  function updateState(key, state) {
+    manager.updateState(key, state);
+  }
+  return { register, traverse, query, update, updateState };
+}
+
+export { ShortcutManager, useShortcuts };

package/es/packages/shortcut-provider/src/types/index.d.ts

@@ -0,0 +1,30 @@
+import { ArrayAble } from '../../../../../es/src/types';
+import { VNode } from 'vue';
+import { ShortcutStatus } from '../../../../../es/packages/shortcut-provider/src/constants';
+declare type Render = () => ArrayAble<VNode>;
+export interface ShortcutSignatureInfo {
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    key: string;
+}
+export interface ShortcutOption {
+    label: string | Render;
+    key?: string;
+    defaultShortcut: ShortcutSignatureInfo;
+    order?: number;
+    debounce?: boolean;
+    debounceOption?: {
+        duration?: number;
+    };
+    beforeTrigger?(): void | Promise<unknown>;
+    callback(): void;
+    afterTrigger?(): void | Promise<unknown>;
+}
+export interface ShortcutItem extends ShortcutOption {
+    status: ShortcutStatus;
+    currentKeySignature: string;
+    key: string;
+    disabled: boolean;
+}
+export {};

package/es/packages/shortcut-provider/src/types/index.js

@@ -0,0 +1 @@
+

package/es/packages/shortcut-provider/src/utils/index.d.ts

@@ -0,0 +1,7 @@
+import { ShortcutSignatureInfo } from '../../../../../es/packages/shortcut-provider/src/types';
+export declare function isKeyboardEvent(event: any): event is KeyboardEvent;
+export declare function getKeySignature(info: KeyboardEvent | Partial<ShortcutSignatureInfo>): string;
+export declare function getDisplaySignature(info: KeyboardEvent | Partial<ShortcutSignatureInfo>): string;
+export declare function transformKey2DisplaySignature(keySignature: string): string;
+export declare function isShortcutProvider(ele: HTMLElement): boolean;
+export declare function findAncestor(ele: HTMLElement | null, finder: (ele: HTMLElement) => boolean): HTMLElement | null;