@byteluck-fe/model-driven-engine 2.3.1-beta.25 → 2.3.1-beta.26

package/dist/types/common/ActionManager.d.ts

@@ -0,0 +1,14 @@
+export declare class ActionManager {
+    private actionMap;
+    private buildinActions;
+    /**
+     * 执行action的时候，作为第二个参数传递给方法，可以通过外部挂载
+     */
+    actionUtils: {};
+    /**
+     * 用于存储es module解析出来的源码，CustomVueControlPlugin
+     */
+    sources: {};
+    execAction(name: string, context: any, ...args: any[]): Promise<any>;
+    addAction(name: string, func: Function): void;
+}

package/dist/types/common/DataManager.d.ts

@@ -0,0 +1,10 @@
+import { EventPayload } from './Engine';
+export declare class DataManager {
+    private _dataStore;
+    private executer?;
+    constructor(callbackExecuter: (payload: EventPayload) => Promise<any>);
+    add(key: string, data: any): void;
+    get(key: string): any;
+    remove(key: string): void;
+    getRemoteData(payload: EventPayload): Promise<any>;
+}

package/dist/types/common/Engine.d.ts

@@ -0,0 +1,180 @@
+import { ControlRuntimeInstance, ControlsInstance, ControlsKeys, DataBind, DeepPartial, LayoutControls, ObjectDataBind, RuntimeControl, RuntimeListControl, Schema } from '@byteluck-fe/model-driven-core';
+import { Callback, Watcher } from '@byteluck-fe/model-driven-shared';
+import { Plugin } from './Plugin';
+import { Runtime, RuntimeProps } from './Runtime';
+import { DataBindMappingFieldItem, dataBindMappingType, DataBindMappingTypeItem, StatesType, StateType } from './Store';
+import { ActionManager } from './ActionManager';
+import { DataManager } from './DataManager';
+export type getDataControlIdMappingType = {
+    [controlId: string]: {
+        dataBind: any;
+        dataView: string;
+        children: getDataControlIdMappingType;
+    };
+};
+type dataSetType = {
+    [dataCode: string]: Record<string, unknown> | Record<string, unknown>[];
+};
+type FieldSetType = {
+    [fieldCode: string]: unknown;
+};
+interface EventPayload {
+    instance?: RuntimeControl;
+    value?: unknown;
+    rowIndex?: number;
+    options?: {
+        [key: string]: any;
+    };
+}
+interface SchemaEventPayload {
+    instance: RuntimeControl;
+    value: unknown;
+    props: string;
+    rowIndex?: number;
+}
+type EngineProps<T extends keyof LayoutControls = keyof LayoutControls> = {
+    schema: RuntimeProps['schema'];
+    beforeCreateInstance?: RuntimeProps['beforeCreateInstance'];
+    plugins?: Plugin[];
+    language?: string;
+    autoMount?: boolean;
+    debug?: boolean;
+    externalParams?: Record<string, unknown>;
+};
+type EventKeys = 'click' | 'click-finish' | 'wps-open' | 'wps-save' | 'wps-rename' | 'change' | 'schema-change' | 'search' | 'checked' | 'input' | 'focus' | 'blur' | 'list-change' | 'list-splice' | 'list-delete' | 'list-before-insert' | 'list-search' | 'list-mounted' | 'list-actions' | 'engine-mounted' | 'engine-submit' | 'engine-submit-params' | 'engine-submitted' | string;
+declare class Engine extends Watcher<EventKeys> {
+    private store;
+    rawStore: Record<string, any>;
+    parent?: Engine;
+    runtime: Runtime;
+    isMounted: boolean;
+    id: string;
+    readonly externalParams?: Record<string, any>;
+    private __plugins;
+    private __pluginsApplied;
+    private readonly $options;
+    private actionManager;
+    private dataManager?;
+    private _jobTasks;
+    constructor(props: EngineProps);
+    private debugLog;
+    use(plugin: Plugin): this;
+    registerControl(...arg: Parameters<Runtime['register']>): this;
+    static register(...arg: Parameters<(typeof Runtime)['register']>): typeof import("@byteluck-fe/model-driven-core").RegisterControls;
+    static judgeControlIsRegistered(control: Parameters<(typeof Runtime)['register']>[0]): boolean;
+    mount(): void;
+    destroy(): void;
+    private _handlerProxyState;
+    private _proxyStateBeforeSetCallback;
+    private _proxyStateCallback;
+    private _handlerArrayUpdate;
+    private _handlerObjectUpdate;
+    private applyPlugins;
+    listControlCreateRow<RowType extends ControlsKeys>(instance: RuntimeListControl, rowType: RowType): NonNullable<InstanceType<import("@byteluck-fe/model-driven-core").ControlsConstructor<RowType, "Runtime">>> | undefined;
+    listControlAddRow(instance: RuntimeListControl, rowType?: ControlsKeys): void;
+    emit(eventKey: EventKeys, payload: EventPayload): Promise<unknown[]>;
+    on(key: EventKeys, callback: Callback): void;
+    createControl(...args: Parameters<Runtime['createControl']>): never[];
+    createInstance<T extends ControlsKeys>(type: T, initSchema?: DeepPartial<Schema<T>>): ControlsInstance<T, 'Runtime'> | undefined;
+    createControlInstance: <T extends never>(type: T, initSchema?: DeepPartial<Schema<T, InstanceType<import("@byteluck-fe/model-driven-core").Controls[T]["Property"]>>> | undefined) => InstanceType<import("@byteluck-fe/model-driven-core").ControlsConstructor<T, "Runtime">> | undefined;
+    schemaEvent(eventKey: 'schema-change', payload: SchemaEventPayload): void;
+    updateInstanceProps(instance: SchemaEventPayload['instance'] | string, props: string, value: unknown, rowIndex?: number): void;
+    getAllRules(controlId?: string): {
+        rules: import("async-validator").Rules | undefined;
+        antdRules: import("async-validator").Rules | undefined;
+    };
+    getRules(controlId?: string): import("async-validator").Rules | undefined;
+    getAntdRules(controlId?: string): import("async-validator").Rules | undefined;
+    getState(controlId?: string, rowIndex?: number): unknown;
+    getEmptyState(controlId?: string): any;
+    /**
+     * 设置payload的options，提供在不是使用标准api修改state的时候可以传递options，会在本次任务执行完成之后清空
+     * @param options 需要携带的options
+     * */
+    setPayloadOptions(options: object | null): void;
+    setState(controlId: string, value: unknown, rowIndex?: number, options?: any): void;
+    /**
+     * 向Store设置一组值，明细表必须全量赋值，并触发事件（触发事件是根据组件在页面中的顺序逐个触发）
+     * @param states
+     */
+    setStates(states: StatesType | StateType, rowIndex?: number, options?: any): void;
+    /**
+     * 通过dataCode和fieldCode来获取控件的值
+     * @param dataCode 模型编码 - 如果是主表的话就是主表的模型编码，明细子表的话就是子表的模型编码
+     * @param fieldCode 字段编码 - 控件绑定的数据项的编码
+     * @param rowIndex 行下标 - 如果是明细子表中的控件需要提供
+     * */
+    getField(dataCode: string, fieldCode?: string, rowIndex?: number): unknown;
+    getData(dataCode: string): ObjectDataBind | ObjectDataBind[] | undefined;
+    /**
+     * 通过dataCode和fieldCode来设置控件的值
+     * @param dataCode 模型编码 - 如果是主表的话就是主表的模型编码，明细子表的话就是子表的模型编码
+     * @param fieldCode 字段编码 - 控件绑定的数据项的编码
+     * @param value 修改的值
+     * @param rowIndex 行下标 - 如果是明细子表中的控件需要提供
+     * @param options 触发事件携带的参数
+     * */
+    setField(dataCode: string, fieldCode: string, value: unknown, rowIndex?: number, options?: EventPayload['options']): void;
+    /**
+     * 通过dataCode和 state来给一组控件赋值，并触发事件携带options
+     * @param dataCode 需要赋值的目标模型
+     * @param state 赋值对象，以fieldCode为key组成的对象
+     * @param rowIndex 行下标，给明细子表赋值时指定赋值某行
+     * @param options 触发事件携带的参数
+     * */
+    setFields(dataCode: string, state: FieldSetType, rowIndex?: number, options?: EventPayload['options']): void;
+    /**
+     * 通过dataCode来将state转化为标准的state结构
+     * @param dataCode 需要转换的目标模型code
+     * @param state 值对象，以fieldCode为key组成的对象
+     * */
+    buildFields(dataCode: string, state: FieldSetType): StateType | undefined;
+    /**
+     * 向Store设置一组值，并触发事件携带options
+     * @param dataSet
+     * @options 传递给关联事件中 EventPayload中的options，一般在plugin中监听使用
+     */
+    setData(dataSet: dataSetType, options?: any): void;
+    /**
+     * 获取控件的dataBind
+     * @param controlId
+     * */
+    getDataBind(controlId: string): DataBind | ObjectDataBind | undefined;
+    /**
+     * 获取组件实例，传入rowIndex代表获取明细表内的控件实例，rowIndex传入-1代表获取表头内的实例
+     * @param controlId
+     * @param rowIndex
+     */
+    getInstance(controlId: string, rowIndex?: number): ControlRuntimeInstance<ControlsKeys> | undefined;
+    /**
+     * 获取组件实例，明细表中的组件将会得到数组, 第二个参数为(false/不传入)则获取到的是明细表内不包含表头内实例的所有控件实例，传入true则获取到包含表头内实例的所有控件实例,表头内实例永远在下标0的位置
+     * @param controlId
+     * @param header 明细表内是否获取表头的控件
+     */
+    getInstances(controlId?: string, header?: boolean): ControlRuntimeInstance<ControlsKeys>[];
+    setInstance(instance: SchemaEventPayload['instance'] | string, props: string, value: unknown, rowIndex?: number): void;
+    getControlIdMapping(): import("./Store").controlIdMappingType;
+    getDataBindMapping(): dataBindMappingType;
+    getDataBindMapping(dataCode: string): DataBindMappingTypeItem | undefined;
+    getDataBindMapping(dataCode: string, fieldCode: string): DataBindMappingFieldItem | undefined;
+    getAction(): ActionManager;
+    initDataManager(callbackExecuter: (payload: EventPayload) => Promise<any>): void;
+    getDataManager(): DataManager | undefined;
+    /**
+     * 判断控件的类型，返回当前控件的正确类型
+     * */
+    assertInstance<T extends ControlsKeys>(instance: ControlRuntimeInstance<ControlsKeys> | RuntimeControl, types: T | T[]): instance is ControlRuntimeInstance<T>;
+    /**
+     * 获取控件在明细子表中的行下标，
+     * 如果控件在表头内，则返回-1
+     * 如果控件在表内，则返回行下标
+     * 如果控件不在明细表内，则返回undefined
+     * */
+    getInstanceRowIndex(instance: ControlRuntimeInstance<ControlsKeys> | RuntimeControl): number | undefined;
+    getInstanceParentControl<T extends ControlsKeys>(instance: ControlRuntimeInstance<ControlsKeys> | RuntimeControl, controlType: T): ControlRuntimeInstance<T> | undefined;
+    getInstanceInSubtableHeader<T extends ControlsKeys>(instance: ControlRuntimeInstance<T> | RuntimeControl): ControlRuntimeInstance<T> | undefined;
+    setControlConfig(...args: Parameters<Runtime['registerControlConfig']>): Runtime;
+    getControlConfig(control: ControlsKeys): Readonly<Record<string, unknown>> | undefined;
+    inList(controlId: string): boolean;
+}
+export { Engine, EventPayload, SchemaEventPayload, EngineProps };

