@byteluck-fe/runtime-engine 1.0.2 → 1.1.1

package/dist/src/services/widgets.d.ts

@@ -0,0 +1,15 @@
+import { FetchService } from '../utils';
+/**
+ *
+ * @class Test
+ * @param {(string)} [domainOrOptions] - The project domain.
+ */
+export default class {
+    http: FetchService;
+    constructor(http: FetchService);
+    /**
+     * 获取审批组件是否显示配置，流程配置的
+     * @method
+     */
+    GetSocialHasPermission(data: any, headers: any): Promise<any>;
+}

package/dist/src/store/index.d.ts

@@ -0,0 +1,26 @@
+import { Store } from 'vuex';
+type HighPerformanceSubtableEditingCell = {
+    subTableId: string;
+    rowIndex: number;
+    colField: string;
+} | null;
+declare const _default: Store<{
+    userInfo: {};
+    tenant: {};
+    centerUser: {};
+    collapsed: boolean;
+    externalForm: {
+        formKey: string;
+        appId: string;
+    };
+    pageLoading: boolean;
+    relationSelectState: {};
+    relationOptions: {};
+    highPerformanceSubtableEditingCell: HighPerformanceSubtableEditingCell;
+    multipleTabs: {};
+    tabsMenuList: {};
+    customTemplateData: {};
+    excludeFullPath: never[];
+    isSubtableFull: boolean;
+}>;
+export default _default;

package/dist/src/types/PageContext.d.ts

@@ -0,0 +1,6 @@
+import { Engine } from '@byteluck-fe/model-driven-engine';
+export type PageContext = {
+    engine: Engine;
+    store: Record<string, unknown>;
+    dataSource: Record<string, unknown>;
+};

package/dist/src/types/PaginationProps.d.ts

@@ -0,0 +1,22 @@
+import { ComputedRef, VNodeChild } from 'vue';
+interface PaginationRenderProps {
+    page: number;
+    type: 'page' | 'prev' | 'next';
+    originalElement: any;
+}
+export interface PaginationProps {
+    total?: number | ComputedRef;
+    defaultCurrent?: number;
+    current?: number;
+    defaultPageSize?: number;
+    pageSize?: number;
+    pageSizeOptions?: string[];
+    hideOnSinglePage?: boolean;
+    showSizeChanger?: boolean;
+    showQuickJumper?: boolean | object;
+    showTotal?: (total: number, range: [number, number]) => any;
+    size?: string;
+    simple?: boolean;
+    itemRender?: (props: PaginationRenderProps) => VNodeChild | JSX.Element;
+}
+export {};

package/dist/src/types/approval-submit.d.ts

@@ -0,0 +1,7 @@
+export type ApprovalSubmitPayload = {
+    uId: string;
+    runTask: {
+        command_id: string;
+        command_type: string;
+    };
+};

package/dist/src/types/type.d.ts

@@ -0,0 +1,26 @@
+import { PropType, VNodeChild } from 'vue';
+export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+export declare const tuple: <T extends string[]>(...args: T) => T;
+export declare const tupleNum: <T extends number[]>(...args: T) => T;
+/**
+ * https://stackoverflow.com/a/59187769
+ * Extract the type of an element of an array/tuple without performing indexing
+ */
+export type ElementOf<T> = T extends (infer E)[] ? E : T extends readonly (infer F)[] ? F : never;
+/**
+ * https://github.com/Microsoft/TypeScript/issues/29729
+ */
+export type LiteralUnion<T extends U, U> = T | (U & {});
+export type Data = Record<string, unknown>;
+export type ObjectData = Record<string, any>;
+export type Key = string | number;
+type DefaultFactory<T> = (props: Data) => T | null | undefined;
+export interface PropOptions<T = any, D = T> {
+    type?: PropType<T> | true | null;
+    required?: boolean;
+    default?: D | DefaultFactory<D> | null | undefined | object;
+    validator?(value: unknown): boolean;
+}
+export type VueNode = VNodeChild | JSX.Element;
+export declare const withInstall: <T>(comp: any) => T & Plugin;
+export {};

package/dist/src/types/vue-type.d.ts

