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

package/es/utils/expression/index.mjs

@@ -0,0 +1,116 @@
+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 "";
+}
+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;
+}
+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_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)];
+}
+window.gct_expression = {
+	execute: calculate,
+	identify
+};
+//#endregion
+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, };