package/dist/types/common/OkWorker.d.ts

@@ -0,0 +1,13 @@
+interface WorkerMessage {
+    action: string;
+    payload: unknown;
+}
+declare class OkWorker {
+    worker?: Worker;
+    run(initState: any): void;
+    destroy(): void;
+    postMessage(message: WorkerMessage): void;
+    private static createWorker;
+    private static createWorkerFunction;
+}
+export { OkWorker };

package/dist/types/common/Plugin.d.ts

@@ -0,0 +1,6 @@
+import { Engine } from './Engine';
+declare abstract class Plugin {
+    abstract pluginName?: string;
+    abstract apply(engine: Engine): void;
+}
+export { Plugin };

package/dist/types/common/Runtime.d.ts

@@ -0,0 +1,25 @@
+import { RuleItem } from 'async-validator';
+import { ControlRuntimeInstance, ControlsKeys, RegisterControls, BeforeCreateInstance } from '@byteluck-fe/model-driven-core';
+export interface RuntimeProps {
+    schema: any;
+    beforeCreateInstance?: BeforeCreateInstance;
+}
+export type InstanceMap = Record<string, ControlRuntimeInstance<ControlsKeys>[]>;
+export declare class Runtime extends RegisterControls<'Runtime'> {
+    private _schema;
+    private _instance;
+    private _flatInstances;
+    private _instanceMap;
+    constructor(props: RuntimeProps);
+    getFlatInstances(): ControlRuntimeInstance<ControlsKeys>[];
+    get schema(): any;
+    get instance(): ControlRuntimeInstance<ControlsKeys>[];
+    get flatInstances(): ControlRuntimeInstance<ControlsKeys>[];
+    get instanceMap(): InstanceMap;
+    get allRules(): {
+        rules: Record<string, RuleItem>;
+        antdRules: Record<string, RuleItem>;
+    };
+    get rules(): Record<string, RuleItem>;
+    get antdRules(): Record<string, RuleItem>;
+}

