@gct-paas/render 0.1.4-dev.10

package/es/Event/Dependency/controller.d.ts

@@ -0,0 +1,13 @@
+/**组件依赖触发器 */
+export declare function insetDep({ expression, rowData, }: {
+    expression?: string;
+    rowData?: IObject | null;
+}, callback: (value: unknown) => void): void;
+/**
+ * 直接计算表达式结果，不进行依赖监控
+ * 用于一次性计算场景，快速获取表达式判断结果
+ */
+export declare function calculateDepResult({ expression, rowData, }: {
+    expression?: string;
+    rowData?: IObject | null;
+}): Promise<true | IObject>;

package/es/Event/Dependency/controller.mjs

@@ -0,0 +1,97 @@
+import { computed } from 'vue';
+import { formMap, globalVarCaches, pageGlobaVariables } from '../utils/runGlobalByPage.mjs';
+import { watchDebounced } from '@vueuse/core';
+import '@gct-paas/core';
+import 'lodash-es';
+import '../../utils/field-attrs/basicAttrs.mjs';
+import '@gct-paas/schema';
+import { identify, calculate } from '../../utils/expression/index.mjs';
+import 'qs';
+
+function insetDep({
+  expression = "",
+  rowData = null
+}, callback) {
+  if (!expression || expression === "true") {
+    callback(true);
+    return;
+  }
+  const identifyArgs = identify(expression);
+  const formCacheMap = identifyArgs.reduce((total, i) => {
+    const arg = i.split(".");
+    total[i] = { formKey: arg[0], itemKey: arg[1] };
+    return total;
+  }, {});
+  const cacheFormFileds = computed(() => {
+    return identifyArgs.reduce((total, i) => {
+      const arg = i.split(".");
+      const formKey = arg[0] + "";
+      const filedKey = arg[1];
+      if (filedKey) {
+        const value = (rowData ? rowData[filedKey] : formMap.value[formKey]?.[filedKey]) ?? "";
+        if (total[formKey]) {
+          total[formKey][filedKey] = value;
+        } else {
+          total[formKey] = { [filedKey]: value };
+        }
+      } else if (formKey.startsWith("$VAR_") || formKey.startsWith("$IVAR_")) {
+        total[formKey] = globalVarCaches.value[formKey]?.value ?? "";
+      } else if (formKey.startsWith("$PAGERVAR_") || formKey.startsWith("$IPAGERVAR_")) {
+        total[formKey] = pageGlobaVariables.value[formKey]?.value ?? "";
+      }
+      return total;
+    }, {});
+  });
+  function playValueByRule(form) {
+    const cache = {};
+    Object.keys(formCacheMap).forEach((k) => {
+      const { formKey, itemKey } = formCacheMap[k];
+      const value = itemKey ? form[formKey]?.[itemKey] : form[formKey];
+      cache[k] = value;
+    });
+    calculate(expression, cache).then(callback);
+  }
+  if (rowData) playValueByRule(cacheFormFileds.value);
+  watchDebounced(
+    cacheFormFileds,
+    () => {
+      playValueByRule(cacheFormFileds.value);
+    },
+    {
+      debounce: 200,
+      immediate: !rowData
+    }
+  );
+}
+async function calculateDepResult({
+  expression = "",
+  rowData = null
+}) {
+  if (!expression || expression === "true") {
+    return true;
+  }
+  const identifyArgs = identify(expression);
+  const formCacheMap = identifyArgs.reduce((total, i) => {
+    const arg = i.split(".");
+    total[i] = { formKey: arg[0], itemKey: arg[1] };
+    return total;
+  }, {});
+  const cache = {};
+  Object.keys(formCacheMap).forEach((k) => {
+    const { formKey, itemKey } = formCacheMap[k];
+    let value = "";
+    if (formKey.startsWith("$VAR_")) {
+      value = globalVarCaches.value[formKey]?.value ?? "";
+    } else if (formKey.startsWith("$PAGERVAR_")) {
+      value = pageGlobaVariables.value[formKey]?.value ?? "";
+    } else if (itemKey) {
+      value = (rowData ? rowData[itemKey] : formMap.value[formKey]?.[itemKey]) ?? "";
+    } else {
+      value = (rowData ? rowData[formKey] : formMap.value[formKey]) ?? "";
+    }
+    cache[k] = value;
+  });
+  return calculate(expression, cache);
+}
+
+export { calculateDepResult, insetDep };

package/es/Event/Dependency/displayRule.d.ts

@@ -0,0 +1,19 @@
+import { DisplayType } from '@gct-paas/core';
+interface DisplayRule {
+    hidden?: boolean;
+    displayType?: DisplayType;
+    displayRule?: string;
+    tableForm?: object;
+    id?: number;
+}
+/**单组件显隐控制 */
+export declare function useVisibileByRuleHook(props: DisplayRule, id: string): false | Readonly<import('vue').Ref<boolean, boolean>>;
+/**
+ * 需要做控制的数组组件
+ * @param optopns 被控制的数组
+ * @param tableForm 需要添加的额外的form {key:object }
+ * @returns
+ */
+export declare function useDisplayRuleOptions(optopns: IObject[], tableForm?: IObject): Readonly<import('vue').Ref<IObject[], IObject[]>>;
+export declare function useDisplayRuleColumnByStyles(optopnslist: IObject[], tableForm?: IObject): Readonly<import('vue').Ref<IObject | undefined, IObject | undefined>> | undefined;
+export {};

package/es/Event/Dependency/displayRule.mjs

