@gct-paas/render 0.1.4-dev.8 → 0.1.5-dev.0

package/es/Event/Dependency/useDependencyToShow.mjs

@@ -0,0 +1,113 @@
+import { getPremission } from "../utils/runGlobalByPage.mjs";
+import "../utils/processRovedInfo.mjs";
+import { calculateDepResult, insetDep } from "./controller.mjs";
+import { useVisibileByRuleHook } from "./displayRule.mjs";
+import { Dependency_ENUM, DisplayType } from "@gct-paas/core";
+import { inject, toRef } from "vue";
+//#region src/Event/Dependency/useDependencyToShow.ts
+function useDependencyToShow(widget) {
+	if (widget.props?.displayRule && widget.props?.displayType === DisplayType.RULE)
+ /**老版本显隐逻辑 */
+	return useVisibileByRuleHook(widget.props, widget.id);
+	else return dependencyToShow(widget);
+}
+function dependencyToShow(widget, rowData) {
+	if (!widget.id) return false;
+	if (!getPremission(widget.id)) {
+		/**权限不存在就直接返回false */
+		widget.props.hidden = true;
+		return false;
+	}
+	const useProcessFieldEvent = inject("useProcessFieldEvent", void 0);
+	if (useProcessFieldEvent) {
+		/**流程节点隐藏的字段 */
+		useProcessFieldEvent.useFieldToShow(widget);
+		return !widget.props.hidden;
+	}
+	const { displayType, displayRule } = widget.props || {};
+	const { value, expression } = (widget.props.componentDependency?.configDependency || {})[Dependency_ENUM.HIDDEN] || {};
+	if (value && expression) {
+		widget.props.hidden = true;
+		insetDep({
+			expression,
+			rowData
+		}, (res) => {
+			widget.props.hidden = !!res;
+		});
+	} else if (value)
+ /**开启组件依赖没有配置隐藏条件 */
+	widget.props.hidden = true;
+	else if (displayType === DisplayType.RULE && displayRule) {
+		/**老数据显示隐藏配置兼容 */
+		widget.props.hidden = true;
+		insetDep({
+			expression: displayRule,
+			rowData
+		}, (res) => {
+			widget.props.hidden = !res;
+		});
+	}
+	return toRef(() => !widget.props.hidden);
+}
+/**直接返回计算结果的依赖显隐逻辑 */
+async function dependencyToShowSync(widget, rowData) {
+	if (!widget.id) return false;
+	if (!getPremission(widget.id)) {
+		/**权限不存在就直接返回false */
+		widget.props.hidden = true;
+		return false;
+	}
+	const useProcessFieldEvent = inject("useProcessFieldEvent", void 0);
+	if (useProcessFieldEvent) {
+		/**流程节点隐藏的字段 */
+		useProcessFieldEvent.useFieldToShow(widget);
+		return !widget.props.hidden;
+	}
+	const { displayType, displayRule } = widget.props || {};
+	const { value, expression } = (widget.props.componentDependency?.configDependency || {})[Dependency_ENUM.HIDDEN] || {};
+	if (value && expression) {
+		widget.props.hidden = true;
+		widget.props.hidden = !!await calculateDepResult({
+			expression,
+			rowData
+		});
+	} else if (value)
+ /**开启组件依赖没有配置隐藏条件 */
+	widget.props.hidden = true;
+	else if (displayType === DisplayType.RULE && displayRule) {
+		/**老数据显示隐藏配置兼容 */
+		widget.props.hidden = true;
+		widget.props.hidden = !!await calculateDepResult({
+			expression: displayRule,
+			rowData
+		});
+	}
+	return !widget.props.hidden;
+}
+/**组件集合处理 */
+function useDependencyToShowList(widgetList, rowData) {
+	widgetList.forEach((widget) => {
+		dependencyToShow(widget, rowData);
+	});
+	return toRef(() => widgetList.filter((i) => !i.props.hidden));
+}
+function tableWidgetToShow(widget, callback) {
+	const { value, expression } = (widget.props.componentDependency?.configDependency || {})[Dependency_ENUM.HIDDEN] || {};
+	if (value && expression) insetDep({ expression }, (res) => {
+		callback(res);
+	});
+	callback(widget.props.hidden);
+}
+function tableWidgetByDept(widget) {
+	const configDependency = widget.props.componentDependency?.configDependency || {};
+	const { value, expression } = configDependency[Dependency_ENUM.HIDDEN] || {};
+	if (value && expression) insetDep({ expression }, (res) => {
+		widget.props.hidden = !!res;
+	});
+	const { value: required_value, expression: required_expression } = configDependency[Dependency_ENUM.REQUIRED] || {};
+	if (required_value && required_expression) insetDep({ expression: required_expression }, (res) => {
+		widget.props.required = !!res;
+	});
+}
+//#endregion
+export { dependencyToShow, dependencyToShowSync, tableWidgetByDept, tableWidgetToShow, useDependencyToShow, useDependencyToShowList };

