@gct-paas/render 0.1.4-dev.10

package/es/hooks/useStorageRef.d.ts

@@ -0,0 +1,9 @@
+/**
+ * app全局缓存
+ * @param key  aid_userId
+ * @returns
+ */
+export declare const useGctSelect: (key: string) => {
+    selectID: import('vue').WritableComputedRef<string, string>;
+    cacheMap: import('vue').WritableComputedRef<IObject, IObject>;
+};

package/es/hooks/useStorageRef.mjs

@@ -0,0 +1,33 @@
+import { useLocalStorage } from '@vueuse/core';
+import { GlobalParamEnum } from '../enums/index.mjs';
+import { computed } from 'vue';
+
+const GCT_SELECT_ID = useLocalStorage("GCT_APP_GlobalCache", {});
+const useGctSelect = (key) => {
+  const cacheMap = computed({
+    get() {
+      return GCT_SELECT_ID.value[key] || {};
+    },
+    set(value) {
+      GCT_SELECT_ID.value[key] = value;
+    }
+  });
+  const selectID = computed({
+    get() {
+      return cacheMap.value[GlobalParamEnum.SELECT_ID];
+    },
+    set(value) {
+      if (cacheMap.value[GlobalParamEnum.SELECT_ID]) {
+        cacheMap.value[GlobalParamEnum.SELECT_ID] = value;
+      } else {
+        cacheMap.value = {
+          ...cacheMap.value,
+          [GlobalParamEnum.SELECT_ID]: value
+        };
+      }
+    }
+  });
+  return { selectID, cacheMap };
+};
+
+export { useGctSelect };

package/es/index.d.ts

@@ -0,0 +1,3 @@
+export * from './utils';
+export * from './Event';
+export declare function onInit(): void;

package/es/index.mjs

@@ -0,0 +1,23 @@
+import { RenderRegister } from './register/render-register/render-register.mjs';
+export { transformPropsField } from './utils/field-attrs/index.mjs';
+export { useStyle } from './utils/useStyle.mjs';
+export { FieldSchema, initFieldWidgetRuntime } from './utils/getFieldSchema.mjs';
+export { addDataByForm, setDataByForm, transSelectData, transformData, transformDataToDict, transformSourceData } from './utils/model-transformer.mjs';
+export { calculate, identify } from './utils/expression/index.mjs';
+export { getRefInfoId } from './utils/get-ref-data.mjs';
+export { Globals, formMap, getPageTitle, getPremission, globalVarCaches, pageDataforJson, pageGlobaVariables, setFormData } from './Event/utils/runGlobalByPage.mjs';
+export { Context, Events, GctComponent } from './Event/baseEvent.mjs';
+import '@gct-paas/core';
+export { dependencyToShow, dependencyToShowSync, tableWidgetByDept, tableWidgetToShow, useDependencyToShow, useDependencyToShowList } from './Event/Dependency/useDependencyToShow.mjs';
+
+function onInit() {
+  if (!_gct.register.render) {
+    _gct.register.render = new RenderRegister();
+  } else {
+    console.warn(
+      "渲染注册已存在，可能存在重复注册问题，请检查是否有重复引入渲染包的情况"
+    );
+  }
+}
+
+export { onInit };

package/es/register/index.d.ts

@@ -0,0 +1 @@
+export { RenderRegister } from './render-register/render-register';

package/es/register/render-register/render-register.d.ts