package/dist/types/common/Store.d.ts

@@ -0,0 +1,49 @@
+import { RuntimeControl, DataBind, ObjectDataBind, OptionSetting } from '@byteluck-fe/model-driven-core';
+export type StateType = {
+    [controlId: string]: unknown;
+};
+export type StatesType = {
+    [dataViewId: string]: StateType;
+};
+export type controlIdMappingType = {
+    [controlId: string]: {
+        dataBind: DataBind | ObjectDataBind;
+        dataView: string;
+        children?: controlIdMappingType;
+        options: Array<OptionSetting>;
+    };
+};
+export interface DataBindMappingTypeItem {
+    controlId: string;
+    dataViewId: string;
+    fields: Array<DataBindMappingFieldItem>;
+}
+export interface DataBindMappingFieldItem {
+    fieldCode: string;
+    controlId: string;
+    dataBind: DataBind | ObjectDataBind;
+    dataViewId: string[];
+}
+export type dataBindMappingType = {
+    [dataCode: string]: DataBindMappingTypeItem;
+};
+type StoreProps = {
+    instance: RuntimeControl[];
+};
+declare class Store {
+    readonly emptyState: StatesType;
+    state: StatesType;
+    dataBindMapping: dataBindMappingType;
+    controlIdMapping: controlIdMappingType;
+    constructor(props: StoreProps);
+    /**
+     * 使用该方法仅改变数据，不会表单触发事件。明细表可全量赋值也可根据rowIndex进行单独设置
+     * @param controlId 组件ID
+     * @param value
+     */
+    setState(controlId: string, value: unknown, rowIndex?: number): void;
+    getState(controlId: string, rowIndex?: number): unknown;
+    getEmptyState(controlId: string): Object | undefined;
+    getDataBind(controlId: string): DataBind | ObjectDataBind | undefined;
+}
+export { Store };