package/es/Event/baseEvent.d.ts

@@ -0,0 +1,156 @@
+import { ProcessOperateRequest } from '@gct-paas/api/apaas';
+import { pageLayoutModeEnum } from '@gct-paas/core';
+import { LowCodeWidget } from '@gct-paas/schema';
+import { ComponentPublicInstance, Ref } from 'vue';
+import { $httpBizService, $request } from './bizServiceRequest';
+import { EventsConstructor, FunctionType, InitNodeOptions } from './eventType';
+import { ProcessAppRovedData } from './utils/processRovedInfo';
+type ContextConstructor<T extends Context> = new (args: {
+    $ref: (key: string) => GctComponent | undefined;
+    $asyncRef: (key: string) => Promise<GctComponent>;
+}) => T;
+export type ModalInstance = null | undefined | (ComponentPublicInstance & {
+    open: Fn;
+    close: Fn;
+});
+export declare class Events<TContext extends Context = Context> {
+    #private;
+    context: TContext;
+    searchVNodes: Record<string, {
+        callback: FunctionType;
+        comId: string;
+    }[]>;
+    cssData?: {
+        css: Ref<string>;
+        load: FunctionType;
+        unload: FunctionType;
+    };
+    pageKey?: string;
+    exports: Record<string, FunctionType>;
+    /**流程信息 */
+    ProcessAppRoved?: ProcessAppRovedData;
+    pageLayoutMode?: pageLayoutModeEnum;
+    constructor({ js, css, pageKey, ContextVm, }: EventsConstructor & {
+        ContextVm: ContextConstructor<TContext>;
+    });
+    /**初始化流程节点信息 */
+    runProcessBySaskId({ taskId, processInstanceId, examineAndApproveState, refFormId, }: IObject): Promise<void>;
+    /**保存所有组件的props*/
+    runContext(key: string, widget: LowCodeWidget.BasicSchema): void;
+    /**触发内置事件 */
+    runEventByName(eventName: string, events?: Record<string, IObject>, ...arg: unknown[]): Promise<unknown>;
+    /**执行公共函数事件 */
+    runExportByName(eventName: string, ...arg: unknown[]): Promise<unknown>;
+    /**异步执行公共函数事件 */
+    runAsyncExportByName(eventName: string, ...arg: unknown[]): Promise<unknown>;
+    initNode(key: string, options: InitNodeOptions): void;
+    /**组件销毁 */
+    destroyNode(key: string): void;
+    initSearchs(key: string, callback: FunctionType, comId: string): void;
+    cancelInitSearchs(key: string, comId: string): void;
+    runTableBySearch(key: string, data: IObject): void;
+    /**
+     * 获取组件公用方法 getComponent(identity),根据组件唯一标识获取组件。
+     * @param {*} key
+     * @returns
+     */
+    getComponent(key: string): GctComponent | undefined;
+    /**
+     * 获取组件公用方法 getComponent(identity),根据组件唯一标识获取组件。
+     * @param {*} key
+     * @returns
+     */
+    getSyncComponent(key?: string): Promise<GctComponent>;
+    /**
+     * 指定函数中使用到的组件初始化后才执行
+     * @param fun
+     * @returns
+     */
+    getReadyByFun(fun?: FunctionType): Promise<undefined>;
+    /**
+     * 流程处理
+     * @param processDateValue
+     * @param data
+     */
+    processHandle(data: IObject, { opinion, reassignId, signature, countersignUserIds, button, }: ProcessOperateRequest): Promise<void>;
+    /**流程审批校验 */
+    checkedProcess(formProcessId: string): Promise<undefined>;
+}
+/**作用域 上下文 */
+export declare class Context {
+    /**根据key获取当前组件 */
+    $ref: (key: string) => GctComponent;
+    /**根据key异步获取获取组件 */
+    $asyncRef: (key: string) => Promise<GctComponent>;
+    /**根据id获取模态框 */
+    $getModal?: (key: string) => ModalInstance;
+    /**关闭当前上下文模态框 */
+    $closeModal?: () => void;
+    /**调用第三方服务 */
+    $customBizService: {
+        post: (path: import('./bizServiceRequest').PathType, query?: IObject, data?: IObject, config?: import('axios').AxiosRequestConfig) => Promise<unknown>;
+        get: (path: import('./bizServiceRequest').PathType, query?: IObject, data?: IObject, config?: import('axios').AxiosRequestConfig) => Promise<unknown>;
+        put: (path: import('./bizServiceRequest').PathType, query?: IObject, data?: IObject, config?: import('axios').AxiosRequestConfig) => Promise<unknown>;
+        delete: (path: import('./bizServiceRequest').PathType, query?: IObject, data?: IObject, config?: import('axios').AxiosRequestConfig) => Promise<unknown>;
+    };
+    /**组件id和widget 的map */
+    gctWidgets: Record<string, LowCodeWidget.BasicSchema>;
+    constructor({ $ref, $asyncRef }: IObject);
+    /**ctx 下的工具函数 */
+    readonly $utility: IObject;
+    $httpBizService: typeof $httpBizService;
+    $request: typeof $request;
+    /**全局loading */
+    $loading: {
+        mask: HTMLDivElement;
+        container: HTMLDivElement;
+        spinner: HTMLDivElement;
+        createLoadingElement(): void;
+        initStyle(): void;
+        show(): void;
+        hide(): void;
+    };
+    $getPremission(id: string): boolean;
+    /**
+     *
+     * @param key 组件权限标识
+     * @param id 组件id
+     */
+    $setPremission(key: string, id: string): void;
+    /**获取应用全局变量 */
+    $getAppGlobalVar(id: string): any;
+    /**设置应用全局变量 */
+    $setAppGlobalVar(id: string, value: string): void;
+    /**获取页面全局变量老版本兼容问题暂时不删除 后续不维护*/
+    $getPageGlobalVar(id: string): any;
+    /**设置页面变量老版本 兼容问题暂时不删除 后续不维护 */
+    $setPageGlobalVar(id: string, value: string): void;
+    /**获取页面全局变量 */
+    $getPageVar(id: string): any;
+    /**设置页面全局变量 */
+    $setPageVar(id: string, value: string): void;
+    /**根据模态框id 获取上下文 id不传默认页面上下文*/
+    $getCtxById(modalKey?: string): any;
+    /**设置组件的属性 */
+    $setPropsByKey(key: string, fromProp: LowCodeWidget.BasicSchema['props']): void;
+    /**获取组件的属性 */
+    $getPropsByKey(key: string, PropsKey?: string | string[], root?: boolean): IObject;
+}
+/**
+ * 获取组件实例公用方法
+ */
+export declare class GctComponent {
+    modelKey?: string;
+    getValue?: () => {
+        id?: string;
+        [key: string]: string | [] | undefined;
+    };
+    setValue?: FunctionType;
+    /**提交 */
+    submit?: FunctionType;
+    /**刷新 */
+    reload?: FunctionType;
+    key: string;
+    constructor(key: string, options: InitNodeOptions);
+}
+export {};

