@cloudpss/expression 0.6.0-alpha.1

package/src/migrator/call.ts

@@ -0,0 +1,397 @@
+import {
+    type ConstantNode,
+    isAccessorNode,
+    isArrayNode,
+    isConstantNode,
+    isObjectNode,
+    type FunctionNode,
+    type MathNode,
+    isOperatorNode,
+} from 'mathjs';
+import type { Options, Result } from './interface.js';
+import type { State } from './state.js';
+import { constantValue, equalText, symbolName } from './utils.js';
+import { migrateAtomic, migrateExpr, migrateNode } from './node.js';
+import { concat } from './concat.js';
+import { toNumber, toString } from './to-type.js';
+
+const EXACT_UNARY_FUNCTION = new Map<string, Result['type']>([
+    // 只支持标量的 mathjs 函数
+    ['sin', 'number'],
+    ['cos', 'number'],
+    ['tan', 'number'],
+    ['sinh', 'number'],
+    ['cosh', 'number'],
+    ['tanh', 'number'],
+    ['asin', 'number'],
+    ['acos', 'number'],
+    ['atan', 'number'],
+    ['asinh', 'number'],
+    ['acosh', 'number'],
+    ['atanh', 'number'],
+    ['sqrt', 'number'],
+    ['cbrt', 'number'],
+    ['log', 'number'],
+
+    // 自定义函数，在 mirascript 也提供
+    ['keys', 'array'],
+    ['values', 'array'],
+    ['entries', 'array'],
+
+    // XStudio 提供的函数
+    ['service', 'extern'],
+]);
+
+/** 兜底 */
+function call(state: State, node: FunctionNode<MathNode>, done: (fn: Result, args: readonly Result[]) => void): Result {
+    const { fn, args } = node;
+    const fnRet = migrateExpr(state, fn);
+    const argList = args.map((a) => migrateAtomic(state, a));
+    done(fnRet, argList);
+    return {
+        code: `${fnRet.code}(${argList.map((a) => a.code).join(', ')})`,
+    };
+}
+
+/** 转换 AST */
+export function migrateCall(state: State, node: FunctionNode<MathNode>, options: Options): Result {
+    const { fn, args } = node;
+
+    const fnName = symbolName(fn);
+    if (fnName && !state.locals.has(fnName)) {
+        const openE = options.format !== 'no-paren' ? '(' : '';
+        const closeE = options.format !== 'no-paren' ? ')' : '';
+
+        if (EXACT_UNARY_FUNCTION.has(fnName) && args.length === 1) {
+            const arg = migrateAtomic(state, args[0]!);
+            return {
+                type: EXACT_UNARY_FUNCTION.get(fnName)!,
+                code: `${fnName}(${arg.code})`,
+            };
+        } else if (fnName === 're' || fnName === 'im') {
+            const m = migrateAtomic(state, args[0]!);
+            state.err(`不支持复数`);
+            return {
+                type: 'number',
+                code: `/* ${fnName} */(${m.code})`,
+            };
+        } else if (fnName === 'date' && args.length === 1) {
+            return {
+                type: 'number',
+                code: `to_timestamp(${migrateAtomic(state, args[0]!).code})`,
+            };
+        } else if (fnName === 'inv' && args.length === 1) {
+            const arg = migrateAtomic(state, args[0]!);
+            return {
+                type: arg.type,
+                code: `matrix.invert(${arg.code})`,
+            };
+        } else if (fnName === 'transpose' && args.length === 1) {
+            const arg = migrateAtomic(state, args[0]!);
+            return {
+                type: arg.type,
+                code: `matrix.transpose(${arg.code})`,
+            };
+        } else if (fnName === 'diag' && (args.length === 1 || args.length === 2)) {
+            const a = args.map((a) => migrateAtomic(state, a).code).join(', ');
+            return {
+                type: 'array',
+                code: `matrix.diagonal(${a})`,
+            };
+        } else if (fnName === 'zeros' || fnName === 'ones' || fnName === 'identity') {
+            return {
+                type: 'array',
+                code: `matrix.${fnName}(${args.map((a) => migrateAtomic(state, a).code).join(', ')})`,
+            };
+        } else if (fnName === 'concat') {
+            const results = args.map((a) => migrateAtomic(state, a));
+            if (results.some((r) => r.type === 'string')) return concat(state, results);
+        } else if (fnName === 'numeric' && args.length === 1) {
+            return toNumber(state, args[0]!);
+        } else if (fnName === 'flatten' && args.length === 1) {
+            return {
+                type: 'array',
+                code: `flatten(${migrateAtomic(state, args[0]!).code})`,
+            };
+        } else if (fnName === 'norm' && args.length === 1) {
+            if (isArrayNode(args[0])) {
+                return {
+                    type: 'number',
+                    code: `hypot(${args[0].items.map((a) => migrateAtomic(state, a).code).join(', ')})`,
+                };
+            }
+            return {
+                type: 'number',
+                code: `hypot(${migrateAtomic(state, args[0]!).code})`,
+            };
+        } else if (fnName === 'equalText' && args.length === 2) {
+            const p = equalText(state, '==', args[0]!, args[1]!);
+            return {
+                type: p.type,
+                code: `${openE}${p.code}${closeE}`,
+            };
+        } else if (fnName === 'toJson' && args.length === 1) {
+            return {
+                type: 'string',
+                code: `to_json(${migrateAtomic(state, args[0]!).code})`,
+            };
+        } else if (fnName === 'fromJson' && args.length === 1) {
+            return {
+                code: `from_json(${migrateAtomic(state, args[0]!).code})`,
+            };
+        } else if (fnName === 'is' && args.length === 2 && isConstantNode(args[1])) {
+            const t = String((args[1] as ConstantNode<string | number>).value);
+            switch (t) {
+                case 'number':
+                case 'string':
+                case 'boolean':
+                    return {
+                        type: 'boolean',
+                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == '${t}'${closeE}`,
+                    };
+                case 'null':
+                case 'undefined':
+                    return {
+                        type: 'boolean',
+                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'nil'${closeE}`,
+                    };
+                case 'Array':
+                case 'array':
+                    state.warn(`'type' 与 'is' 结果可能不同`);
+                    return {
+                        type: 'boolean',
+                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'array'${closeE}`,
+                    };
+                case 'Object':
+                case 'object':
+                    state.warn(`'type' 与 'is' 结果可能不同`);
+                    return {
+                        type: 'boolean',
+                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'record'${closeE}`,
+                    };
+                case 'Function':
+                case 'function': {
+                    if (symbolName(args[0]!) === 'service' && !state.locals.has('service')) {
+                        return {
+                            type: 'boolean',
+                            code: `${openE}type(service) == 'extern'${closeE}`,
+                        };
+                    }
+                    state.warn(`'type' 与 'is' 结果可能不同`);
+                    return {
+                        type: 'boolean',
+                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'function'${closeE}`,
+                    };
+                }
+            }
+        } else if (fnName === 'typeOf' && args.length === 1) {
+            state.warn(`'type' 与 'typeOf' 结果可能不同`);
+            return {
+                type: 'string',
+                code: `type(${migrateAtomic(state, args[0]!).code})`,
+            };
+        } else if (fnName === 'format' && args.length === 1) {
+            return toString(state, args[0]!);
+        } else if (fnName === 'print' && args.length === 1) {
+            state.loose();
+            return toString(state, args[0]!);
+        } else if (
+            fnName === 'print' &&
+            args.length === 2 &&
+            isConstantNode(args[0]) &&
+            (isObjectNode(args[1]) || isArrayNode(args[1]))
+        ) {
+            const template = String(args[0].value);
+            const values = isObjectNode(args[1])
+                ? args[1].properties
+                : (args[1].items as unknown as Record<string, MathNode>);
+            return {
+                type: 'string',
+                code:
+                    '`' +
+                    template.replaceAll(/`|\$([\w.]+)/g, (original, key: string) => {
+                        if (original === '`') return '\\`';
+                        const keys = key.split('.').map((part) => {
+                            const nPart = Number.parseInt(part);
+                            if (!Number.isNaN(nPart) && part.length > 0 && nPart >= 1) {
+                                return nPart - 1;
+                            } else {
+                                return part;
+                            }
+                        });
+                        const value = values[keys.shift()!];
+                        if (value == null) return original.replaceAll('$', String.raw`\$`);
+                        if (!keys.length) {
+                            return `$(${migrateAtomic(state, value).code})`;
+                        }
+                        return `$(${migrateNode(state, value, { format: 'paren' }).code}.${keys.join('.')})`;
+                    }) +
+                    '`',
+            };
+        } else if (fnName === 'string' && args.length === 1) {
+            const inner = migrateAtomic(state, args[0]!);
+            return {
+                type: 'string',
+                code: `to_string(${inner.code})`,
+            };
+        } else if (
+            fnName === 'sum' &&
+            args.length === 1 &&
+            isArrayNode(args[0]) &&
+            args[0].items.length === 1 &&
+            isOperatorNode(args[0].items[0]) &&
+            ['>=', '>', '<=', '<', '==', '!='].includes(args[0].items[0].op) &&
+            typeof constantValue(args[0].items[0].args[1]!) === 'number'
+        ) {
+            // sum([a > v])
+            const a = migrateAtomic(state, args[0].items[0].args[0]!);
+            const v = migrateAtomic(state, args[0].items[0].args[1]!);
+            return {
+                type: 'number',
+                code: `sum(map(${a.code}, fn { it ${args[0].items[0].op} ${v.code} }))`,
+            };
+        }
+
+        return call(state, node, (fn, args) => {
+            const fun = state.globals.get(fnName);
+            if (typeof fun === 'function') {
+                if (args.some((a) => a.type !== 'number' && a.type !== 'boolean' && a.type !== 'string')) {
+                    state.warn(`函数行为可能不一致: ${fnName}`);
+                }
+            } else {
+                state.err(`不支持的函数: ${fnName}`);
+            }
+        });
+    }
+
+    if (
+        isAccessorNode(fn) &&
+        fn.index.dimensions.length === 1 &&
+        isConstantNode(fn.index.dimensions[0]) &&
+        typeof fn.index.dimensions[0].value == 'string'
+    ) {
+        const thisArg = migrateExpr(state, fn.object);
+        const fnName = String(fn.index.dimensions[0].value);
+        if (fnName === 'toString' && args.length === 0) {
+            return {
+                type: 'string',
+                code: `${thisArg.code}::to_string()`,
+            };
+        } else if (fnName === 'includes' && args.length === 1) {
+            if (thisArg.type === 'array') {
+                return {
+                    type: 'boolean',
+                    code: `(${migrateExpr(state, args[0]!).code} in ${thisArg.code})`,
+                };
+            }
+            if (thisArg.type === 'string') {
+                return {
+                    type: 'boolean',
+                    code: `${thisArg.code}::contains(${migrateAtomic(state, args[0]!).code})`,
+                };
+            }
+            state.helper(
+                `fn @@includes(it, el) { match it::type() { case 'string' { it::contains(el) } case 'array' { el in it } case _ { false } } }`,
+            );
+            return {
+                type: 'boolean',
+                code: `${thisArg.code}::@@includes(${migrateAtomic(state, args[0]!).code})`,
+            };
+        } else if ((fnName === 'map' || fnName === 'filter') && args.length === 1) {
+            return {
+                type: 'array',
+                code: `${thisArg.code}::${fnName}(${migrateAtomic(state, args[0]!).code})`,
+            };
+        } else if (fnName === 'find' && args.length === 1) {
+            return {
+                code: `${thisArg.code}::find(${migrateAtomic(state, args[0]!).code}).1`,
+            };
+        } else if (fnName === 'findIndex' && args.length === 1) {
+            return {
+                type: 'number',
+                code: `(${thisArg.code}::find(${migrateAtomic(state, args[0]!).code}).0 ?? -1)`,
+            };
+        } else if (fnName === 'flatMap' && args.length === 1) {
+            return {
+                type: 'array',
+                code: `${thisArg.code}::map(${migrateAtomic(state, args[0]!).code})::flatten()`,
+            };
+        } else if (fnName === 'reverse' && args.length === 0) {
+            return {
+                type: 'array',
+                code: `${thisArg.code}::reverse()`,
+            };
+        } else if ((fnName === 'replaceAll' || fnName === 'replace') && args.length === 2) {
+            if (fnName === 'replace') {
+                state.warn(`MiraScript 的 'replace' 函数会替换全部结果`);
+            }
+            return {
+                type: 'string',
+                code: `${thisArg.code}::replace(${migrateAtomic(state, args[0]!).code}, ${migrateAtomic(state, args[1]!).code})`,
+            };
+        } else if (fnName === 'split' && args.length === 1) {
+            return {
+                type: 'array',
+                code: `${thisArg.code}::split(${migrateAtomic(state, args[0]!).code})`,
+            };
+        } else if (fnName === 'concat') {
+            if (thisArg.type === 'string') {
+                return concat(state, [thisArg, ...args]);
+            }
+            if (thisArg.type !== 'array') {
+                const c = concat(state, [thisArg, ...args]);
+                state.warn(`字符串连接时应使用插值: ${c.code}`);
+            }
+            return {
+                type: 'array',
+                code: `flatten([` + [fn.object, ...args].map((a) => migrateAtomic(state, a).code).join(', ') + `])`,
+            };
+        } else if (
+            fnName === 'toFixed' &&
+            (args.length === 0 || (args.length === 1 && isConstantNode(args[0]) && typeof args[0].value == 'number'))
+        ) {
+            const digits = constantValue(args[0]!) ?? 0;
+            return {
+                type: 'string',
+                code: `${thisArg.code}::format('.${digits}')`,
+            };
+        } else if (isArrayNode(fn.object) && fnName === 'join' && args.length <= 1) {
+            let sep = ',';
+            if (args[0]) {
+                if (isConstantNode(args[0])) {
+                    sep = String(args[0].value).replaceAll('`', '\\`');
+                } else {
+                    sep = `$(${migrateAtomic(state, args[0]).code})`;
+                }
+            }
+            let ret = '';
+            for (let i = 0; i < fn.object.items.length; i++) {
+                const item = fn.object.items[i]!;
+                if (i > 0) ret += sep;
+                if (isConstantNode(item)) {
+                    const value = String(item.value).replaceAll('`', '\\`');
+                    ret += value;
+                } else {
+                    ret += `$(${migrateAtomic(state, item).code})`;
+                }
+            }
+            return {
+                type: 'string',
+                code: '`' + ret + '`',
+            };
+        } else if (thisArg.type === 'extern') {
+            const argList = args.map((a) => migrateAtomic(state, a).code);
+            return {
+                code: `${thisArg.code}(${argList.join(', ')})`,
+            };
+        }
+
+        state.err(`不支持的方法: ${fnName}`);
+        const argList = args.map((a) => migrateAtomic(state, a).code);
+        return { code: `${thisArg.code}.${fnName}(${argList.join(', ')})` };
+    }
+
+    return call(state, node, () => {
+        state.loose();
+    });
+}

package/src/migrator/concat.ts

@@ -0,0 +1,28 @@
+import { isConstantNode, isFunctionNode, isSymbolNode, type MathNode } from 'mathjs';
+import type { State } from './state.js';
+import { migrateNode } from './node.js';
+import { isResult, type Result } from './interface.js';
+
+/** 连接字符串 */
+export function concat(state: State, args: ReadonlyArray<MathNode | string | number | Result>): Result {
+    const parts: string[] = [];
+    for (const arg of args) {
+        if (typeof arg != 'object') {
+            parts.push(String(arg).replaceAll('`', '\\`'));
+        } else if (isConstantNode(arg)) {
+            const value = String(arg.value).replaceAll('`', '\\`');
+            parts.push(value);
+        } else if (isResult(arg)) {
+            if (arg.literal && typeof arg.literal != 'object') {
+                parts.push(String(arg.literal).replaceAll('`', '\\`'));
+            } else {
+                parts.push(`$(${arg.code})`);
+            }
+        } else if (isFunctionNode(arg) && isSymbolNode(arg.fn) && arg.fn.name === 'string') {
+            parts.push(`$(${migrateNode(state, arg.args[0]!, { format: 'no-paren' }).code})`);
+        } else {
+            parts.push(`$(${migrateNode(state, arg, { format: 'no-paren' }).code})`);
+        }
+    }
+    return { code: '`' + parts.join('') + '`', type: 'string' };
+}

package/src/migrator/condition.ts

@@ -0,0 +1,120 @@
+import { isFunctionNode, isOperatorNode, OperatorNode, type ConditionalNode } from 'mathjs';
+import type { State } from './state.js';
+import type { Options, Result } from './interface.js';
+import { toBoolean } from './to-type.js';
+import { migrateAtomic } from './node.js';
+import { constantValue } from './utils.js';
+
+/** 三目运算 */
+export function migrateCondition(state: State, node: ConditionalNode, options: Options): Result {
+    const { condition, trueExpr, falseExpr } = node;
+
+    if (constantValue(trueExpr) === true && constantValue(falseExpr) === false) {
+        // x ? true : false
+        const condRet = toBoolean(state, condition);
+        let { code } = condRet;
+        if (options.format === 'paren') {
+            code = `(${code})`;
+        }
+        return {
+            type: 'boolean',
+            code,
+        };
+    }
+
+    if (constantValue(trueExpr) === false && constantValue(falseExpr) === true) {
+        // x ? false : true
+        const c2 = new OperatorNode('not', 'not', [condition]);
+        const condRet = toBoolean(state, c2);
+        let { code } = condRet;
+        if (options.format === 'paren') {
+            code = `(${code})`;
+        }
+        return {
+            type: 'boolean',
+            code,
+        };
+    }
+
+    if (
+        // is(x, 'string')
+        isFunctionNode(condition) &&
+        condition.fn.isSymbolNode &&
+        condition.fn.name === 'is' &&
+        condition.args.length === 2 &&
+        constantValue(condition.args[1]!) === 'string' &&
+        // ? count(x) != 0
+        isOperatorNode(trueExpr) &&
+        trueExpr.op === '!=' &&
+        isFunctionNode(trueExpr.args[0]!) &&
+        trueExpr.args[0].fn.isSymbolNode &&
+        trueExpr.args[0].fn.name === 'count' &&
+        trueExpr.args[0].args.length === 1 &&
+        constantValue(trueExpr.args[1]!) === 0 &&
+        // : false
+        constantValue(falseExpr) === false &&
+        // same arg
+        condition.args[0]!.equals(trueExpr.args[0].args[0]!)
+    ) {
+        // is(x, 'string') ? count(x) != 0 : false
+        const x = migrateAtomic(state, condition.args[0]!);
+        let code = `type(${x.code}) == 'string' && ${x.code} != ''`;
+        if (options.format === 'paren') {
+            code = `(${code})`;
+        }
+        return {
+            type: 'boolean',
+            code,
+        };
+    }
+
+    if (
+        // is(x, 'string')
+        isFunctionNode(condition) &&
+        condition.fn.isSymbolNode &&
+        condition.fn.name === 'is' &&
+        condition.args.length === 2 &&
+        constantValue(condition.args[1]!) === 'string' &&
+        // ? equalText(x, "xxx")
+        isFunctionNode(trueExpr) &&
+        trueExpr.fn.isSymbolNode &&
+        trueExpr.fn.name === 'equalText' &&
+        trueExpr.args.length === 2 &&
+        typeof constantValue(trueExpr.args[1]!) === 'string' &&
+        // : false
+        constantValue(falseExpr) === false &&
+        // same arg
+        condition.args[0]!.equals(trueExpr.args[0]!)
+    ) {
+        // is(x, 'string') ? equalText(x, "xxx") : false
+        const x = migrateAtomic(state, condition.args[0]!);
+        const xxx = migrateAtomic(state, trueExpr.args[1]!);
+        let code = `${x.code} == ${xxx.code}`;
+        if (options.format === 'paren') {
+            code = `(${code})`;
+        }
+        return {
+            type: 'boolean',
+            code,
+        };
+    }
+
+    const condRet = toBoolean(state, condition);
+    let trueRet = migrateAtomic(state, trueExpr);
+    let falseRet = migrateAtomic(state, falseExpr);
+    if (!(trueRet.code.startsWith('{') && trueRet.code.endsWith('}'))) {
+        trueRet = { ...trueRet, code: `{ ${trueRet.code} }` };
+    }
+    if (!((falseRet.code.startsWith('{') || falseRet.code.startsWith('if ')) && falseRet.code.endsWith('}'))) {
+        falseRet = { ...falseRet, code: `{ ${falseRet.code} }` };
+    }
+
+    let code = `if ${condRet.code} ${trueRet.code} else ${falseRet.code}`;
+    if (options.format === 'paren') {
+        code = `(${code})`;
+    }
+    return {
+        type: trueRet.type === falseRet.type ? trueRet.type : undefined,
+        code,
+    };
+}

package/src/migrator/interface.ts

@@ -0,0 +1,30 @@
+import type { TypeName, VmConst } from '@mirascript/mirascript';
+
+/** 转换选项 */
+export interface Options {
+    /** 格式 */
+    readonly format: 'paren' | 'no-paren' | 'expr';
+}
+
+/** 转换结果 */
+export interface Result {
+    /** 节点类型 */
+    readonly type?: TypeName;
+    /** 为字面量 */
+    readonly literal?: VmConst;
+    /** 转换后的代码 */
+    readonly code: string;
+    /** 转换后的代码 */
+    readonly as_boolean?: string;
+    /** 转换后的代码 */
+    readonly as_number?: string;
+    /** 转换后的代码 */
+    readonly as_string?: string;
+}
+
+/** 判断是否为转换结果 */
+export function isResult(value: unknown): value is Result {
+    if (!value || typeof value != 'object') return false;
+    const obj = value as Result;
+    return typeof obj.code === 'string';
+}