@cloudpss/expression 0.6.0-alpha.8 → 0.6.0-beta.1

package/src/migrator/state.ts

@@ -1,10 +1,10 @@
-import { createVmContext, type VmContext } from '@mirascript/mirascript';
+import type { VmContext } from '@mirascript/mirascript';
 import { parse } from './parser.js';
 import {
     type AssignmentNode,
-    type FunctionAssignmentNode,
     isAssignmentNode,
     isBlockNode,
+    isConstantNode,
     isFunctionAssignmentNode,
     isSymbolNode,
     type MathNode,
@@ -12,9 +12,10 @@ import {
 import type { Result } from './interface.js';
 import { migrateAtomic } from './node.js';
 import { toBoolean } from './to-type.js';
-import { constantValue, symbolName, unsupportedNode } from './utils.js';
+import { constantValue, migrateSymbolName, symbolName, unsupportedNode } from './utils.js';
 import { migrateAccess } from './access.js';
 import { specialMigrate } from './special.js';
+import { migrateFunctionAssignment } from './function.js';
 
 /** 转换 AST */
 function migrateLast(state: State, node: MathNode): Result {
@@ -38,17 +39,20 @@ function migrateAssignment(state: State, node: AssignmentNode): Result {
     const { object, index, value } = node;
     const name = symbolName(object);
     if (name && index == null) {
-        // name = xxx;
+        const localName = migrateSymbolName(name, true);
         if (state.locals.has(name)) {
-            state.err(`不支持局部变量重新赋值: ${name}'`);
+            state.err(`不支持局部变量重新赋值: '${name}'`);
             return {
-                code: `${name} = ${migrateAtomic(state, value).code}`,
+                code: `${localName} = ${migrateAtomic(state, value).code}`,
             };
         }
         const expr = migrateAtomic(state, value);
         state.locals.set(name, expr);
+        if (name !== localName) {
+            state.warn(`变量名 '${name}' 是 MiraScript 关键字，已转换为 '${localName}'`);
+        }
         return {
-            code: `let ${name} = ${expr.code};`,
+            code: `let ${localName} = ${expr.code};`,
         };
     }
     if (index != null) {
@@ -60,26 +64,6 @@ function migrateAssignment(state: State, node: AssignmentNode): Result {
     }
     return unsupportedNode(state, node);
 }
-/** 转换函数定义语句 */
-function migrateFunctionAssignment(state: State, node: FunctionAssignmentNode): Result {
-    state.loose();
-    const { name, params, expr } = node;
-    if (state.locals.has(name)) {
-        state.err(`重复定义函数: ${name}`);
-    }
-    const fState = new FunctionState(state, params);
-    let body = migrateAtomic(fState, expr);
-    if (!(body.code.startsWith('{') && body.code.endsWith('}'))) {
-        body = { ...body, code: `{ ${body.code} }` };
-    }
-    state.locals.set(name, {
-        type: 'function',
-        code: body.code,
-    });
-    return {
-        code: `fn ${name}(${params.join(', ')}) ${body.code}`,
-    };
-}
 
 /** 转换状态 */
 export class BaseState {
@@ -87,7 +71,7 @@ export class BaseState {
         private readonly expr: string,
         readonly condition: boolean,
         /** 可识别的全局环境 */
-        readonly globals: VmContext = createVmContext(),
+        readonly globals: VmContext,
     ) {}
     /** 帮助函数 */
     private readonly helpers = new Set<string>();
@@ -126,7 +110,7 @@ export class BaseState {
         const r = isFunc ? migrateFunctionAssignment(this, node) : migrator(this, node);
         let { code } = r;
         if (stmt && !isFunc && !code.endsWith(';')) code += ';';
-        if (node.comment) code += ' //' + node.comment;
+        if (node.comment) code += ' //' + node.comment.slice(1);
         this.ret.push(code);
     }
     /** 转换 */
@@ -143,7 +127,6 @@ export class BaseState {
             const sp = specialMigrate(this.expr, ast);
             if (sp != null) {
                 this.ret.push(sp);
-                this.loose();
                 return;
             }
             if (isBlockNode(ast)) {
@@ -160,6 +143,8 @@ export class BaseState {
                     }
                 }
                 return;
+            } else if (isConstantNode(ast) && ast.value === undefined && ast.comment) {
+                this.ret.push(`//${ast.comment.slice(1)}`);
             } else {
                 this.migrateStmt(migrateLast, false, ast);
                 return;
@@ -178,21 +163,33 @@ export class BaseState {
         // 写入原始 math.js 作为注释
         const lines = this.expr.split('\n').map((line) => `// ${line}`);
         lines.unshift(`// # 原始 math.js 表达式`);
+        const addComment = (prefix: string, item: string) => {
+            if (!item.includes('\n')) {
+                lines.unshift(`// ${prefix}: ${item}`);
+                return;
+            }
+            const l = item.split('\n');
+            const indent = ' '.repeat(prefix.length + 2);
+            for (let i = l.length - 1; i >= 1; i--) {
+                lines.unshift(`// ${indent}${l[i]}`);
+            }
+            lines.unshift(`// ${prefix}: ${l[0]}`);
+        };
         if (this.errors.size || this.warnings.size || this.critical.size) {
             const warnings = [...this.warnings];
             for (let i = warnings.length - 1; i >= 0; i--) {
                 const warn = warnings[i]!;
-                lines.unshift(`// - W: ${warn}`);
+                addComment('- W', warn);
             }
             const errors = [...this.errors];
             for (let i = errors.length - 1; i >= 0; i--) {
                 const err = errors[i]!;
-                lines.unshift(`// - E: ${err}`);
+                addComment('- E', err);
             }
             const critical = [...this.critical];
             for (let i = critical.length - 1; i >= 0; i--) {
                 const crit = critical[i]!;
-                lines.unshift(`// - C: ${crit}`);
+                addComment('- C', crit);
             }
             lines.unshift(`// # 转换日志`);
         }

package/src/migrator/symbol.ts

@@ -2,6 +2,7 @@ import type { SymbolNode } from 'mathjs';
 import type { Result } from './interface.js';
 import type { State } from './state.js';
 import { operations } from '@mirascript/mirascript/subtle';
+import { migrateSymbolName } from './utils.js';
 
 /** 处理符号名称 */
 export function migrateSymbol(state: State, node: SymbolNode, migrateConst: boolean): Result {
@@ -10,15 +11,23 @@ export function migrateSymbol(state: State, node: SymbolNode, migrateConst: bool
     if (local) {
         return {
             ...local,
-            code: name,
+            code: migrateSymbolName(name, true),
         };
     }
-    const global = state.globals.get(name);
-    if (global != null) {
-        return {
-            type: operations.$Type(global),
-            code: name,
-        };
+    if (state.globals.has(name)) {
+        try {
+            const global = state.globals.get(name);
+            return {
+                type: operations.$Type(global),
+                code: migrateSymbolName(name, false),
+                global,
+            };
+        } catch {
+            return {
+                type: undefined,
+                code: migrateSymbolName(name, false),
+            };
+        }
     }
     if (name.startsWith('$') || name.startsWith('@')) {
         return {
@@ -33,21 +42,33 @@ export function migrateSymbol(state: State, node: SymbolNode, migrateConst: bool
                 code: `i`,
             };
         }
-        if (name === 'pi' || name === 'PI') {
+        if (name === 'pi') {
             return {
                 type: 'number',
-                code: `@pi`,
+                code: `PI`,
             };
         }
-        if (name === 'e' || name === 'E') {
+        if (name === 'e') {
             return {
                 type: 'number',
-                code: `@e`,
+                code: `E`,
+            };
+        }
+        if (name === '__PREVIEW') {
+            return {
+                type: 'boolean',
+                code: '@PREVIEW',
+            };
+        }
+        if (name === '__ICON') {
+            return {
+                type: 'boolean',
+                code: '@ICON',
             };
         }
     }
     state.warn(`符号 '${name}' 未定义`);
     return {
-        code: name,
+        code: migrateSymbolName(name, false),
     };
 }

package/src/migrator/to-type.ts

@@ -1,13 +1,16 @@
 import { isConstantNode, isNode, type MathNode } from 'mathjs';
 import type { Result } from './interface.js';
-import { serialize } from '@mirascript/mirascript/subtle';
+import { serialize } from './serialize.js';
 import type { State } from './state.js';
 import { migrateNode } from './node.js';
+import { globalFnName } from './utils.js';
 
 /** 转换 AST */
 export function toBoolean(state: State, node: MathNode | Result): Result {
     const helper = (): void => {
-        state.helper("fn @@to_boolean { it != '' && it != 0 && it is not nan && !!it }");
+        state.helper(
+            "fn @@to_boolean { if it is nil { nil } else { it != '' && it != '0' && it != 0 && it is not nan && it != false } }",
+        );
     };
     if (!isNode(node)) {
         if (node.type === 'boolean') return node;
@@ -46,9 +49,17 @@ 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})`,
+            code: `${globalFnName(state, 'to_string')}(${node.code})`,
         };
     }
     if (isConstantNode(node)) {
@@ -74,9 +85,17 @@ export function toNumber(state: State, node: MathNode | Result): Result {
                 code: node.as_number,
             };
         }
+        if ((node.type === 'string' || node.type === 'boolean') && node.literal !== undefined) {
+            const lit = Number(node.literal);
+            return {
+                type: 'number',
+                literal: lit,
+                code: serialize(lit),
+            };
+        }
         return {
             type: 'number',
-            code: `to_number(${node.code})`,
+            code: `${globalFnName(state, 'to_number')}(${node.code})`,
         };
     }
     if (isConstantNode(node)) {

package/src/migrator/utils.ts

@@ -1,17 +1,44 @@
-import { type MathNode, isSymbolNode, isConstantNode } from 'mathjs';
+import { type MathNode, isSymbolNode, isConstantNode, isOperatorNode } from 'mathjs';
+import { keywords } from '@mirascript/mirascript/subtle';
 import type { Result } from './interface.js';
 import type { State } from './state.js';
 import { toString } from './to-type.js';
 import { migrateExpr } from './node.js';
 
+/** 获取全局函数的名字 */
+export function globalFnName(state: State, fnName: string): string {
+    if (state.locals.has(fnName)) {
+        return `global.${fnName}`;
+    }
+    return fnName;
+}
+
 /** 获取 symbol name */
 export function symbolName(node: MathNode): string | undefined {
     if (!isSymbolNode(node)) return undefined;
     return node.name;
 }
 
+const kw = new Set(keywords());
+/** 转换为 mirascript 符号 */
+export function migrateSymbolName(name: string, local: boolean): string {
+    if (!kw.has(name)) return name;
+    if (local) return `__${name}__`;
+    return `global.${name}`;
+}
+
 /** 获取 constant value */
 export function constantValue(node: MathNode): number | string | boolean | null | undefined {
+    if (isOperatorNode(node) && node.args.length === 1) {
+        if (node.op === '+') {
+            const val = constantValue(node.args[0]!);
+            if (typeof val === 'number') return val;
+        } else if (node.op === '-') {
+            const val = constantValue(node.args[0]!);
+            if (typeof val === 'number') return -val;
+        }
+        return undefined;
+    }
     if (!isConstantNode(node)) return undefined;
     return node.value ?? null;
 }
@@ -65,3 +92,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})`,
+    };
+}

package/src/parser.ts

@@ -1,5 +1,7 @@
 import { compileSync, type VmScript } from '@mirascript/mirascript';
-import type { Context } from './context.js';
+import { LRUCache } from 'lru-cache';
+import type { Evaluator } from './main.js';
+
 /** 一般表达式 */
 export interface EvalExpressionCache {
     /**
@@ -38,12 +40,12 @@ export type ExpressionCache = ErrorExpressionCache | EvalExpressionCache;
 /**
  * 编译表达式
  */
-function compile(expression: string): ExpressionCache {
+function compile(expression: string, template: boolean): ExpressionCache {
     const compiled = {
         source: expression,
     } as ExpressionCache;
     try {
-        const script = compileSync(expression);
+        const script = compileSync(expression, { input_mode: template ? 'Template' : 'Script' });
         compiled.func = script;
     } catch (ex) {
         compiled.error = ex as Error;
@@ -51,19 +53,42 @@ function compile(expression: string): ExpressionCache {
     return compiled;
 }
 
+const kTemplateCache = Symbol('cloudpss.expression.templateCache');
+const kExpressionCache = Symbol('cloudpss.expression.expressionCache');
+
+/** 获取编译缓存 */
+function getCache(evaluator: Evaluator | null, template: boolean): LRUCache<string, EvalExpressionCache> | null {
+    if (evaluator == null) return null;
+    const key = template ? kTemplateCache : kExpressionCache;
+    if (!(key in evaluator)) {
+        const size = template ? evaluator.options.templateCacheSize : evaluator.options.expressionCacheSize;
+        Object.defineProperty(evaluator, key, {
+            value: new LRUCache<string, EvalExpressionCache>({ max: size! || 50 }),
+        });
+    }
+    return (evaluator as Evaluator & Record<typeof key, LRUCache<string, EvalExpressionCache>>)[key];
+}
+
 /**
  * 解析表达式
  */
-export function parse(context: Context, expression: string, throws: boolean): ExpressionCache {
+export function parse(
+    evaluator: Evaluator | null,
+    expression: string,
+    throws: boolean,
+    template: boolean,
+): ExpressionCache {
     if (typeof expression != 'string') {
         throw new TypeError(`${String(expression)} is not a valid expression`);
     }
-    const v = context.expressionCache.get(expression);
-    if (v) return v;
-    const complied = compile(expression);
+    const cache = getCache(evaluator, template);
+    const cached = cache?.get(expression);
+    if (cached != null) return cached;
+    const complied = compile(expression, template);
     if (complied.error) {
         if (throws) throw complied.error;
+    } else {
+        cache?.set(expression, complied);
     }
-    context.expressionCache.set(expression, complied);
     return complied;
 }

package/src/re-exports.ts

@@ -0,0 +1,47 @@
+export {
+    isVmAny,
+    isVmArray,
+    isVmConst,
+    isVmContext,
+    isVmExtern,
+    isVmFunction,
+    isVmImmutable,
+    isVmModule,
+    isVmPrimitive,
+    isVmRecord,
+    isVmArrayLikeRecord,
+    isVmArrayLikeRecordByEntires,
+    isVmArrayLikeRecordByKeys,
+    isVmCallable,
+    isVmScript,
+    isVmWrapper,
+    isVmValue,
+    VmExtern,
+    VmFunction,
+    VmModule,
+    VmError,
+    defineVmContextValue,
+} from '@mirascript/mirascript';
+export type {
+    VmScript,
+    VmValueMap,
+    VmAny,
+    VmArray,
+    VmConst,
+    VmContext,
+    VmImmutable,
+    VmPrimitive,
+    VmRecord,
+    VmUninitialized,
+    VmValue,
+} from '@mirascript/mirascript';
+export {
+    serialize,
+    serializeRecordKey,
+    serializeString,
+    type SerializeOptions,
+    constants,
+    DefaultVmContext,
+    lib,
+    operations,
+} from '@mirascript/mirascript/subtle';