package/es/Event/baseEvent.mjs

@@ -0,0 +1,389 @@
+import { transformData, transformSourceData } from "../utils/model-transformer.mjs";
+import "../utils/index.mjs";
+import { Globals } from "./utils/runGlobalByPage.mjs";
+import { $httpBizService, $request, BizService } from "./bizServiceRequest.mjs";
+import { globalLoading } from "./utils/globalLoading.mjs";
+import { ProcessAppRovedData } from "./utils/processRovedInfo.mjs";
+import { FormComponents, INNER_EVENT, t } from "@gct-paas/core";
+import dayjs from "dayjs";
+import * as _ from "lodash-es";
+import { cloneDeep, differenceBy } from "lodash-es";
+import BigNumberJS from "bignumber.js";
+import { useStyleTag } from "@vueuse/core";
+import { toRaw } from "vue";
+//#region src/Event/baseEvent.ts
+var Events = class {
+	context;
+	searchVNodes;
+	cssData;
+	pageKey;
+	exports;
+	#Oberver;
+	#VNodes;
+	/**流程信息 */
+	ProcessAppRoved;
+	pageLayoutMode;
+	constructor({ js, css, pageKey, ContextVm }) {
+		this.cssData = this.#createCss(css);
+		/**
+		* 绑定外部搜索的表格组件
+		*/
+		this.searchVNodes = {};
+		/**
+		* 存放所有公共事件函数
+		*/
+		this.exports = {};
+		/**
+		* 当前页面所有组件key和事件对象
+		*/
+		this.#VNodes = {};
+		/**
+		* 组件订阅中心
+		*/
+		this.#Oberver = {};
+		this.context = new ContextVm({
+			$ref: this.getComponent.bind(this),
+			$asyncRef: this.getSyncComponent.bind(this)
+		});
+		this.#createFunction(js);
+		Globals.setContextByKey(this.context, pageKey);
+		this.pageKey = pageKey;
+	}
+	/**初始化流程节点信息 */
+	async runProcessBySaskId({ taskId, processInstanceId, examineAndApproveState, refFormId }) {
+		this.ProcessAppRoved = new ProcessAppRovedData({
+			taskId,
+			processInstanceId,
+			examineAndApproveState,
+			refFormId
+		});
+		await this.ProcessAppRoved.readyProcess();
+	}
+	#createCss(str, attr = {}) {
+		if (!str) return;
+		const { css, load, unload } = useStyleTag(str, attr);
+		return {
+			css,
+			load,
+			unload
+		};
+	}
+	/**保存所有组件的props*/
+	runContext(key, widget) {
+		this.context.gctWidgets[key] = widget;
+	}
+	/**触发内置事件 */
+	async runEventByName(eventName, events = {}, ...arg) {
+		const E = events[eventName];
+		let data;
+		if (!E) return;
+		if (Array.isArray(E)) data = await builtInEvents(E, this.context, arg);
+		else {
+			const fun = this.exports[E.name];
+			if (!fun) throw `函数${E.name}不存在`;
+			data = await fun(...arg, toRaw(E.extraParams));
+		}
+		return data;
+	}
+	/**执行公共函数事件 */
+	async runExportByName(eventName, ...arg) {
+		try {
+			const fun = this.exports[eventName];
+			if (!fun) throw `函数${eventName}不存在`;
+			return fun(...arg);
+		} catch (error) {
+			console.error(error);
+		}
+	}
+	/**异步执行公共函数事件 */
+	async runAsyncExportByName(eventName, ...arg) {
+		try {
+			const fun = this.exports[eventName];
+			if (!fun) throw `函数${eventName}不存在`;
+			await this.getReadyByFun(fun);
+			return fun(...arg);
+		} catch (error) {
+			console.error(error);
+		}
+	}
+	#createFunction(jsJSON) {
+		if (!jsJSON) return;
+		try {
+			new Function("exports", "CTX", jsJSON)(this.exports, this.context);
+		} catch (error) {
+			console.error(error, "createFunction");
+		}
+	}
+	initNode(key, options) {
+		if (key) {
+			this.#VNodes[key] = options;
+			this.#publish(key, options);
+		}
+	}
+	/**组件销毁 */
+	destroyNode(key) {
+		delete this.#VNodes[key];
+		delete this.#Oberver[key];
+	}
+	initSearchs(key, callback, comId) {
+		if (!key) return;
+		if (this.searchVNodes[key]) {
+			/**添加 comId 组件标识 处理显隐藏控制引起的 重复注册回调函数的问题*/
+			const item = this.searchVNodes[key].find((i) => i.comId === comId);
+			if (item) item.callback = callback;
+			else this.searchVNodes[key].push({
+				callback,
+				comId
+			});
+		} else this.searchVNodes[key] = [{
+			callback,
+			comId
+		}];
+	}
+	cancelInitSearchs(key, comId) {
+		if (!key || !this.searchVNodes[key]) return;
+		this.searchVNodes[key] = this.searchVNodes[key].filter((i) => i.comId !== comId);
+		if (this.searchVNodes[key].length === 0) delete this.searchVNodes[key];
+	}
+	runTableBySearch(key, data) {
+		(this.searchVNodes[key] || []).forEach(({ callback }) => callback(data));
+	}
+	/**
+	* 组件初始化订阅
+	* @param {*} key 组件唯一key
+	* @param {*} eventName  事件名称
+	*/
+	#subscribeready(key, callback) {
+		const options = this.#VNodes[key];
+		if (options) callback(key, options);
+		else if (this.#Oberver[key]) this.#Oberver[key].push(callback);
+		else this.#Oberver[key] = [callback];
+	}
+	/**
+	*
+	* @param key 执行回调
+	*/
+	#publish(key, options) {
+		if (this.#Oberver[key]) this.#Oberver[key].forEach((fun) => {
+			fun(options);
+		});
+	}
+	/**
+	* 获取组件公用方法 getComponent(identity),根据组件唯一标识获取组件。
+	* @param {*} key
+	* @returns
+	*/
+	getComponent(key) {
+		const options = this.#VNodes[key];
+		if (options) return new GctComponent(key, options);
+		console.error(key + "组件不存在或者未初始化");
+	}
+	/**
+	* 获取组件公用方法 getComponent(identity),根据组件唯一标识获取组件。
+	* @param {*} key
+	* @returns
+	*/
+	getSyncComponent(key) {
+		if (!key) return Promise.reject("标识不能为空");
+		const options = this.#VNodes[key];
+		if (options) return Promise.resolve(new GctComponent(key, options));
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				reject(key + "不存在或者被隐藏");
+			}, 3e4);
+			this.#subscribeready(key, (options) => {
+				clearTimeout(timer);
+				resolve(new GctComponent(key, options));
+			});
+		});
+	}
+	/**
+	* 指定函数中使用到的组件初始化后才执行
+	* @param fun
+	* @returns
+	*/
+	async getReadyByFun(fun) {
+		if (typeof fun !== "function") return Promise.reject("参数必须是函数");
+		const P = String(fun).match(/\$ref\((["'A-Za-z0-9_-]+)\)/g)?.map((i) => {
+			const key = i.match(/\$ref\(['|"]([A-Za-z0-9_-]+)['|"]\)/)?.[1];
+			return this.getSyncComponent(key);
+		}) || [];
+		await Promise.all(P);
+	}
+	/**
+	* 流程处理
+	* @param processDateValue
+	* @param data
+	*/
+	async processHandle(data, { opinion, reassignId, signature, countersignUserIds, button }) {
+		const { taskId, processInstanceId } = this.ProcessAppRoved;
+		const processData = {
+			procInstId: processInstanceId,
+			data,
+			opinion,
+			button,
+			countersignUserIds,
+			taskId,
+			signature,
+			reassignId
+		};
+		await _gct.api.apaas.pmProcessEngine.postProcExecute(processData);
+	}
+	/**流程审批校验 */
+	async checkedProcess(formProcessId) {
+		const { processId } = this.ProcessAppRoved || {};
+		if (!processId) return Promise.reject(t("sys.process.pleaseInitiateTheProcessFirst"));
+		if (formProcessId !== processId) return Promise.reject(t("sys.process.processInstanceMismatch"));
+	}
+};
+/**作用域 上下文 */
+var Context = class {
+	/**根据key获取当前组件 */
+	$ref;
+	/**根据key异步获取获取组件 */
+	$asyncRef;
+	/**根据id获取模态框 */
+	$getModal;
+	/**关闭当前上下文模态框 */
+	$closeModal;
+	/**调用第三方服务 */
+	$customBizService = BizService;
+	/**组件id和widget 的map */
+	gctWidgets = {};
+	constructor({ $ref, $asyncRef }) {
+		this.$asyncRef = $asyncRef;
+		this.$ref = $ref;
+	}
+	/**ctx 下的工具函数 */
+	$utility = {
+		_,
+		cloneDeep,
+		differenceBy,
+		dayjs,
+		BigNumber: BigNumberJS,
+		plus(a, b) {
+			return new BigNumberJS(a).plus(new BigNumberJS(b)).toNumber();
+		},
+		minus(a, b) {
+			return new BigNumberJS(a).minus(new BigNumberJS(b)).toNumber();
+		},
+		multipliedBy(a, b) {
+			return new BigNumberJS(a).multipliedBy(new BigNumberJS(b)).toNumber();
+		},
+		div(a, b) {
+			return new BigNumberJS(a).div(new BigNumberJS(b)).toNumber();
+		},
+		transformSourceData,
+		transformData
+	};
+	$httpBizService = $httpBizService;
+	$request = $request;
+	/**全局loading */
+	$loading = globalLoading;
+	$getPremission(id) {
+		return Globals.getPremission(id);
+	}
+	/**
+	*
+	* @param key 组件权限标识
+	* @param id 组件id
+	*/
+	$setPremission(key, id) {
+		Globals.setPremission(key, id);
+	}
+	/**获取应用全局变量 */
+	$getAppGlobalVar(id) {
+		return Globals.getGlobalVar(id);
+	}
+	/**设置应用全局变量 */
+	$setAppGlobalVar(id, value) {
+		Globals.setGlobalVar(id, value);
+	}
+	/**获取页面全局变量老版本兼容问题暂时不删除 后续不维护*/
+	$getPageGlobalVar(id) {
+		return Globals.getPageGlobalVar(id);
+	}
+	/**设置页面变量老版本 兼容问题暂时不删除 后续不维护 */
+	$setPageGlobalVar(id, value) {
+		Globals.setPageGlobalVar(id, value);
+	}
+	/**获取页面全局变量 */
+	$getPageVar(id) {
+		return Globals.getPageVar(id);
+	}
+	/**设置页面全局变量 */
+	$setPageVar(id, value) {
+		Globals.setPageVar(id, value);
+	}
+	/**根据模态框id 获取上下文 id不传默认页面上下文*/
+	$getCtxById(modalKey) {
+		return Globals.getContextByKey(modalKey);
+	}
+	/**设置组件的属性 */
+	$setPropsByKey(key, fromProp) {
+		const toProps = this.gctWidgets[key]?.props;
+		if (!toProps) return;
+		for (const k in fromProp) toProps[k] = fromProp[k];
+	}
+	/**获取组件的属性 */
+	$getPropsByKey(key, PropsKey = [], root) {
+		const widget = this.gctWidgets[key];
+		if (!widget) return {};
+		const props = root || !widget.props ? widget : widget.props;
+		if (typeof PropsKey === "string") PropsKey = [PropsKey];
+		return PropsKey.reduce((pre, curr) => {
+			pre[curr] = props[curr];
+			return pre;
+		}, {});
+	}
+};
+/**
+* 获取组件实例公用方法
+*/
+var GctComponent = class {
+	modelKey;
+	getValue;
+	setValue;
+	/**提交 */
+	submit;
+	/**刷新 */
+	reload;
+	key;
+	constructor(key, options) {
+		this.key = key;
+		const elRef = options.elRef;
+		Object.keys(elRef).forEach((k) => {
+			this[k] = elRef[k];
+		});
+	}
+};
+/**
+* 执行内置事件
+* @param eventList
+*/
+async function builtInEvents(eventList, context, args) {
+	const allEvent = eventList.map(transformEventFun.bind(context, args));
+	await Promise.all(allEvent);
+}
+async function transformEventFun(args, item) {
+	const { name, refId, scopeId, modalTitle } = item;
+	const ids = modalTitle?.split(".") || [];
+	let widget;
+	if (ids.length > 1) {
+		const orgWidget = this.gctWidgets?.[ids[0]] || {};
+		const opes = [];
+		getAllOpe(opes, orgWidget);
+		widget = opes.find((i) => i.id === ids[1]) || {};
+	} else if (ids.length) widget = this.gctWidgets?.[ids[0]];
+	if (name === INNER_EVENT.OPEN_MODAL) await this.$getModal(refId).open({ title: widget?.props?.title });
+	if (name === INNER_EVENT.CLOSE_MODAL) if (refId) await this.$getModal(refId).close();
+	else await this.$closeModal();
+	if (name === INNER_EVENT.REFRESH_TABLE) await (await this.$getCtxById(scopeId).$asyncRef(refId)).reload(args ? args[0] : null);
+}
+function getAllOpe(arr, widget) {
+	const children = widget.children || [];
+	for (const i of children) if (i.type && i.type == FormComponents.CustomButton) arr.push(i);
+	else if (i.children?.length) getAllOpe(arr, i);
+}
+//#endregion
+export { Context, Events, GctComponent };

package/es/Event/bizServiceRequest.d.ts

@@ -0,0 +1,26 @@
+import { BizServiceEnum, EntityModelCategoryEnum } from '@gct-paas/core';
+import { AxiosRequestConfig } from 'axios';
+export declare const BizService: {
+    post: (path: PathType, query?: IObject, data?: IObject, config?: AxiosRequestConfig) => Promise<unknown>;
+    get: (path: PathType, query?: IObject, data?: IObject, config?: AxiosRequestConfig) => Promise<unknown>;
+    put: (path: PathType, query?: IObject, data?: IObject, config?: AxiosRequestConfig) => Promise<unknown>;
+    delete: (path: PathType, query?: IObject, data?: IObject, config?: AxiosRequestConfig) => Promise<unknown>;
+};
+/**
+ * 系统内置业务服务请求
+ * @param path
+ * @param params
+ * @param config
+ * @returns
+ */
+export declare function $httpBizService(path: PathType, params: Record<string, unknown>, ...config: IObject[]): Promise<unknown>;
+/**post 业务服务请求 */
+export declare function $request(modelKey: string, action: PathType['action'], { body, query }?: IObject, config?: AxiosRequestConfig): Promise<unknown>;
+type BizServiceParams = Record<string, unknown>;
+export interface PathType {
+    key: string;
+    action: keyof typeof BizServiceEnum;
+    modelCategory?: EntityModelCategoryEnum;
+}
+export type BizServiceMethod = (path: PathType, params: BizServiceParams, ...args: unknown[]) => Promise<unknown>;
+export {};