package/dist/types/common/checkerValue.d.ts

@@ -0,0 +1,3 @@
+import { FieldTypes } from '@byteluck-fe/model-driven-shared';
+export declare function checkerValue(fieldType: FieldTypes, key: string, value: unknown, oldValue: unknown): unknown;
+export declare function checkerSubtableValue(fieldTypeMap: Record<string, FieldTypes>, value: Record<string, any>, emptyValue: Record<string, any>): Record<string, any>;

package/dist/types/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Engine';
+export * from './Plugin';

package/dist/types/common/proxyState.d.ts

@@ -0,0 +1,30 @@
+import { RuntimeControl, RuntimeFormControl, ControlRuntimeInstance } from '@byteluck-fe/model-driven-core';
+import { InstanceMap } from './Runtime';
+export type ArrayApi = 'splice' | 'push' | 'shift' | 'pop' | 'unshift' | 'reverse';
+/**
+ * @param state 当前正在操作的state数据
+ * @param key 当前操作的state的key 这个key是从store.state开始的
+ * @param type 如果state是数组，并且直接操作api的话，会携带type参数，代表当前操作的数组的某个api
+ * @param args 如果state是数组，并且直接操作api的话，会携带args参数，代表当前操作的api的参数
+ */
+type Callback = (state: object, key: string, type?: ArrayApi | unknown, args?: unknown[], result?: unknown) => void;
+type BeforeSetCallback = (state: object, key: string, newValue: unknown, oldValue: unknown) => never | unknown;
+export declare const engineProxyFlag: unique symbol;
+export declare const engineTargetKey: unique symbol;
+export declare const engineArrayBeforeSetCallbackFlag: unique symbol;
+export declare const engineProxyThisKey: unique symbol;
+/**
+ * 代理state数据
+ * @param state 数据对象
+ * @param callback 触发set时候的回调函数
+ * @param beforeSetCallback
+ * @param prevKey 递归对象的key
+ * */
+export declare function proxyState<T extends object>(state: T, callback: Callback, beforeSetCallback: BeforeSetCallback, prevKey?: string): T;
+/**
+ * 在flatInstance中通过key查找出对应的instance
+ * @param flatInstance 拍平的instance数组
+ * @param key 操作的数据在state的key - 可以是深层次的 subtable.0.input等
+ * */
+export declare function findItem(flatInstance: RuntimeControl[], key: string, instanceMap: InstanceMap): undefined | RuntimeFormControl | ControlRuntimeInstance<'subtable'>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './plugins';
+export * from './utils';