@@ -0,0 +1,76 @@
+import { DisplayType } from '@gct-paas/core';
+import 'lodash-es';
+import '../../utils/field-attrs/basicAttrs.mjs';
+import '@gct-paas/schema';
+import { identify, calculate } from '../../utils/expression/index.mjs';
+import 'qs';
+import { toRef, ref } from 'vue';
+import { getPremission, formMap } from '../utils/runGlobalByPage.mjs';
+import { watchDebounced } from '@vueuse/core';
+
+function useVisibileByRuleHook(props, id) {
+  if (!getPremission(id)) {
+    return false;
+  } else if (props.displayType === DisplayType.CONFIG) {
+    return toRef(() => !props.hidden);
+  } else {
+    return useDisplayRule(props);
+  }
+}
+function useDisplayRule(rule) {
+  const formCache = ref(false);
+  getOptionsByDisplayRule(rule, (f) => {
+    formCache.value = !!f;
+  });
+  return formCache;
+}
+function getOptionsByDisplayRule({ displayRule, tableForm }, callback) {
+  if (!displayRule) {
+    callback(true);
+  } else {
+    const identifyArgs = identify(displayRule);
+    const formCacheMap = identifyArgs.reduce((total, i) => {
+      const arg = i.split(".");
+      total[i] = { formKey: arg[0], itemKey: arg[1] };
+      return total;
+    }, {});
+    const cacheFormFileds = toRef(() => {
+      return identifyArgs.reduce((total, i) => {
+        const arg = i.split(".");
+        const formKey = arg[0] + "", filedKey = arg[1] + "";
+        const value = { ...tableForm, ...formMap.value }[formKey]?.[filedKey];
+        if (total[formKey]) {
+          total[formKey][filedKey] = value;
+        } else {
+          total[formKey] = { [filedKey]: value };
+        }
+        return total;
+      }, {});
+    });
+    watchDebounced(
+      cacheFormFileds,
+      () => {
+        playValueByRule(
+          cacheFormFileds.value,
+          formCacheMap,
+          displayRule,
+          (flag) => {
+            callback(flag);
+          }
+        );
+      },
+      { immediate: true, debounce: 300 }
+    );
+  }
+}
+function playValueByRule(form, formCacheMap, displayRule, callback) {
+  const cache = {};
+  Object.keys(formCacheMap).forEach((k) => {
+    const { formKey, itemKey } = formCacheMap[k];
+    const value = form?.[formKey]?.[itemKey];
+    cache[k] = value;
+  });
+  calculate(displayRule, cache).then(callback);
+}
+
+export { useVisibileByRuleHook };

package/es/Event/Dependency/useDependency.d.ts

@@ -0,0 +1,7 @@
+import { LowCodeWidget } from '@gct-paas/schema';
+export declare function useDependency(widget: LowCodeWidget.BasicSchema, formState?: IObject, isRow?: boolean): {
+    value: import('vue').WritableComputedRef<any, any>;
+    formRowData: import('vue').ComputedRef<any>;
+    fieldKey: any;
+};
+export declare function useDependencyByRequired(widget: LowCodeWidget.BasicSchema): void;

package/es/Event/Dependency/useDependencyToShow.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+import { LowCodeWidget } from '@gct-paas/schema';
+export declare function useDependencyToShow(widget: LowCodeWidget.BasicSchema): boolean | Readonly<Ref<boolean, boolean>>;
+export declare function dependencyToShow(widget: LowCodeWidget.BasicSchema, rowData?: object): boolean | Ref<boolean>;
+/**直接返回计算结果的依赖显隐逻辑 */
+export declare function dependencyToShowSync(widget: LowCodeWidget.BasicSchema, rowData?: object): Promise<boolean>;
+/**组件集合处理 */
+export declare function useDependencyToShowList<T extends LowCodeWidget.BasicSchema = LowCodeWidget.BasicSchema>(widgetList: T[], rowData?: object): Ref<T[]>;
+export declare function tableWidgetToShow(widget: LowCodeWidget.BasicSchema, callback: (res: unknown) => void): void;
+export declare function tableWidgetByDept(widget: LowCodeWidget.BasicSchema): void;

package/es/Event/Dependency/useDependencyToShow.mjs

@@ -0,0 +1,109 @@
+import { inject, toRef } from 'vue';
+import { getPremission } from '../utils/runGlobalByPage.mjs';
+import { insetDep, calculateDepResult } from './controller.mjs';
+import { useVisibileByRuleHook } from './displayRule.mjs';
+import { Dependency_ENUM, DisplayType } from '@gct-paas/core';
+
+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)) {
+    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 configDependency = widget.props.componentDependency?.configDependency || {};
+  const { value, expression } = 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)) {
+    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 configDependency = widget.props.componentDependency?.configDependency || {};
+  const { value, expression } = 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 configDependency = widget.props.componentDependency?.configDependency || {};
+  const { value, expression } = 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;
+    });
+  }
+}
+
+export { dependencyToShow, dependencyToShowSync, tableWidgetByDept, tableWidgetToShow, useDependencyToShow, useDependencyToShowList };

package/es/Event/baseEvent.d.ts

@@ -0,0 +1,155 @@
+import { ProcessOperateRequest } from '@gct-paas/api/apaas';
+import { pageLayoutModeEnum } from '@gct-paas/core';
+import { LowCodeWidget } from '@gct-paas/schema';
+import { 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 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, ContextPc, }: EventsConstructor & {
+        ContextPc: 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) => {
+        open: FunctionType;
+        close: FunctionType;
+    };
+    /**关闭当前上下文模态框 */
+    $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 {};