@@ -0,0 +1,54 @@
+import { Component } from 'vue';
+/**
+ * 绘制组件注册
+ *
+ * @author zhanghanrui
+ * @date 2024-05-25 08:05:52
+ * @export
+ * @class RenderRegister
+ */
+export declare class RenderRegister {
+    /**
+     * 组件清单
+     *
+     * @author zhanghanrui
+     * @date 2024-05-25 08:05:03
+     * @protected
+     * @type {Map<string, Component>}
+     */
+    protected map: Map<string, Component>;
+    /**
+     * 注册界面绘制组件
+     *
+     * @author zhanghanrui
+     * @date 2024-05-25 08:05:05
+     * @param {string} tag
+     * @param {Component} com
+     */
+    register(tag: string, com: Component): void;
+    /**
+     * 取消组件注册
+     *
+     * @author zhanghanrui
+     * @date 2024-05-25 08:05:34
+     * @param {string} tag
+     */
+    unregister(tag: string): void;
+    /**
+     * 获取注册的组件
+     *
+     * @author zhanghanrui
+     * @date 2024-05-25 08:05:59
+     * @param {string} tag
+     * @return {*}  {(Component | undefined)}
+     */
+    get(tag: string): Component | undefined;
+    /**
+     * 组件标识清单
+     *
+     * @author zhanghanrui
+     * @date 2024-05-25 08:05:19
+     * @return {*}  {string[]}
+     */
+    keys(): string[];
+}

package/es/register/render-register/render-register.mjs

@@ -0,0 +1,59 @@
+class RenderRegister {
+  /**
+   * 组件清单
+   *
+   * @author zhanghanrui
+   * @date 2024-05-25 08:05:03
+   * @protected
+   * @type {Map<string, Component>}
+   */
+  map = /* @__PURE__ */ new Map();
+  // readonly hooks = {
+  //   register: new SyncSeriesHook<[string, Component]>(),
+  //   unregister: new SyncSeriesHook<string>(),
+  // };
+  /**
+   * 注册界面绘制组件
+   *
+   * @author zhanghanrui
+   * @date 2024-05-25 08:05:05
+   * @param {string} tag
+   * @param {Component} com
+   */
+  register(tag, com) {
+    this.map.set(tag, com);
+  }
+  /**
+   * 取消组件注册
+   *
+   * @author zhanghanrui
+   * @date 2024-05-25 08:05:34
+   * @param {string} tag
+   */
+  unregister(tag) {
+    this.map.delete(tag);
+  }
+  /**
+   * 获取注册的组件
+   *
+   * @author zhanghanrui
+   * @date 2024-05-25 08:05:59
+   * @param {string} tag
+   * @return {*}  {(Component | undefined)}
+   */
+  get(tag) {
+    return this.map.get(tag);
+  }
+  /**
+   * 组件标识清单
+   *
+   * @author zhanghanrui
+   * @date 2024-05-25 08:05:19
+   * @return {*}  {string[]}
+   */
+  keys() {
+    return Array.from(this.map.keys());
+  }
+}
+
+export { RenderRegister };

package/es/types/index.d.ts

@@ -0,0 +1,7 @@
+import '@gct-paas/core/types';
+import type { RenderRegister } from '../register';
+declare module '@gct-paas/core' {
+  interface IGlobalRegister {
+    render: RenderRegister;
+  }
+}

package/es/utils/cacheAdapter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 请求缓存
+ * @param args
+ * @param adapter
+ * @returns
+ */
+export declare function cacheAdapter(args: IObject, adapter: (p: IObject) => Promise<unknown>, noneCache?: boolean): any;

package/es/utils/cacheAdapter.mjs

@@ -0,0 +1,57 @@
+import qs from 'qs';
+
+function cacheAdapter(args, adapter, noneCache = false) {
+  if (noneCache || args?.customApi?.value) return adapter(args);
+  const maxAge = 5e3;
+  const requestKey = typeof args === "object" ? qs.stringify({ ...args, customApi: null }) : args;
+  let responsePromise = MemoryCache.get(requestKey);
+  if (!responsePromise) {
+    responsePromise = (async () => {
+      try {
+        return await adapter(args);
+      } catch (reason) {
+        MemoryCache.delete(requestKey);
+        throw reason;
+      }
+    })();
+    MemoryCache.set(requestKey, responsePromise, maxAge);
+    return responsePromise;
+  }
+  return responsePromise;
+}
+class MemoryCache {
+  static cachedata = {};
+  static set(key, value, maxAge) {
+    this.cachedata[key] = {
+      maxAge: maxAge || 0,
+      value,
+      now: Date.now()
+    };
+  }
+  static get(key) {
+    this.reset();
+    const cachedItem = this.cachedata[key];
+    if (!cachedItem) return null;
+    return cachedItem.value;
+  }
+  static delete(key) {
+    return delete this.cachedata[key];
+  }
+  static clear() {
+    this.cachedata = {};
+  }
+  /**
+   *清空过期的数据
+   */
+  static reset() {
+    for (const key in this.cachedata) {
+      const cachedItem = this.cachedata[key];
+      if (cachedItem) {
+        const isExpired = Date.now() - cachedItem.now > cachedItem.maxAge;
+        if (isExpired) this.delete(key);
+      }
+    }
+  }
+}
+
+export { cacheAdapter };

