@cloudpss/expression 0.6.0-alpha.1 → 0.6.0-alpha.10

package/src/migrator/call.ts

@@ -10,7 +10,7 @@ import {
 } from 'mathjs';
 import type { Options, Result } from './interface.js';
 import type { State } from './state.js';
-import { constantValue, equalText, symbolName } from './utils.js';
+import { constantValue, equalText, len, symbolName } from './utils.js';
 import { migrateAtomic, migrateExpr, migrateNode } from './node.js';
 import { concat } from './concat.js';
 import { toNumber, toString } from './to-type.js';
@@ -53,215 +53,246 @@ function call(state: State, node: FunctionNode<MathNode>, done: (fn: Result, arg
     };
 }
 
-/** 转换 AST */
-export function migrateCall(state: State, node: FunctionNode<MathNode>, options: Options): Result {
-    const { fn, args } = node;
+/** 函数调用 */
+function migrateFunctionCall(
+    state: State,
+    node: FunctionNode<MathNode>,
+    fnName: string,
+    args: readonly MathNode[],
+    options: Options,
+): Result {
+    const openE = options.format !== 'no-paren' ? '(' : '';
+    const closeE = options.format !== 'no-paren' ? ')' : '';
 
-    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) {
+    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 === 'size' && args.length === 1) {
+        const arg = migrateAtomic(state, args[0]!);
+        return {
+            type: arg.type,
+            code: `matrix.size(${arg.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 === 'count' && args.length === 1) {
+        const arg = migrateAtomic(state, args[0]!);
+        if (arg.type !== 'string') {
+            state.warn(`函数行为可能不一致: count`);
+        }
+        return len(state, arg);
+    } 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: `to_timestamp(${migrateAtomic(state, args[0]!).code})`,
+                code: `hypot(${args[0].items.map((a) => migrateAtomic(state, a).code).join(', ')})`,
             };
-        } 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(${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: 'number',
-                    code: `hypot(${args[0].items.map((a) => migrateAtomic(state, a).code).join(', ')})`,
+                    type: 'boolean',
+                    code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == '${t}'${closeE}`,
                 };
-            }
-            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' 结果可能不同`);
+            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': {
+                const arg0 = migrateAtomic(state, args[0]!);
+                if (arg0.code.endsWith('.value.rt_state')) {
                     return {
                         type: 'boolean',
-                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'record'${closeE}`,
+                        code: `${openE}!!${arg0.code}${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' 结果可能不同`);
+                }
+                state.warn(`'type' 与 'is' 结果可能不同`);
+                return {
+                    type: 'boolean',
+                    code: `${openE}type(${arg0.code}) == 'record'${closeE}`,
+                };
+            }
+            case 'Function':
+            case 'function': {
+                if (symbolName(args[0]!) === 'service' && !state.locals.has('service')) {
                     return {
                         type: 'boolean',
-                        code: `${openE}type(${migrateAtomic(state, args[0]!).code}) == 'function'${closeE}`,
+                        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} }))`,
-            };
         }
+    } 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}`);
+    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}`);
+        }
+    });
+}
+
+/** 转换 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)) {
+        return migrateFunctionCall(state, node, fnName, args, options);
     }
 
     if (
@@ -382,7 +413,7 @@ export function migrateCall(state: State, node: FunctionNode<MathNode>, options:
         } else if (thisArg.type === 'extern') {
             const argList = args.map((a) => migrateAtomic(state, a).code);
             return {
-                code: `${thisArg.code}(${argList.join(', ')})`,
+                code: `${thisArg.code}.${fnName}(${argList.join(', ')})`,
             };
         }
 

package/src/migrator/interface.ts

@@ -1,4 +1,4 @@
-import type { TypeName, VmConst } from '@mirascript/mirascript';
+import type { TypeName, VmConst, VmValue } from '@mirascript/mirascript';
 
 /** 转换选项 */
 export interface Options {
@@ -12,6 +12,8 @@ export interface Result {
     readonly type?: TypeName;
     /** 为字面量 */
     readonly literal?: VmConst;
+    /** 为全局变量 */
+    readonly global?: VmValue;
     /** 转换后的代码 */
     readonly code: string;
     /** 转换后的代码 */

package/src/migrator/node.ts

@@ -117,7 +117,7 @@ export function migrateNode(state: State, node: MathNode, options: Options): Res
             const r = params[i + 1]!;
             exprs.push(migrateOperator(state, { fn, args: [l, r] }, options));
         }
-        let code = exprs.join(' && ');
+        let code = exprs.map((e) => e.code).join(' && ');
         if (options.format !== 'no-paren') code = `(${code})`;
         return {
             type: 'boolean',

package/src/migrator/operator.ts

@@ -47,10 +47,18 @@ const BINARY_MATH_OPERATORS = {
     ],
     divide: [
         ' / ',
-        (l, r) => ({
-            type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.multiply(${l.code}, matrix.invert(${r.code}))`,
-        }),
+        (l, r) => {
+            if (r.type === 'array' || !r.type) {
+                return {
+                    type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
+                    code: `matrix.multiply(${l.code}, matrix.invert(${r.code}))`,
+                };
+            }
+            return {
+                type: l.type === 'array' ? 'array' : l.type ? 'number' : undefined,
+                code: `matrix.entrywise_divide(${l.code}, ${r.code})`,
+            };
+        },
     ],
     dotDivide: [
         ' / ',
@@ -187,9 +195,9 @@ export function migrateOperator(
         case 'unaryMinus':
         case 'unaryPlus': {
             const op = fn === 'unaryMinus' ? '-' : '+';
-            const f = fn === 'unaryMinus' ? operations.$Neg : operations.$Pos;
             const exp = migrateExpr(state, a0);
             if (typeof exp.literal == 'number') {
+                const f = fn === 'unaryMinus' ? operations.$Neg : operations.$Pos;
                 const v = f(exp.literal);
                 return {
                     type: 'number',
@@ -308,6 +316,12 @@ export function migrateOperator(
             };
 
             return binary(state, a(a0), a(a1), (l, r) => {
+                if (l.type === 'boolean' && r.type === 'boolean') {
+                    return {
+                        type: 'boolean',
+                        code: `${l.code} ${op} ${r.code}`,
+                    };
+                }
                 return {
                     type: 'boolean',
                     code: `${toNumber(state, l).code} ${op} ${toNumber(state, r).code}`,

package/src/migrator/state.ts

@@ -1,4 +1,4 @@
-import { createVmContext, type VmContext } from '@mirascript/mirascript';
+import type { VmContext } from '@mirascript/mirascript';
 import { parse } from './parser.js';
 import {
     type AssignmentNode,
@@ -87,7 +87,7 @@ export class BaseState {
         private readonly expr: string,
         readonly condition: boolean,
         /** 可识别的全局环境 */
-        readonly globals: VmContext = createVmContext(),
+        readonly globals: VmContext,
     ) {}
     /** 帮助函数 */
     private readonly helpers = new Set<string>();

package/src/migrator/symbol.ts

@@ -18,6 +18,7 @@ export function migrateSymbol(state: State, node: SymbolNode, migrateConst: bool
         return {
             type: operations.$Type(global),
             code: name,
+            global,
         };
     }
     if (name.startsWith('$') || name.startsWith('@')) {
@@ -45,6 +46,18 @@ export function migrateSymbol(state: State, node: SymbolNode, migrateConst: bool
                 code: `@e`,
             };
         }
+        if (name === '__PREVIEW') {
+            return {
+                type: 'boolean',
+                code: '@PREVIEW',
+            };
+        }
+        if (name === '__ICON') {
+            return {
+                type: 'boolean',
+                code: '@ICON',
+            };
+        }
     }
     state.warn(`符号 '${name}' 未定义`);
     return {

package/src/migrator/to-type.ts

@@ -46,6 +46,14 @@ export function toString(state: State, node: MathNode | Result): Result {
                 code: node.as_string,
             };
         }
+        if (node.type === 'number' && node.literal !== undefined) {
+            const lit = String(node.literal);
+            return {
+                type: 'string',
+                literal: lit,
+                code: serialize(lit),
+            };
+        }
         return {
             type: 'string',
             code: `to_string(${node.code})`,
@@ -74,6 +82,14 @@ export function toNumber(state: State, node: MathNode | Result): Result {
                 code: node.as_number,
             };
         }
+        if (node.type === 'string' && node.literal !== undefined) {
+            const lit = Number(node.literal);
+            return {
+                type: 'number',
+                literal: lit,
+                code: serialize(lit),
+            };
+        }
         return {
             type: 'number',
             code: `to_number(${node.code})`,

package/src/migrator/utils.ts

@@ -65,3 +65,24 @@ export function equalText(state: State, op: '==' | '!=', l: MathNode, r: MathNod
         code: `${toString(state, lr).code} ${op} ${toString(state, rr).code}`,
     };
 }
+
+/** 计算长度 */
+export function len(state: State, obj: Result): Result {
+    if (obj.type === 'string')
+        return {
+            type: 'number',
+            code: `len(chars(${obj.code}))`,
+        };
+    if (obj.type === 'array')
+        return {
+            type: 'number',
+            code: `len(${obj.code})`,
+        };
+    state.helper(
+        `fn @@length(x) { if type(x) == 'string' { len(chars(x)) } else if type(x) == 'array' { len(x) } } else { x.length } }`,
+    );
+    return {
+        type: 'number',
+        code: `@@length(${obj.code})`,
+    };
+}