package/dist/types/plugins/CalcPlugin.d.ts

@@ -0,0 +1,121 @@
+import { Engine, Plugin } from '../common';
+import { Language } from '@byteluck-fe/model-driven-core';
+declare enum DisplayType {
+    /**
+     * 完全等于
+     */
+    EQ = "EQ",
+    /**
+     * 包含
+     * */
+    IN = "IN"
+}
+interface DisplayItem {
+    id: string;
+    show_edit: boolean;
+    explain: Language;
+    control_id: string;
+    control_in_subtable: boolean;
+    type: DisplayType;
+    option_ids: string[];
+    is_remember: boolean;
+    show_controls: string[];
+    hide_controls: string[];
+}
+interface BehaviorItem {
+    /**
+     *  0: 不控制，走控件 1： 隐藏 2：只读 6：可编辑
+     * */
+    ctrlBehavior: 0 | 1 | 2 | 6;
+    ctrlId: string;
+}
+interface CalcPluginProps {
+    displayBoList: DisplayItem[];
+    behavior: BehaviorItem[];
+}
+export declare class CalcPlugin implements Plugin {
+    private engine;
+    private options;
+    /**
+     * 所有的计算公式控件
+     * */
+    private calcControls;
+    /**
+     * key=控件id  value=控件修改后需要触发重新计算的计算公式控件组成的数组
+     * 存储为一个Map，用于在控件change的时候，重新计算依赖的calc
+     * */
+    private dependenciesTriggerMap;
+    /**
+     * 隐藏以后需要被计算的控件
+     * */
+    private hideNotRememberControlIds;
+    private dontHasPermissionControlIds;
+    private cacheComputedResult;
+    constructor(options: CalcPluginProps);
+    /**
+     * @description 获取显隐控制的需要被记住值的控件id
+     * */
+    private getNeedHideRememberControlIds;
+    /**
+     * @description 获取权限控制的隐藏的字段，不需要参与计算
+     * */
+    private getDontHasPermissionControlIds;
+    /**
+     * @description 判断控件是否需要被计算
+     * @param control 控件
+     * */
+    private controlNeedComputedValue;
+    /**
+     * @description 获取控件是否被隐藏
+     * @param control 控件
+     * */
+    private getControlIsHide;
+    apply(engine: Engine): void;
+    /**
+     * @description 重置依赖，获取所有的计算公式控件，并根据计算公式获取控件依赖关系
+     * */
+    private resetDependencies;
+    /**
+     * @description 执行所有计算公式控件的计算
+     * */
+    private allCalcControlComputed;
+    /**
+     * @description 获取所有的计算公式控件
+     * */
+    private getAllCalcControl;
+    /**
+     * @description 获取计算公式控件依赖，组成 依赖=>[计算公式] 的Map结构
+     * */
+    private getCalcDependencies;
+    private setDependenciesTriggerMapItem;
+    private getCalcControlsFromSubtableRows;
+    /**
+     * @description 监听控件的显隐事件，把显隐会影响的控件触发一遍计算
+     * */
+    private watchSchemaHideChange;
+    /**
+     * @description 监听明细子表的change事件，把明细表会影响的控件触发一遍计算
+     * */
+    private watchSubtableChange;
+    /**
+     * @description 监听控件的change事件，当控件change的时候，取到控件会影响的计算公式，然后执行对应的计算
+     * */
+    private watchControlChange;
+    /**
+     * @description 控件在明细子表内
+     * */
+    private controlInSubtable;
+    /**
+     * @description 执行计算公式的计算
+     * */
+    private computedCalcValue;
+    /**
+     * @description 获取数字值，因为计算公式可以依赖计算公式和金额，所以需要从value中取到对应的值
+     * */
+    private getNumberValue;
+    /**
+     * 计算明细子表最大值最小值平均值总和
+     * */
+    private getAggregateTypeValue;
+}
+export {};

package/dist/types/plugins/ControlsEventPlugin.d.ts