package/es/utils/expression/index.d.ts

@@ -0,0 +1,6 @@
+import { UseMemoizeReturn } from '@vueuse/core';
+export declare const identify: UseMemoizeReturn<string[], [expr: string, isAll?: boolean | undefined]>;
+export declare const calculate: UseMemoizeReturn<Promise<IObject>, [
+    expr: string,
+    values: IObject
+]>;

package/es/utils/expression/index.mjs

@@ -0,0 +1,133 @@
+import * as methods from './regularExpression/methods.mjs';
+import * as esprima from 'esprima-next';
+import estraverse from 'estraverse';
+import { innerVarIds, SYSTEM_VAR_PREFIX, operator2FuncMap, functionMap } from '@gct-paas/core';
+import { useMemoize } from '@vueuse/core';
+
+window._METHOD_DEBUG_ = methods;
+const identify = useMemoize(_identify);
+const calculate = useMemoize(_calc);
+function _deepCalcName(node) {
+  if (node.type === esprima.Syntax.MemberExpression) {
+    return `${node.object.type === esprima.Syntax.MemberExpression ? _deepCalcName(node.object) : node.object.name}.${node.property.name}`;
+  } else if (node.type === esprima.Syntax.Identifier) {
+    return node.name;
+  }
+  return "";
+}
+const AsyncFunction = Object.getPrototypeOf(async function() {
+  return;
+}).constructor;
+async function _getSystemVarValue(ids) {
+  let res = [];
+  if (ids.length > 0) {
+    res = await _gct.api.apaas.systemVar.getGetVarByKeys({
+      keys: ids.join(",")
+    });
+  }
+  return res;
+}
+const getSystemVarValue = useMemoize(_getSystemVarValue);
+async function _calc(expr, values) {
+  const ids = identify(expr, true);
+  const innerIds = ids.filter((id) => innerVarIds.includes(id)).sort();
+  const systemIds = ids.filter((id) => id.startsWith(SYSTEM_VAR_PREFIX)).sort();
+  const systemValues = await getSystemVarValue([...innerIds, ...systemIds]);
+  const ast = esprima.parse(expr);
+  estraverse.replace(ast, {
+    enter(node) {
+      if (node.type === esprima.Syntax.BinaryExpression) {
+        const { operator } = node;
+        const fnName = operator2FuncMap[operator];
+        if (!fnName) {
+          return node;
+        }
+        return {
+          type: esprima.Syntax.CallExpression,
+          arguments: [node.left, node.right],
+          callee: {
+            type: esprima.Syntax.Identifier,
+            name: fnName
+          },
+          optional: false
+        };
+      }
+      return node;
+    }
+  });
+  estraverse.traverse(ast, {
+    enter: function(node) {
+      if (node.type === esprima.Syntax.CallExpression && node.callee.type === esprima.Syntax.Identifier) {
+        node.callee.name = `await Methods.${node.callee.name}`;
+      }
+    }
+  });
+  const runjs = "";
+  const objNames = {};
+  const defs = [];
+  systemValues.forEach((item) => {
+    defs.push(`const ${item.key} = ${JSON.stringify(item.value)};`);
+  });
+  Object.keys(values).map((key) => {
+    if (key.includes(".")) {
+      const [obj = "", property] = key.split(".");
+      if (!objNames[obj]) {
+        defs.push(`const ${obj} = {};`);
+        objNames[obj] = true;
+      }
+      defs.push(`${obj}.${property} = ${JSON.stringify(values[key])};`);
+    } else {
+      defs.push(`const ${key} = ${JSON.stringify(values[key])};`);
+    }
+  });
+  const calcFunc = new AsyncFunction(
+    "Methods",
+    [
+      ...defs,
+      `return new Promise(async(resolve)=>{`,
+      `const res = ${runjs};`,
+      "resolve(res);",
+      "})"
+    ].join("\n")
+  );
+  const result = await calcFunc(methods);
+  console.info("【表达式】", expr);
+  console.info("【参数】", values);
+  console.info("【执行语句】", calcFunc.toString());
+  console.info("【执行结果】", result);
+  return result;
+}
+function _identify(expr, isAll = false) {
+  const ast = esprima.parse(expr);
+  let identifiers = [];
+  estraverse.traverse(ast, {
+    enter: function(node) {
+      if (node.type === esprima.Syntax.MemberExpression) {
+        const name = _deepCalcName(node);
+        identifiers.push(name);
+        Object.assign(node, {
+          name,
+          type: esprima.Syntax.Identifier
+        });
+      } else if (node.type === esprima.Syntax.Identifier) {
+        identifiers.push(node.name);
+      }
+      if (isAll) {
+        identifiers = identifiers.filter(
+          (item) => !functionMap[item] && item !== "undefined"
+        );
+      } else {
+        identifiers = identifiers.filter(
+          (item) => !functionMap[item] && item !== "undefined" && !innerVarIds.includes(item) && !item.startsWith(SYSTEM_VAR_PREFIX) && !item.startsWith("undefined.")
+        );
+      }
+    }
+  });
+  return [...new Set(identifiers)];
+}
+window.gct_expression = {
+  execute: calculate,
+  identify
+};
+
+export { calculate, identify };