@@ -0,0 +1,103 @@
+import { VueTypesDefaults, VueTypesConfig, ExtendProps, PropOptions } from 'vue-types/dist/types';
+import { CSSProperties } from 'vue';
+import { VueTypeDef, custom, oneOf, instanceOf, oneOfType, arrayOf, objectOf, shape, VueTypeValidableDef } from 'vue-types';
+import { VueNode } from './type';
+export declare function withUndefined<T extends {
+    default?: any;
+}>(type: T): T;
+export declare const ButtonTypes: ["default", "primary", "ghost", "dashed", "danger", "link"];
+declare const _default: {
+    new (): {};
+    defaults: Partial<VueTypesDefaults>;
+    sensibleDefaults: boolean | Partial<VueTypesDefaults>;
+    config: VueTypesConfig;
+    readonly any: VueTypeValidableDef<any>;
+    readonly func: VueTypeValidableDef<(...args: any[]) => any> & {
+        default: (...args: any[]) => any;
+    };
+    readonly bool: VueTypeValidableDef<boolean> & {
+        default: boolean;
+    };
+    readonly string: VueTypeValidableDef<string> & {
+        default: string;
+    };
+    readonly number: VueTypeValidableDef<number> & {
+        default: number;
+    };
+    readonly array: VueTypeValidableDef<unknown[]> & {
+        default: () => unknown[];
+    };
+    readonly object: VueTypeValidableDef<{
+        [key: string]: any;
+    }> & {
+        default: () => {
+            [key: string]: any;
+        };
+    };
+    readonly integer: VueTypeDef<number> & {
+        default: number;
+    };
+    readonly symbol: VueTypeDef<symbol>;
+    readonly custom: typeof custom;
+    readonly oneOf: typeof oneOf;
+    readonly instanceOf: typeof instanceOf;
+    readonly oneOfType: typeof oneOfType;
+    readonly arrayOf: typeof arrayOf;
+    readonly objectOf: typeof objectOf;
+    readonly shape: typeof shape;
+    extend<T_3 extends {
+        new (): {};
+        defaults: Partial<VueTypesDefaults>;
+        sensibleDefaults: boolean | Partial<VueTypesDefaults>;
+        config: VueTypesConfig;
+        readonly any: VueTypeValidableDef<any>;
+        readonly func: VueTypeValidableDef<(...args: any[]) => any> & {
+            default: (...args: any[]) => any;
+        };
+        readonly bool: VueTypeValidableDef<boolean> & {
+            default: boolean;
+        };
+        readonly string: VueTypeValidableDef<string> & {
+            default: string;
+        };
+        readonly number: VueTypeValidableDef<number> & {
+            default: number;
+        };
+        readonly array: VueTypeValidableDef<unknown[]> & {
+            default: () => unknown[];
+        };
+        readonly object: VueTypeValidableDef<{
+            [key: string]: any;
+        }> & {
+            default: () => {
+                [key: string]: any;
+            };
+        };
+        readonly integer: VueTypeDef<number> & {
+            default: number;
+        };
+        readonly symbol: VueTypeDef<symbol>;
+        readonly custom: typeof custom;
+        readonly oneOf: typeof oneOf;
+        readonly instanceOf: typeof instanceOf;
+        readonly oneOfType: typeof oneOfType;
+        readonly arrayOf: typeof arrayOf;
+        readonly objectOf: typeof objectOf;
+        readonly shape: typeof shape;
+        extend<T extends unknown>(props: ExtendProps<any> | ExtendProps<any>[]): T;
+        utils: {
+            validate<T_1, U>(value: T_1, type: U): boolean;
+            toType<T_2 = unknown>(name: string, obj: PropOptions<T_2, T_2>, validable?: boolean | undefined): VueTypeDef<T_2> | VueTypeValidableDef<T_2>;
+        };
+    }>(props: ExtendProps<any> | ExtendProps<any>[]): T_3;
+    utils: {
+        validate<T_1_1, U_1>(value: T_1_1, type: U_1): boolean;
+        toType<T_2_1 = unknown>(name: string, obj: PropOptions<T_2_1, T_2_1>, validable?: boolean | undefined): VueTypeDef<T_2_1> | VueTypeValidableDef<T_2_1>;
+    };
+} & {
+    readonly looseBool: VueTypeValidableDef<boolean>;
+    readonly style: VueTypeValidableDef<CSSProperties>;
+    readonly VNodeChild: VueTypeValidableDef<VueNode>;
+};
+export default _default;
+export * from './type';

package/dist/src/types/vuedraggable.d.ts