@@ -0,0 +1,15 @@
+import { Engine } from '../common/Engine';
+import { Plugin } from '../common/Plugin';
+export type ControlsEvent = {
+    [controlId: string]: {
+        [eventName: string]: string[];
+    };
+};
+export declare class ControlsEventPlugin implements Plugin {
+    private config;
+    private engine;
+    constructor(config: ControlsEvent);
+    apply(engine: Engine): void;
+    private engineAddEventListener;
+    private callControlEvent;
+}

package/dist/types/plugins/ES6ModulePlugin.d.ts

@@ -0,0 +1,26 @@
+import { Engine, Plugin } from '../common';
+export type VariableMap = {
+    [key: string]: any;
+};
+export type ActionConfig = {
+    module: {
+        compiled: string;
+        source: string;
+        type: 'FUNCTION';
+    };
+};
+export type FuncMap = {
+    [key: string]: Function;
+};
+export type Module = {
+    funcMap: FuncMap;
+    variables: VariableMap;
+};
+export declare class ES6ModulePlugin implements Plugin {
+    private config;
+    private engine;
+    private env;
+    constructor(config: ActionConfig, env: any);
+    apply(engine: Engine): void;
+}
+export declare function parseModule(action: ActionConfig, engine: Engine, env: any): Module | undefined;

package/dist/types/plugins/LifecycleEventPlugin.d.ts

@@ -0,0 +1,14 @@
+import { Engine, Plugin } from '../common';
+export type LifecycleEvent = {
+    did_mount: string[];
+    did_submit: string[];
+    will_submit: string[];
+    do_submit: string[];
+};
+export declare class LifecycleEventPlugin implements Plugin {
+    private config;
+    private engine;
+    constructor(config: LifecycleEvent);
+    apply(engine: Engine): void;
+    private callLifecycleEvent;
+}

package/dist/types/plugins/StylePlugin.d.ts

@@ -0,0 +1,12 @@
+import { Engine, Plugin } from '../common';
+export type StyleConfig = {
+    compiled: string;
+    source: string;
+    type: 'CSS';
+};
+export declare class StylePlugin implements Plugin {
+    private config;
+    private engine;
+    constructor(config: StyleConfig);
+    apply(engine: Engine): void;
+}

package/dist/types/plugins/index.d.ts

@@ -0,0 +1,5 @@
+export * from './ES6ModulePlugin';
+export * from './LifecycleEventPlugin';
+export * from './ControlsEventPlugin';
+export * from './CalcPlugin';
+export * from './StylePlugin';

package/dist/types/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './runtimeUtils';

package/dist/types/utils/runtimeUtils.d.ts

@@ -0,0 +1,5 @@
+import { ControlRuntimeInstance, ControlsKeys, RuntimeControl, RuntimeFormControl, RuntimeLayoutControl, RuntimeListControl, RuntimeSearchControl } from '@byteluck-fe/model-driven-core';
+export declare function hasChildrenControl(instance: RuntimeControl): instance is RuntimeLayoutControl | RuntimeListControl | RuntimeSearchControl;
+export declare function loopFormControl(control: RuntimeControl[], callback: (item: RuntimeFormControl | ControlRuntimeInstance<'subtable'>, children?: RuntimeFormControl[]) => any): void;
+export declare function loopDataViewControl(control: ControlRuntimeInstance<ControlsKeys>[], callback: (item: ControlRuntimeInstance<'data-view' | 'simple-search'>) => any): void;
+export declare function buildUUID(prefix?: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byteluck-fe/model-driven-engine",
-  "version": "2.3.1-beta.25",
+  "version": "2.3.1-beta.26",
   "description": "> TODO: description",
   "author": "郝晨光 <2293885211@qq.com>",
   "homepage": "",
@@ -26,7 +26,7 @@
     "postpublish": "node ../../scripts/postpublish.js"
   },
   "dependencies": {
-    "@byteluck-fe/model-driven-core": "2.3.1-beta.23",
+    "@byteluck-fe/model-driven-core": "2.3.1-beta.26",
     "@byteluck-fe/model-driven-shared": "2.3.1-beta.23",
     "@types/mathjs": "^9.4.2",
     "mathjs": "^11.3.3"
@@ -34,5 +34,5 @@
   "devDependencies": {
     "@types/node": "~18.0.6"
   },
-  "gitHead": "f709000371a428ee181b1560cc99539d6424b7e5"
+  "gitHead": "2dd5344cfff27a67c4fd13f3ca654173e64af4c8"
 }