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

package/es/state/design-render-base/design-render-base.state.mjs

@@ -0,0 +1,6 @@
+//#region src/state/design-render-base/design-render-base.state.ts
+var DesignRenderBaseState = class {
+	isDestroy = false;
+};
+//#endregion
+export { DesignRenderBaseState };

package/es/state/design-render-container/design-render-container.state.d.ts

@@ -0,0 +1,4 @@
+import { IDesignRenderContainerState } from '../../interface';
+import { DesignRenderBaseState } from '../design-render-base/design-render-base.state';
+export declare class DesignRenderContainerState extends DesignRenderBaseState implements IDesignRenderContainerState {
+}

package/es/state/design-render-item/design-render-item.state.d.ts

@@ -0,0 +1,4 @@
+import { IDesignRenderItemState } from '../../interface';
+import { DesignRenderBaseState } from '../design-render-base/design-render-base.state';
+export declare class DesignRenderItemState extends DesignRenderBaseState implements IDesignRenderItemState {
+}

package/es/state/index.d.ts

@@ -0,0 +1,4 @@
+export { DesignRenderState } from './design-render/design-render.state';
+export { DesignRenderBaseState } from './design-render-base/design-render-base.state';
+export { DesignRenderContainerState } from './design-render-container/design-render-container.state';
+export { DesignRenderItemState } from './design-render-item/design-render-item.state';

package/es/utils/cacheAdapter.mjs

@@ -1,57 +1,65 @@
-import qs from 'qs';
-
+import qs from "qs";
+//#region src/utils/cacheAdapter.ts
+/**
+* 请求缓存
+* @param args
+* @param adapter
+* @returns
+*/
 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;
+	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);
-      }
-    }
-  }
-}
-
+var MemoryCache = class {
+	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) {
+				if (Date.now() - cachedItem.now > cachedItem.maxAge) this.delete(key);
+			}
+		}
+	}
+};
+//#endregion
 export { cacheAdapter };

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

@@ -1,6 +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>, [
+export declare const calculate: UseMemoizeReturn<Promise<IObject | number>, [
     expr: string,
     values: IObject
 ]>;

package/es/utils/expression/index.mjs

@@ -1,133 +1,116 @@
-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);
+import { methods_exports } from "./regularExpression/methods.mjs";
+import { SYSTEM_VAR_PREFIX, functionMap, innerVarIds, operator2FuncMap } from "@gct-paas/core";
+import * as esprima from "esprima-next";
+import estraverse from "estraverse";
+import { useMemoize } from "@vueuse/core";
+//#region src/utils/expression/index.ts
+window._METHOD_DEBUG_ = methods_exports;
+var identify = useMemoize(_identify);
+var 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 "";
+	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;
+var AsyncFunction = Object.getPrototypeOf(async function() {}).constructor;
+/**
+* 获取系统变量值
+* @param ids 系统变量标识
+* @returns
+*/
 async function _getSystemVarValue(ids) {
-  let res = [];
-  if (ids.length > 0) {
-    res = await _gct.api.apaas.systemVar.getGetVarByKeys({
-      keys: ids.join(",")
-    });
-  }
-  return res;
+	let res = [];
+	if (ids.length > 0) res = await _gct.api.apaas.systemVar.getGetVarByKeys({ keys: ids.join(",") });
+	return res;
 }
-const getSystemVarValue = useMemoize(_getSystemVarValue);
+var getSystemVarValue = useMemoize(_getSystemVarValue);
+/**
+* 表达式计算
+* @param expr
+* @param values
+* @returns
+*/
 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;
+	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_exports);
+	console.info("【表达式】", expr);
+	console.info("【参数】", values);
+	console.info("【执行语句】", calcFunc.toString());
+	console.info("【执行结果】", result);
+	return result;
 }
+/**
+* 变量识别
+* @param expr
+* @returns
+*/
 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)];
+	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
+	execute: calculate,
+	identify
 };
-
+//#endregion
 export { calculate, identify };