@@ -0,0 +1,36 @@
+declare module 'vuedraggable' {
+    import { ComponentOptions, Component } from 'vue';
+    export interface DraggedContext<T> {
+        index: number;
+        futureIndex: number;
+        element: T;
+    }
+    export interface DropContext<T> {
+        index: number;
+        component: Component;
+        element: T;
+    }
+    export interface Rectangle {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+        width: number;
+        height: number;
+    }
+    export interface MoveEvent<T> {
+        originalEvent: DragEvent;
+        dragged: Element;
+        draggedContext: DraggedContext<T>;
+        draggedRect: Rectangle;
+        related: Element;
+        relatedContext: DropContext<T>;
+        relatedRect: Rectangle;
+        from: Element;
+        to: Element;
+        willInsertAfter: boolean;
+        isTrusted: boolean;
+    }
+    const draggableComponent: ComponentOptions<{}>;
+    export default draggableComponent;
+}

package/dist/src/utils/controls/activeElementBlur.d.ts

@@ -0,0 +1 @@
+export declare function activeElementBlur(): Promise<void>;

package/dist/src/utils/controls/amountUtils.d.ts

@@ -0,0 +1,4 @@
+declare const thousFormat: (value: number | string) => string;
+declare const okToFixed: (num: number | string, precision: number) => string;
+export declare function clearNumber(num: any, precision: number | ''): string | number;
+export { thousFormat, okToFixed };

package/dist/src/utils/controls/attachmentUtils.d.ts

@@ -0,0 +1,7 @@
+declare const MAX_FILE_SIZE = 104857600;
+declare const ALL_ACCEPT_TYPE: string[];
+declare const getFileType: (filePath: string) => string;
+declare const validFileType: (fileName: string, fileTypeList: string[]) => boolean;
+declare const validAttachmentType: (fileName: string, type?: string[]) => boolean;
+export * from '../../constant/global';
+export { MAX_FILE_SIZE, ALL_ACCEPT_TYPE, getFileType, validFileType, validAttachmentType, };

package/dist/src/utils/controls/customVueRegister.d.ts

@@ -0,0 +1,2 @@
+export declare function simpleMoudleInit(module: Recordable<object>): void;
+export default function install(Vue: any): void;

package/dist/src/utils/controls/dateUtils.d.ts

@@ -0,0 +1,6 @@
+declare const formatDateValue: (value: any) => any;
+declare const computedDisabledDate: (current: any, limitDateList: any, dateType: 'date' | 'datetime' | 'datemin' | 'datehour' | 'month' | 'year') => any;
+declare const boundaryTime: (value: number | string, type?: string) => string[] | "";
+declare const boundaryRange: (range: any, type: any) => string[];
+declare const getSystemTime: (type: any) => string;
+export { computedDisabledDate, boundaryTime, boundaryRange, formatDateValue, getSystemTime };

package/dist/src/utils/controls/dealTableColumn.d.ts

@@ -0,0 +1,20 @@
+import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
+import { ComputedRef } from 'vue';
+import { RuntimeColumnControl } from '@byteluck-fe/model-driven-core-all';
+export declare enum BTN_TYPE {
+    delete = "delete",
+    custom = "custom",
+    create = "create",
+    view = "view",
+    edit = "edit"
+}
+export declare function computedItemWidth(children: ComputedRef<ControlRuntimeInstance<'operation-button'>[]>, showType: 'icon' | 'text' | 'text', limit: number): void;
+export declare function dealGridTableColumns(params: {
+    instance: ControlRuntimeInstance<'grid-table'>;
+    filterColumns: RuntimeColumnControl[];
+    operationChildrenNum: number;
+    resizeWidthList?: typing.CustomHeaderWidthBo[];
+    tableWidth?: number;
+    indexFlag?: boolean;
+    modalFlag?: boolean;
+}): Record<string, any>[];

package/dist/src/utils/controls/findInstance.d.ts

