@gct-paas/design 0.1.4-dev.7 → 0.1.4-dev.9

package/es/hooks/design-view/widget/useWidget.d.ts

@@ -0,0 +1,107 @@
+import { PropType } from 'vue';
+import { LowCodeModal, LowCodeWidget } from '@gct-paas/schema';
+/**不需要遮罩 */
+export declare const NotMask: string[];
+interface Props {
+    /**组件 */
+    widget?: LowCodeWidget.BasicSchema | LowCodeModal.Modal;
+    /**父组件 */
+    parentWidget?: LowCodeWidget.BasicSchema | LowCodeModal.Modal;
+    /**父组件List */
+    parentList?: (LowCodeWidget.BasicSchema | LowCodeModal.Modal)[];
+    /**在父组件列表的下标 */
+    indexOfParentList?: number;
+}
+export declare function useWidget(props: Props): {
+    isWidgetSelected: import('vue').ComputedRef<boolean>;
+    value: import('vue').ComputedRef<string>;
+    label: import('vue').ComputedRef<any>;
+    hideMask: import('vue').ComputedRef<boolean>;
+    showMask: import('vue').ComputedRef<boolean>;
+};
+/**widget-wrapper通用的props */
+export declare const widgetWrapperProps: {
+    /**组件 */
+    widget: {
+        type: PropType<LowCodeWidget.BasicSchema>;
+    };
+    /**父组件 */
+    parentWidget: {
+        type: PropType<LowCodeWidget.BasicSchema> | undefined;
+    };
+    /**父组件List */
+    parentList: {
+        type: {
+            (arrayLength: number): import('@gct-paas/schema').IBasicSchema[];
+            (...items: import('@gct-paas/schema').IBasicSchema[]): import('@gct-paas/schema').IBasicSchema[];
+            new (arrayLength: number): import('@gct-paas/schema').IBasicSchema[];
+            new (...items: import('@gct-paas/schema').IBasicSchema[]): import('@gct-paas/schema').IBasicSchema[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+    };
+    /**在父组件列表的下标 */
+    indexOfParentList: {
+        type: NumberConstructor;
+    };
+    /** 是否隐藏操作按钮 */
+    hideAction: {
+        type: BooleanConstructor;
+    };
+    /** 显示哪些操作按钮 */
+    actionTypes: {
+        type: {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+    };
+    action: {
+        type: PropType<(id: string) => boolean>;
+    };
+    /** 是否为新版设计器 */
+    isNewDesigner: {
+        type: BooleanConstructor;
+    };
+    deleteCallback: {
+        type: FunctionConstructor;
+    };
+    /**是否开启悬浮虚线 */
+    showHoverLine: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare const widgetProps: {
+    /**组件 */
+    widget: {
+        type: PropType<LowCodeWidget.BasicSchema>;
+        require: boolean;
+        default: () => {};
+    };
+    rowReadonly: BooleanConstructor;
+    formData: {
+        type: ObjectConstructor;
+    };
+    isNewDesigner: BooleanConstructor;
+};
+export {};

package/es/hooks/design-view/widget/useWidget.mjs

@@ -0,0 +1,124 @@
+import { computed } from 'vue';
+import { useSelectedWidget } from './useSelectedWidget.mjs';
+import { FormComponents } from '@gct-paas/core';
+import { has } from 'lodash-es';
+
+const NotMask = [
+  FormComponents.Search,
+  FormComponents.DataTable,
+  FormComponents.DataVTable,
+  FormComponents.SubDataTable,
+  FormComponents.Form,
+  FormComponents.FormProcess,
+  FormComponents.RdoForm,
+  FormComponents.MedProRdoForm,
+  FormComponents.LayoutContainer,
+  FormComponents.Grid,
+  FormComponents.GridCol,
+  FormComponents.LeftRightColumns,
+  FormComponents.ButtonContainer,
+  FormComponents.SubTable,
+  FormComponents.Tabs,
+  FormComponents.TabPane,
+  FormComponents.TableSelect,
+  FormComponents.Collapse,
+  FormComponents.CardList,
+  FormComponents.TreeTable,
+  FormComponents.RefDataTable,
+  FormComponents.DynamicTable,
+  FormComponents.Text,
+  FormComponents.UploadFile,
+  FormComponents.Descriptions,
+  FormComponents.BottomButtonContainer,
+  FormComponents.ButtonProcessContainer,
+  FormComponents.ApprovalHistory
+];
+function useWidget(props) {
+  const { selectedWidget } = useSelectedWidget();
+  const widget = props.widget;
+  const isWidgetSelected = computed(() => {
+    if (selectedWidget.value.id === widget.id) {
+      if (!has(selectedWidget.value, "materialType") || !has(widget, "materialType")) {
+        return true;
+      } else {
+        return selectedWidget.value.materialType === widget.materialType;
+      }
+    }
+    return false;
+  });
+  const label = computed(() => {
+    return widget.props.label;
+  });
+  const value = computed(() => {
+    return "";
+  });
+  const widgetdesigner = {};
+  const hideMaskValue = computed(() => {
+    if (typeof widgetdesigner[widget.type]?.hideMask === "function") {
+      return widgetdesigner[widget.type].hideMask(widget);
+    }
+    return widgetdesigner[widget.type]?.hideMask;
+  });
+  const hideMask = computed(() => {
+    return NotMask.indexOf(widget.type) === -1 && !hideMaskValue.value;
+  });
+  const showMask = computed(() => {
+    return NotMask.indexOf(widget.type) === -1 && !hideMaskValue.value;
+  });
+  return { isWidgetSelected, value, label, hideMask, showMask };
+}
+const widgetWrapperProps = {
+  /**组件 */
+  widget: {
+    type: Object
+  },
+  /**父组件 */
+  parentWidget: {
+    type: Object
+  },
+  /**父组件List */
+  parentList: {
+    type: Array
+  },
+  /**在父组件列表的下标 */
+  indexOfParentList: {
+    type: Number
+  },
+  /** 是否隐藏操作按钮 */
+  hideAction: {
+    type: Boolean
+  },
+  /** 显示哪些操作按钮 */
+  actionTypes: {
+    type: Array
+  },
+  action: {
+    // 返回 true 中断自身操作
+    type: Object
+  },
+  /** 是否为新版设计器 */
+  isNewDesigner: {
+    type: Boolean
+  },
+  deleteCallback: { type: Function },
+  /**是否开启悬浮虚线 */
+  showHoverLine: {
+    type: Boolean,
+    default: false
+  }
+};
+const widgetProps = {
+  /**组件 */
+  widget: {
+    type: Object,
+    require: true,
+    default: () => ({})
+  },
+  rowReadonly: Boolean,
+  formData: {
+    type: Object
+  },
+  isNewDesigner: Boolean
+};
+
+export { NotMask, useWidget, widgetProps, widgetWrapperProps };

package/es/hooks/design-view/widget/useWidgetQuery.d.ts

@@ -0,0 +1,13 @@
+import { ComTypeMap } from '@gct-paas/schema';
+import { ComputedRef } from 'vue';
+export declare function useWidgetQuery(): {
+    allWidget: ComputedRef<import('@gct-paas/schema').IBasicSchema[]>;
+    allFormWidget: ComputedRef<import('@gct-paas/schema').IBasicSchema[]>;
+    excludeSubTableFormWidget: ComputedRef<import('@gct-paas/schema').IBasicSchema[]>;
+    allSubTableWidget: ComputedRef<import('@gct-paas/schema').IBasicSchema[]>;
+    allListWidget: ComputedRef<import('@gct-paas/schema').IBasicSchema[]>;
+    allTableWidget: ComputedRef<import('@gct-paas/schema').IBasicSchema[]>;
+    allDeptWidget: ComputedRef<import('@gct-paas/schema').IBasicSchema[]>;
+    allRefSelectWidget: ComputedRef<import('@gct-paas/schema').IBasicSchema[]>;
+    getWidgetByScope: <K extends keyof ComTypeMap>(type: K) => ComTypeMap[K][];
+};

package/es/hooks/design-view/widget/useWidgetQuery.mjs

@@ -0,0 +1,88 @@
+import { TreeHelper, FormComponents, FIELD_TYPE } from '@gct-paas/core';
+import { getCompPos } from '@gct-paas/schema';
+import { computed } from 'vue';
+import { useScope } from '../layout/useScope.mjs';
+
+function useWidgetQuery() {
+  const allWidget = computed(
+    () => {
+      const { scopeData } = useScope();
+      return TreeHelper.findNodeAll(scopeData.value, (widget) => {
+        return !!widget;
+      });
+    }
+  );
+  const allFormWidget = computed(() => {
+    const { scopeData } = useScope();
+    return TreeHelper.findNodeAll(scopeData.value, (widget) => {
+      return [
+        FormComponents.Form,
+        FormComponents.RdoForm,
+        FormComponents.MedProRdoForm,
+        FormComponents.FormProcess
+      ].includes(widget.type);
+    });
+  });
+  const excludeSubTableFormWidget = computed(() => {
+    const { scopeData } = useScope();
+    return TreeHelper.findNodeAll(scopeData.value, (widget) => {
+      if ([
+        FormComponents.RdoForm,
+        FormComponents.MedProRdoForm,
+        FormComponents.FormProcess
+      ].includes(widget.type)) {
+        return true;
+      }
+      return widget.type === FormComponents.Form && !getCompPos(widget, FIELD_TYPE.MASTERSLAVE, FormComponents.Form);
+    });
+  });
+  const allSubTableWidget = computed(() => {
+    const { scopeData } = useScope();
+    return TreeHelper.findNodeAll(scopeData.value, (widget) => {
+      return widget.type === FormComponents.SubTable;
+    });
+  });
+  const allListWidget = computed(() => {
+    const { scopeData } = useScope();
+    return TreeHelper.findNodeAll(scopeData.value, (widget) => {
+      return widget.type === FormComponents.DataList || widget.type === FormComponents.RdoDataList;
+    });
+  });
+  const allTableWidget = computed(() => {
+    const { scopeData } = useScope();
+    return TreeHelper.findNodeAll(scopeData.value, (widget) => {
+      return widget.type === FormComponents.DataTable || widget.type === FormComponents.DataVTable || widget.type === FormComponents.RefDataTable;
+    });
+  });
+  const allDeptWidget = computed(() => {
+    const { scopeData } = useScope();
+    return TreeHelper.findNodeAll(scopeData.value, (widget) => {
+      return widget.type === FormComponents.Department;
+    });
+  });
+  const allRefSelectWidget = computed(() => {
+    const { scopeData } = useScope();
+    return TreeHelper.findNodeAll(scopeData.value, (widget) => {
+      return widget.type === FormComponents.Select && widget.props.fieldType === FIELD_TYPE.REF;
+    });
+  });
+  function getWidgetByScope(type) {
+    const { scopeData } = useScope();
+    return TreeHelper.findNodeAll(scopeData.value, (widget) => {
+      return widget.type === type;
+    });
+  }
+  return {
+    allWidget,
+    allFormWidget,
+    excludeSubTableFormWidget,
+    allSubTableWidget,
+    allListWidget,
+    allTableWidget,
+    allDeptWidget,
+    allRefSelectWidget,
+    getWidgetByScope
+  };
+}
+
+export { useWidgetQuery };

package/es/hooks/design-view/widget/useWidgetRegistry.d.ts

@@ -0,0 +1,11 @@
+import { LowCodeWidget } from '@gct-paas/schema';
+import { Component } from 'vue';
+export declare function useWidgetRegistry(): {
+    getAsyncWidget: (widget: string | LowCodeWidget.BasicSchema) => Component | undefined;
+    getWidgetHooks: (type: string) => unknown;
+    widgetEntry: import('vue').ComputedRef<string>;
+    pluginConfigs: import('vue').ComputedRef<IObject[]>;
+    getWhiteList: (type: string) => (string | RegExp)[];
+    getBlackList: (type: string) => (string | RegExp)[];
+    setPluginConfigs: (configs: IObject[]) => void;
+};

package/es/hooks/design-view/widget/useWidgetRegistry.mjs

@@ -0,0 +1,59 @@
+import { Platform } from '@gct-paas/core';
+import { computed } from 'vue';
+import { widgetInfo, pluginConfigs, platform, designRegister } from '../design-state.mjs';
+
+function useWidgetRegistry() {
+  const allComHooks = computed(() => {
+    return widgetInfo.value.hooks;
+  });
+  const allWhiteList = computed(() => {
+    return widgetInfo.value.whiteList;
+  });
+  const allBlackList = computed(() => {
+    return widgetInfo.value.blackList;
+  });
+  const pluginConfigsComputed = computed(() => {
+    return pluginConfigs.value;
+  });
+  function setPluginConfigs(configs) {
+    pluginConfigs.value = configs;
+  }
+  const getAsyncWidget = (widget) => {
+    if (typeof widget === "string") {
+      return designRegister.value.getComponentByType(widget);
+    }
+    if (widget._plugin) {
+      return designRegister.value.getComponentByPluginTag(widget._plugin.key);
+    }
+    return designRegister.value.getComponentByType(widget.type);
+  };
+  const getWidgetHooks = (type) => {
+    return allComHooks.value[type] ?? {};
+  };
+  const getWhiteList = (type) => {
+    return allWhiteList.value[type] ?? [];
+  };
+  const getBlackList = (type) => {
+    return allBlackList.value[type] ?? [];
+  };
+  const widgetEntry = computed(() => {
+    if (platform.value === Platform.MOBILE) {
+      return "widget-mobile-entry";
+    } else if (platform.value === Platform.PAD) {
+      return "widget-pad-entry";
+    } else {
+      return "widget-entry";
+    }
+  });
+  return {
+    getAsyncWidget,
+    getWidgetHooks,
+    widgetEntry,
+    pluginConfigs: pluginConfigsComputed,
+    getWhiteList,
+    getBlackList,
+    setPluginConfigs
+  };
+}
+
+export { useWidgetRegistry };

package/es/hooks/designer.hooks.d.ts

@@ -0,0 +1,15 @@
+import { SyncSeriesHook } from 'qx-util';
+/**
+ * 设计界面钩子
+ *
+ * @export
+ * @class DesignViewHooks
+ */
+export declare class DesignViewHooks {
+    /**
+     * 触发执行设计容器扩容展示
+     *
+     * @static
+     */
+    expansion: SyncSeriesHook<[], string[]>;
+}

package/es/hooks/designer.hooks.mjs

@@ -0,0 +1,12 @@
+import { SyncSeriesHook } from 'qx-util';
+
+class DesignViewHooks {
+  /**
+   * 触发执行设计容器扩容展示
+   *
+   * @static
+   */
+  expansion = new SyncSeriesHook();
+}
+
+export { DesignViewHooks };

package/es/hooks/develop/useCacheHistory.d.ts

@@ -0,0 +1,67 @@
+import { Ref } from 'vue';
+interface IHistoryValue<T = any> {
+    /** 过去 */
+    pasts: T[];
+    /** 将来 */
+    futures: T[];
+    /** 最大存储个数 */
+    max: number;
+}
+interface InitProps {
+    /** 唯一id */
+    historyId: string;
+    /** 最大数量 */
+    max?: number;
+}
+export declare function useCacheHistory(): {
+    historyUtils: {
+        new (): {};
+        /**
+         * 获取唯一id
+         */
+        getUniqueHistoryId(): string;
+        /** 初始化 */
+        init(props: InitProps): void;
+        /** 是否存在所属唯一id的历史记录信息 */
+        isHistoryInfoExist(historyId: string): boolean;
+        /** 根据唯一id获取历史记录 */
+        getHistoryInfo(historyId: string): IHistoryValue;
+        /** 根据唯一id获取删除指定历史记录 */
+        deleteHistoryInfo(historyId: string): void;
+        /** 清空全部历史记录Map */
+        clearCacheHistory(): void;
+        /** 清空全部历史记录Map */
+        resetHistoryById(id: string): void;
+        getCacheHistoryMap(): Map<string, {
+            pasts: any[];
+            futures: any[];
+            max: number;
+        }> & Omit<Map<string, IHistoryValue<any>>, keyof Map<any, any>>;
+        /** 新增一条历史记录到指定唯一id中 */
+        addHistory({ historyId, replaceHistory, past, }: {
+            /** 唯一id */
+            historyId: string;
+            /**替换最新的一条历史记录 */
+            replaceHistory?: boolean;
+            /** 新的一条历史记录 */
+            past: string;
+        }): void;
+        /** 撤销一条历史记录 */
+        undoHistory(historyId: string): any;
+        /** 重做一条历史记录 */
+        restoreHistory(historyId: string): any;
+    };
+};
+interface IPropsInner {
+    /** 唯一id */
+    historyIdRef: Ref<string>;
+    /** 撤销和重做回调方法 */
+    callback?(content: unknown): void;
+}
+export declare function useCacheHistoryInner(props: IPropsInner): {
+    undoDisabled: Ref<boolean, boolean>;
+    restoreDisabled: Ref<boolean, boolean>;
+    onUndo: () => any;
+    onRestore: () => any;
+};
+export {};

package/es/hooks/develop/useCacheHistory.mjs

@@ -0,0 +1,157 @@
+import { ref, unref, watch } from 'vue';
+import { useUUid } from '../web/useUUid.mjs';
+
+const cacheHistoryMap = ref(/* @__PURE__ */ new Map());
+function useCacheHistory() {
+  const historyKeys = [...unref(cacheHistoryMap).keys()];
+  const { getUuidGenerate } = useUUid(ref([]), ref(""), {
+    needPrefix: true,
+    isString: false,
+    prefix: "h_"
+  });
+  const uuidGenerate = getUuidGenerate(historyKeys);
+  class historyUtils {
+    /**
+     * 获取唯一id
+     */
+    static getUniqueHistoryId() {
+      return uuidGenerate.next();
+    }
+    /** 初始化 */
+    static init(props) {
+      if (this.isHistoryInfoExist(props.historyId)) {
+        console.warn("唯一key重复了");
+        return;
+      }
+      cacheHistoryMap.value.set(props.historyId, {
+        pasts: [],
+        futures: [],
+        max: props.max ?? 30
+      });
+    }
+    /** 是否存在所属唯一id的历史记录信息 */
+    static isHistoryInfoExist(historyId) {
+      return unref(cacheHistoryMap).has(historyId);
+    }
+    /** 根据唯一id获取历史记录 */
+    static getHistoryInfo(historyId) {
+      return unref(cacheHistoryMap).get(historyId);
+    }
+    /** 根据唯一id获取删除指定历史记录 */
+    static deleteHistoryInfo(historyId) {
+      cacheHistoryMap.value.delete(historyId);
+    }
+    /** 清空全部历史记录Map */
+    static clearCacheHistory() {
+      cacheHistoryMap.value.clear();
+    }
+    /** 清空全部历史记录Map */
+    static resetHistoryById(id) {
+      const history = historyUtils.getHistoryInfo(id);
+      if (!history) return;
+      history.futures.length = 0;
+      history.pasts.length = 0;
+    }
+    static getCacheHistoryMap() {
+      return cacheHistoryMap.value;
+    }
+    /** 新增一条历史记录到指定唯一id中 */
+    static addHistory({
+      historyId,
+      replaceHistory,
+      past
+    }) {
+      if (this.isHistoryInfoExist(historyId)) {
+        const historyInfo = this.getHistoryInfo(historyId);
+        if (!replaceHistory && historyInfo?.pasts.length > historyInfo?.max + 1) {
+          historyInfo?.pasts.shift();
+        }
+        if (replaceHistory) {
+          historyInfo?.pasts.splice(-1, 1, past);
+        } else {
+          historyInfo?.pasts.push(past);
+        }
+        historyInfo.futures.length = 0;
+      } else {
+        console.warn("不存在，插入历史记录失败");
+      }
+    }
+    /** 撤销一条历史记录 */
+    static undoHistory(historyId) {
+      if (this.isHistoryInfoExist(historyId)) {
+        const historyInfo = this.getHistoryInfo(historyId);
+        const len = historyInfo.pasts.length;
+        if (len > 1) {
+          historyInfo.futures.push(historyInfo.pasts.pop());
+          return historyInfo.pasts[historyInfo.pasts.length - 1];
+        }
+      } else {
+        console.warn("不存在，撤销历史记录失败");
+      }
+      return null;
+    }
+    /** 重做一条历史记录 */
+    static restoreHistory(historyId) {
+      if (this.isHistoryInfoExist(historyId)) {
+        const historyInfo = this.getHistoryInfo(historyId);
+        const len = historyInfo.futures.length;
+        if (len > 0) {
+          const current = historyInfo.futures.pop();
+          historyInfo.pasts.push(current);
+          return current;
+        }
+      } else {
+        console.warn("不存在，重做历史记录失败");
+      }
+      return null;
+    }
+  }
+  return { historyUtils };
+}
+function useCacheHistoryInner(props) {
+  const { historyUtils } = useCacheHistory();
+  const undoDisabled = ref(true);
+  const restoreDisabled = ref(true);
+  watch(
+    () => historyUtils.getHistoryInfo(unref(props.historyIdRef))?.pasts,
+    (value) => {
+      undoDisabled.value = (unref(value) ?? []).length <= 1;
+    },
+    { deep: true, immediate: true }
+  );
+  watch(
+    () => historyUtils.getHistoryInfo(unref(props.historyIdRef))?.futures,
+    (value) => {
+      restoreDisabled.value = !(unref(value) ?? []).length;
+    },
+    { deep: true, immediate: true }
+  );
+  function onUndo() {
+    if (unref(undoDisabled)) {
+      return;
+    }
+    const content = historyUtils.undoHistory(unref(props.historyIdRef));
+    if (props.callback && typeof props.callback === "function" && content !== null) {
+      props.callback(content);
+    }
+    return content;
+  }
+  function onRestore() {
+    if (unref(restoreDisabled)) {
+      return;
+    }
+    const content = historyUtils.restoreHistory(unref(props.historyIdRef));
+    if (props.callback && typeof props.callback === "function" && content !== null) {
+      props.callback(content);
+    }
+    return content;
+  }
+  return {
+    undoDisabled,
+    restoreDisabled,
+    onUndo,
+    onRestore
+  };
+}
+
+export { useCacheHistory, useCacheHistoryInner };

package/es/hooks/develop/useKeyParser.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+/**
+ * key值转换器
+ * @param prefix 前缀
+ * @param suffix 后缀 仅空字符串代表不需要后缀
+ * @returns
+ */
+export declare function useKeyParser(prefix: Ref<string | undefined> | string, suffix?: Ref<string | undefined> | string): {
+    keyPrefix: Ref<string, string>;
+    keySuffix: Ref<string, string>;
+    keyReset: () => void;
+    keyPad: (key: string) => string | undefined;
+    keyClip: (formKey: string) => string;
+    keyPrePad: (key: string) => string | undefined;
+    keyPreClip: (formKey: string) => string;
+};