package/es/utils/expression/regularExpression/methods.d.ts

@@ -0,0 +1,77 @@
+import { default as dayjs } from 'dayjs';
+declare function IF<T>(expr: boolean, v: T, l: T): T;
+declare function ISEMPTY<T>(v: T): boolean;
+declare function ISNULL<T>(v: T): boolean;
+declare function ISUNDEFINED<T>(v: T): boolean;
+declare function AND<T>(...e: T[]): boolean;
+declare function OR<T>(...e: T[]): boolean;
+declare function EQ<T, K>(v: T, o: K): boolean;
+declare function NE<T>(v: T, o: T): boolean;
+declare function LE<T>(v: T, o: T): boolean;
+declare function LT<T>(v: T, o: T): boolean;
+declare function GE<T>(v: T, o: T): boolean;
+declare function GT<T>(v: T, o: T): boolean;
+declare function LEN(v?: string): number;
+declare function CONCAT(...args: string[]): string;
+declare function SUBSTRING(v: string | undefined, s: number, e: number): string;
+declare function SUBSTR(v: string | undefined, s: number, l: number): string;
+declare function UPPER(v?: string): string;
+declare function LOWER(v?: string): string;
+declare function TRIM(v?: string): string;
+declare function LTRIM(v?: string): string;
+declare function RTRIM(v?: string): string;
+declare function REPEAT(v?: string, c?: string): number | null;
+declare function REPLACE(v?: string, o?: string, t?: string): string;
+declare function FINDSTR(v?: string, c?: string): boolean;
+declare function SEARCHSTR(v?: string, c?: string): number;
+declare function PARSENUMBER(v?: string): number | null;
+declare function SPLIT(v?: string, c?: string): string[];
+declare function SUM(...args: (number | string)[]): number | string;
+declare function ADD(...args: number[]): number | string;
+declare function REDUCE(v: number, ...args: number[]): number | string;
+declare function MULTIPLICATION(val: number | string, ...args: (number | string)[]): number | string;
+declare function DIVISION(v: number | string, ...args: (number | string)[]): number | string;
+declare function FIXED(v: number, n: number): string | undefined;
+declare function ROUND(v: number | string, n: number): number | string;
+declare function ROUNDUP(v: number | string, n: number): number | '';
+declare function MAX(...args: (number | '')[]): number | string;
+declare function LARGE(v: number[], n: number): number | undefined;
+declare function MIN(...args: (number | '')[]): number | '';
+declare function SMALL(v: number[], n: number): number | undefined;
+declare function AVERAGE(...args: (number | '')[]): number | '';
+declare function ABS(v: number): number;
+declare function MOD(v: number, n: number): number | string;
+declare function POWER(v: number, n: number): number;
+declare function SQRT(v: number): number;
+declare function GET<T extends object | IObject[]>(v: T, p: number | keyof T): T[keyof T];
+declare function PUT<T extends object>(a: T, b: keyof T, c: unknown): T;
+declare function PUSH<T>(v: T[], n: T): T[];
+declare function HEADPUSH<T>(v: T[], n: T): T[];
+declare function TIMESTAMP2DATE(v: number): string | undefined;
+declare function DATE2TIMESTAMP(v: string): number | undefined;
+declare function DATEFORMAT(v: Date, f: string): string | undefined;
+declare function NOW(): string;
+declare function TODAY(): string;
+declare function YEAR(v: dayjs.ConfigType): number;
+declare function MONTH(v: dayjs.ConfigType): number;
+declare function DAY(v: dayjs.ConfigType): number;
+declare function HOUR(v: dayjs.ConfigType): number;
+declare function MINUTE(v: dayjs.ConfigType): number;
+declare function WEEKRANGE(): [string, string];
+declare function LASTWEEKRANGE(): [string, string];
+declare function MONTHRANGE(): [string, string];
+declare function LASTMONTHRANGE(): [string, string];
+declare function YEARRANGE(): [string, string];
+declare function LASTYEARRANGE(): [string, string];
+declare function QUARTER(): [string, string];
+declare function LASTQUARTER(): [string, string];
+declare function ISDATERANGE(v: Date, r: [Date, Date]): boolean;
+declare function ISTIMERANGE(v: string, r: [string, string]): boolean;
+declare function TUPLE(...args: unknown[]): unknown[];
+declare function SEQMAP<K extends string | number | symbol, V>(...args: (K | V)[]): Record<K, V>;
+declare function SUMSQ(...args: (string | '')[]): number | string;
+/**数组计数 */
+declare function COUNT(v: number[]): number | '';
+/**标准差函数 */
+declare function STDEV(...args: number[]): number | '';
+export { IF, ISEMPTY, ISNULL, ISUNDEFINED, AND, OR, EQ, NE, LE, LT, GE, GT, LEN, CONCAT, SUBSTRING, SUBSTR, UPPER, LOWER, TRIM, LTRIM, RTRIM, REPEAT, REPLACE, FINDSTR, SEARCHSTR, PARSENUMBER, SPLIT, SUM, ADD, REDUCE, MULTIPLICATION, DIVISION, FIXED, ROUND, ROUNDUP, MAX, LARGE, MIN, SMALL, AVERAGE, ABS, MOD, POWER, SQRT, GET, PUT, PUSH, HEADPUSH, TIMESTAMP2DATE, DATE2TIMESTAMP, DATEFORMAT, NOW, TODAY, YEAR, MONTH, DAY, HOUR, MINUTE, WEEKRANGE, LASTWEEKRANGE, MONTHRANGE, LASTMONTHRANGE, YEARRANGE, LASTYEARRANGE, QUARTER, LASTQUARTER, ISDATERANGE, ISTIMERANGE, TUPLE, SEQMAP, SUMSQ, COUNT, STDEV, };