@@ -0,0 +1,2 @@
+import { RuntimeControl, ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
+export declare const findSubtable: (control: RuntimeControl) => ControlRuntimeInstance<'subtable'> | null;

package/dist/src/utils/controls/formCopy.d.ts

@@ -0,0 +1,9 @@
+export declare const formCopy: {
+    clearValueFieldCodeStates: {
+        dataCode: string;
+        fieldCode: string;
+    }[];
+    isCopy(type?: string): boolean;
+    setClearValueFieldCode(schema: any): void;
+    resetDataSet(dataSet: any): void;
+};

package/dist/src/utils/controls/getSubtables.d.ts

@@ -0,0 +1 @@
+export declare function getSubtables(data: any): any[];

package/dist/src/utils/controls/imageUtils.d.ts

@@ -0,0 +1,8 @@
+declare const MAX_IMAGE_SIZE = 10485760;
+declare const INITAL_IMAGE_TYPE: string[];
+declare const IMAGE_ACCEPT_TYPE_ARR: string[];
+declare const IMAGE_ACCEPT_TYPE: string;
+declare const validImageType: (fileName: string, type?: string[]) => boolean;
+declare const isImage: (suffix: string) => boolean;
+export * from '../../constant/global';
+export { MAX_IMAGE_SIZE, INITAL_IMAGE_TYPE, IMAGE_ACCEPT_TYPE_ARR, IMAGE_ACCEPT_TYPE, validImageType, isImage, };

package/dist/src/utils/controls/index.d.ts

@@ -0,0 +1,14 @@
+export * from './amountUtils';
+export * from './imageUtils';
+export * from './activeElementBlur';
+export * from './attachmentUtils';
+export * from './notAccess';
+export * from './notFound';
+export * from './notSupportMobile';
+export * from './submitFormData';
+export * from './findInstance';
+export * from './dealTableColumn';
+export * from './table';
+export * from './preview';
+export * from './subtable';
+export * from './formCopy';

package/dist/src/utils/controls/notAccess.d.ts

@@ -0,0 +1,5 @@
+import { Router } from 'vue-router';
+export declare function setNotAccess(router: Router, options: {
+    appId: string;
+    sappId: string;
+}, query: any, store: any, fullPath: string): void;

package/dist/src/utils/controls/notFound.d.ts

@@ -0,0 +1,5 @@
+import { Router } from 'vue-router';
+export declare function setNotFound(router: Router, options: {
+    appId: string;
+    sappId: string;
+}, query: any, store: any, fullPath: string): void;

package/dist/src/utils/controls/notSupportMobile.d.ts

@@ -0,0 +1 @@
+export declare function notSupportMobile(supportMobile: boolean | undefined): void;

package/dist/src/utils/controls/preview.d.ts

@@ -0,0 +1 @@
+export declare const isPreview: boolean;

package/dist/src/utils/controls/submitFormData.d.ts

@@ -0,0 +1,14 @@
+import { Engine } from '@byteluck-fe/model-driven-engine';
+/**
+ * 格式化表单保存数据
+ */
+export declare function getSaveData(context: Engine, dataViewId: string, params: {
+    sappId?: string;
+    uId?: string;
+    isEditing?: boolean;
+    channelParamId?: string;
+}, behaviors: typing.PageBehaviorBo[]): typing.SubmitFormDto & typing.RunFormDto;
+/**
+ * 表单校验，滚动到提示第一个
+ */
+export declare function validTransition(): string | undefined;

package/dist/src/utils/controls/subtable.d.ts

@@ -0,0 +1,3 @@
+import { CONTROL_TYPE } from '@byteluck-fe/model-driven-core-all';
+export declare function isNewRow(uid: string): boolean;
+export declare const protogenesisColumn: readonly CONTROL_TYPE[];

package/dist/src/utils/controls/subtableDealTableColumn.d.ts

@@ -0,0 +1,156 @@
+import { default as __DTS_2__ } from '@byteluck-fe/model-driven-controls/dist/types/layoutControls/SubTableRow/runtime';
+import { default as __DTS_1__ } from '@byteluck-fe/model-driven-controls/dist/types/layoutControls/SubTableColumn/runtime';
+import { ControlRuntimeInstance } from '@byteluck-fe/model-driven-core-all';
+import { DefineComponent, Raw, PropType, ComponentOptionsMixin, VNodeProps, AllowedComponentProps, ComponentCustomProps, ExtractPropTypes, Ref } from 'vue';
+declare const HeaderType: __DTS_1__[];
+export declare function dealGridTableColumns(params: {
+    filterInstance?: ControlRuntimeInstance<'subtable-column'>;
+    meta: 'pc' | 'mobile';
+    isPinned?: boolean;
+    isPrintMode?: boolean;
+}): {
+    width: number | undefined;
+    maxWidth: number | undefined;
+    minWidth: number | undefined;
+    flex: number | undefined;
+    pinned: string | boolean | undefined;
+};
+export declare const subTableCellRenderColumn: (item: any, headers: typeof HeaderType, instance?: ControlRuntimeInstance<'subtable-column'>, isPinned?: boolean, isPrintMode?: boolean) => {
+    width: number | undefined;
+    maxWidth: number | undefined;
+    minWidth: number | undefined;
+    flex: number | undefined;
+    pinned: string | boolean | undefined;
+    cellEditor: DefineComponent<{
+        params: {
+            type: ObjectConstructor;
+            required: true;
+        };
+    }, unknown, {
+        instance: undefined;
+        dataSource: never[];
+        control: Raw<DefineComponent<{
+            instance: {
+                type: PropType<__DTS_2__>;
+                required: true;
+            };
+            col: {
+                type: ObjectConstructor;
+                required: true;
+                default: () => {};
+            };
+            index: {
+                type: NumberConstructor;
+                required: true;
+                default: undefined;
+            };
+            colIndex: {
+                type: (SymbolConstructor | NumberConstructor | StringConstructor)[];
+                required: true;
+                default: undefined;
+            };
+            pageStatus: {
+                type: StringConstructor;
+                required: true;
+                default: undefined;
+            };
+            editableData: {
+                type: ObjectConstructor;
+                default: undefined;
+            };
+            dataValue: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            rowRecord: {
+                type: ObjectConstructor;
+                default: undefined;
+            };
+            openType: {
+                type: StringConstructor;
+                default: undefined;
+            };
+        }, {
+            tableItem: Ref<any>;
+        }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
+            instance: {
+                type: PropType<__DTS_2__>;
+                required: true;
+            };
+            col: {
+                type: ObjectConstructor;
+                required: true;
+                default: () => {};
+            };
+            index: {
+                type: NumberConstructor;
+                required: true;
+                default: undefined;
+            };
+            colIndex: {
+                type: (SymbolConstructor | NumberConstructor | StringConstructor)[];
+                required: true;
+                default: undefined;
+            };
+            pageStatus: {
+                type: StringConstructor;
+                required: true;
+                default: undefined;
+            };
+            editableData: {
+                type: ObjectConstructor;
+                default: undefined;
+            };
+            dataValue: {
+                type: ObjectConstructor;
+                required: true;
+            };
+            rowRecord: {
+                type: ObjectConstructor;
+                default: undefined;
+            };
+            openType: {
+                type: StringConstructor;
+                default: undefined;
+            };
+        }>>, {
+            col: Record<string, any>;
+            pageStatus: string;
+            rowRecord: Record<string, any>;
+            openType: string;
+            index: number;
+            colIndex: string | number | symbol;
+            editableData: Record<string, any>;
+        }, {}>>;
+        options: {
+            col: {
+                trigger: undefined;
+                dataIndex: string;
+            };
+            index: number;
+            colIndex: undefined;
+            rowRecord: undefined;
+        };
+        renderRef: null;
+    }, {
+        dataValue(): any;
+    }, {
+        render(): void;
+        openVirtuallyModel(params: any): void;
+        handleGetList(): void;
+        handelDeleteRow(param: any): void;
+        getPopupContainer(): Element | null;
+        handleClickCell(): void;
+        getValue(): any;
+        windowChange(): void;
+    }, ComponentOptionsMixin, ComponentOptionsMixin, "openVirtuallyModel"[], "openVirtuallyModel", VNodeProps & AllowedComponentProps & ComponentCustomProps, Readonly<ExtractPropTypes<{
+        params: {
+            type: ObjectConstructor;
+            required: true;
+        };
+    }>> & {
+        onOpenVirtuallyModel?: ((...args: any[]) => any) | undefined;
+    }, {}, {}>;
+    cellRenderer: string;
+};
+export {};

package/dist/src/utils/controls/table.d.ts

@@ -0,0 +1,10 @@
+import { OptionsType } from '../../types/controls/table-import';
+/**
+ * 遍历数据，重命名重复项的label值
+ * @param list 对象数组
+ * @example [{"label":"短文本"},{"label":"长文本"},{"lable":"短文本"},{"lable":"短文本"}]
+ *       => [{"label":"短文本"},{"label":"长文本"},{"lable":"短文本@1"},{"lable":"短文本@2"}]
+ */
+export declare function addRepeatNameSeparator(list: OptionsType[], separator: string): OptionsType[];
+export declare function removeLabelSeparator(name: string, separator: string, index?: number): string;
+export declare function removeRepeatNameSeparator(list: OptionsType[], separator: string): OptionsType[];

package/dist/src/utils/core/buildFiltersToDataSetValues.d.ts

@@ -0,0 +1,9 @@
+import { FieldFilterCondition, FieldFilterConditions } from '@byteluck-fe/model-driven-core-all';
+import { Engine } from '@byteluck-fe/model-driven-engine';
+interface DataSetValue {
+    code: string;
+    value: string;
+    field_type?: string;
+}
+export declare function buildFiltersToDataSetValues(engine: Engine, filters: (FieldFilterCondition | FieldFilterConditions)[], rowIndex?: number, initialValue?: DataSetValue[], props?: any): DataSetValue[];
+export {};

package/dist/src/utils/core/cacheRequest.d.ts

@@ -0,0 +1,10 @@
+import ServiceAuto from '../../services/services.auto';
+export declare class CacheRequest {
+    private cache;
+    private cacheResult;
+    private readonly service;
+    constructor(requestThis: ServiceAuto);
+    setCache(value: boolean): void;
+    request<T extends (payload: any) => Promise<any>>(request: T, params: Parameters<T>[0]['payload']): ReturnType<T>;
+    request<T extends (payload: any) => Promise<any>, R>(request: T, params: Parameters<T>[0]['payload'], callback: (response: ReturnType<T> extends Promise<infer U> ? U : any) => R): Promise<R extends void ? ReturnType<T> : R>;
+}

package/dist/src/utils/core/crossMessageProcessor.d.ts

@@ -0,0 +1,10 @@
+type CrossDomainMessageType = {
+    status: string;
+    action: string;
+    system: string;
+    options: any;
+};
+export declare function tryRefreshOpener(message: CrossDomainMessageType): void;
+export declare function corssDomainMessageProcessor(route: any, store: any): void;
+export declare function removeAppLauncherTab(message: any): void;
+export {};

package/dist/src/utils/core/index.d.ts

@@ -0,0 +1,9 @@
+export * from '@byteluck-fe/global-shared';
+export * from './cacheRequest';
+export * from './setFormData';
+export * from './setSubtableData';
+export * from './buildFiltersToDataSetValues';
+export * from './math';
+export * from './proxy';
+export { default as vueApp } from './vueApp';
+export { default as Mitt } from './tinyMitt';

package/dist/src/utils/core/math.d.ts

@@ -0,0 +1,6 @@
+import Decimal from 'decimal.js';
+export declare const add: (arg1: Decimal.Value, arg2: Decimal.Value) => string;
+export declare const subtract: (arg1: Decimal.Value, arg2: Decimal.Value) => string;
+export declare const multiply: (arg1: Decimal.Value, arg2: Decimal.Value) => string;
+export declare const divide: (arg1: Decimal.Value, arg2: Decimal.Value) => string;
+export declare const toFixed: (num: Decimal.Value, dp?: number) => string;

package/dist/src/utils/core/onlineDebugger.d.ts

@@ -0,0 +1,2 @@
+export declare function consolelog(...args: any[]): void;
+export declare function consoleerror(...args: any[]): void;

package/dist/src/utils/core/proxy.d.ts

@@ -0,0 +1,4 @@
+import { ComponentPublicInstance, ComponentOptionsBase } from 'vue';
+export declare function getCurrentProxy(): {
+    proxy: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+};

package/dist/src/utils/core/registerControl.d.ts

@@ -0,0 +1,10 @@
+declare namespace __WebpackModuleApi {
+    interface RequireContext {
+        keys(): string[];
+        <T>(id: string): T;
+    }
+}
+export declare function register(comps: any): void;
+export declare function init(context: __WebpackModuleApi.RequireContext): void;
+export default function install(Vue: any): void;
+export {};

package/dist/src/utils/core/sensorsData.d.ts

@@ -0,0 +1 @@
+export declare function approvalSensors(task: any, context: any): void;

package/dist/src/utils/core/setFormData.d.ts

@@ -0,0 +1,21 @@
+import { Engine } from '@byteluck-fe/model-driven-engine';
+export declare function getFormDataUID(values: any[]): string;
+/**
+ * 填充表单数据
+ * @param data 需要填充的原始数据
+ */
+export declare function getMasterData(dataCode: string, values: typing.DataBo[]): {
+    dataSet: any;
+    dataDisplay: any;
+};
+export declare function handleFillDataSet(context: Engine, dataSetValues: typing.DataBo[], subTableData?: {
+    [subtableId: string]: typing.SubTableRowDataBo[];
+}): void;
+export declare function setFormDataNew(params: {
+    context: Engine;
+    uId?: string | null;
+    datasetPromise?: Promise<typing.PageDataDisplayBo | undefined>;
+    setLoading?: Fn;
+    query: typing.SubTableQuery;
+    isCopyPage?: boolean;
+}): Promise<void>;