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

package/src/migrator/operator.ts

@@ -8,7 +8,7 @@ import {
     isOperatorNode,
     isNode,
 } from 'mathjs';
-import { symbolName, constantValue, equalText, scalar } from './utils.js';
+import { symbolName, constantValue, equalText, scalar, globalFnName } from './utils.js';
 import type { State } from './state.js';
 import type { Options, Result } from './interface.js';
 import { migrateAtomic, migrateExpr } from './node.js';
@@ -19,50 +19,58 @@ import { operations, serialize } from '@mirascript/mirascript/subtle';
 const BINARY_MATH_OPERATORS = {
     add: [
         ' + ',
-        (l, r) => ({
+        (state, l, r) => ({
             type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.add(${l.code}, ${r.code})`,
+            code: `${globalFnName(state, 'matrix')}.add(${l.code}, ${r.code})`,
         }),
     ],
     subtract: [
         ' - ',
-        (l, r) => ({
+        (state, l, r) => ({
             type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.subtract(${l.code}, ${r.code})`,
+            code: `${globalFnName(state, 'matrix')}.subtract(${l.code}, ${r.code})`,
         }),
     ],
     multiply: [
         ' * ',
-        (l, r) => ({
+        (state, l, r) => ({
             type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.multiply(${l.code}, ${r.code})`,
+            code: `${globalFnName(state, 'matrix')}.multiply(${l.code}, ${r.code})`,
         }),
     ],
     dotMultiply: [
         ' * ',
-        (l, r) => ({
+        (state, l, r) => ({
             type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.entrywise_multiply(${l.code}, ${r.code})`,
+            code: `${globalFnName(state, 'matrix')}.entrywise_multiply(${l.code}, ${r.code})`,
         }),
     ],
     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}))`,
-        }),
+        (state, l, r) => {
+            if (r.type === 'array' || !r.type) {
+                return {
+                    type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
+                    code: `${globalFnName(state, 'matrix')}.multiply(${l.code}, ${globalFnName(state, 'matrix')}.invert(${r.code}))`,
+                };
+            }
+            return {
+                type: l.type === 'array' ? 'array' : l.type ? 'number' : undefined,
+                code: `${globalFnName(state, 'matrix')}.entrywise_divide(${l.code}, ${r.code})`,
+            };
+        },
     ],
     dotDivide: [
         ' / ',
-        (l, r) => ({
+        (state, l, r) => ({
             type: l.type === 'array' || r.type === 'array' ? 'array' : l.type && r.type ? 'number' : undefined,
-            code: `matrix.entrywise_divide(${l.code}, ${r.code})`,
+            code: `${globalFnName(state, 'matrix')}.entrywise_divide(${l.code}, ${r.code})`,
         }),
     ],
     mod: [' % '],
     pow: ['^', false],
     dotPow: ['^'],
-} satisfies Record<string, [op: string, alt?: ((l: Result, r: Result) => Result) | false]>;
+} satisfies Record<string, [op: string, alt?: ((state: State, l: Result, r: Result) => Result) | false]>;
 
 const MATH_FUNCTIONS = {
     factorial: 'factorial',
@@ -99,47 +107,47 @@ function binary(
     state: State,
     l: Result,
     r: Result,
-    op: (l: Result, r: Result) => Result,
-    alt?: (l: Result, r: Result) => Result,
+    op: (state: State, l: Result, r: Result) => Result,
+    alt?: (state: State, l: Result, r: Result) => Result,
 ): Result {
     if (l.type && r.type && l.type !== 'array' && r.type !== 'array') {
-        return op(l, r);
+        return op(state, l, r);
     }
     if (Array.isArray(l.literal) && l.literal.every((e) => !Array.isArray(e))) {
         return {
             type: 'array',
-            code: `${l.code}::map(fn { ${op({ code: 'it' }, r).code} })`,
+            code: `${l.code}::${globalFnName(state, 'map')}(fn { ${op(state, { code: 'it' }, r).code} })`,
         };
     }
     if (Array.isArray(r.literal) && r.literal.every((e) => !Array.isArray(e))) {
         return {
             type: 'array',
-            code: `${r.code}::map(fn { ${op(l, { code: 'it' }).code} })`,
+            code: `${r.code}::${globalFnName(state, 'map')}(fn { ${op(state, l, { code: 'it' }).code} })`,
         };
     }
     if (alt) {
-        return alt(l, r);
+        return alt(state, l, r);
     }
     return {
         type: l.type === 'array' || r.type === 'array' ? 'array' : undefined,
-        code: `matrix.entrywise(${l.code}, ${r.code}, fn (a, b) { ${op({ code: 'a' }, { code: 'b' }).code} })`,
+        code: `${globalFnName(state, 'matrix')}.entrywise(${l.code}, ${r.code}, fn (a, b) { ${op(state, { code: 'a' }, { code: 'b' }).code} })`,
     };
 }
 
 /** 一元操作 */
-function unary(state: State, v: Result, op: (v: Result) => Result): Result {
+function unary(state: State, v: Result, op: (state: State, v: Result) => Result): Result {
     if (v.type && v.type !== 'array') {
-        return op(v);
+        return op(state, v);
     }
     if (Array.isArray(v.literal) && v.literal.every((e) => !Array.isArray(e))) {
         return {
             type: 'array',
-            code: `${v.code}::map(fn { ${op({ code: 'it' }).code} })`,
+            code: `${v.code}::${globalFnName(state, 'map')}(fn { ${op(state, { code: 'it' }).code} })`,
         };
     }
     return {
         type: 'array',
-        code: `matrix.entrywise(${v.code}, nil, fn { ${op({ code: 'it' }).code} })`,
+        code: `${globalFnName(state, 'matrix')}.entrywise(${v.code}, nil, fn { ${op(state, { code: 'it' }).code} })`,
     };
 }
 
@@ -171,14 +179,14 @@ export function migrateOperator(
                 state,
                 migrateExpr(state, a0),
                 migrateExpr(state, a1),
-                (l, r) => ({
+                (state, l, r) => ({
                     type: 'number',
                     code: `${l.code}${op}${r.code}`,
                 }),
                 alt === false
-                    ? (l, r) => {
+                    ? (state, l, r) => {
                           state.warn(`'${op.trim()}' 不支持矩阵，计算结果可能不一致`);
-                          return { code: `${l.code} ^ ${r.code}` };
+                          return { code: `${l.code}${op}${r.code}` };
                       }
                     : alt,
             );
@@ -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',
@@ -197,7 +205,7 @@ export function migrateOperator(
                     code: serialize(v),
                 };
             }
-            return unary(state, migrateExpr(state, a0), (v) => ({
+            return unary(state, migrateExpr(state, a0), (state, v) => ({
                 type: 'number',
                 code: `${op}${v.code}`,
             }));
@@ -307,7 +315,13 @@ export function migrateOperator(
                 return r;
             };
 
-            return binary(state, a(a0), a(a1), (l, r) => {
+            return binary(state, a(a0), a(a1), (state, 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

@@ -3,11 +3,14 @@ import type { Result } from './interface.js';
 import { serialize } from '@mirascript/mirascript/subtle';
 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 { return nil; } it != '' && it != '0' && it != 0 && it is not nan && !!it }",
+        );
     };
     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.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

@@ -4,6 +4,14 @@ 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;
@@ -65,3 +73,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,36 @@ function compile(expression: string): ExpressionCache {
     return compiled;
 }
 
+const kTemplateCache = Symbol('cloudpss.expression.templateCache');
+const kExpressionCache = Symbol('cloudpss.expression.expressionCache');
+
+/** 获取编译缓存 */
+function getCache(evaluator: Evaluator, template: boolean): LRUCache<string, EvalExpressionCache> {
+    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, 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,28 @@
+export {
+    isVmAny,
+    isVmArray,
+    isVmConst,
+    isVmContext,
+    isVmExtern,
+    isVmFunction,
+    isVmImmutable,
+    isVmModule,
+    isVmPrimitive,
+    isVmRecord,
+    isVmValue,
+    VmExtern,
+    VmFunction,
+    VmModule,
+} from '@mirascript/mirascript';
+export { serialize, serializePropName, serializeString, lib, operations } from '@mirascript/mirascript/subtle';
+export type {
+    VmAny,
+    VmArray,
+    VmConst,
+    VmContext,
+    VmImmutable,
+    VmPrimitive,
+    VmRecord,
+    VmUninitialized,
+    VmValue,
+} from '@mirascript/mirascript';

package/src/scope.ts

@@ -1,5 +1,13 @@
-import { createVmContext, isVmExtern, type VmAny, type VmContext, type VmValue } from '@mirascript/mirascript';
-import type { Context } from './context.js';
+import {
+    createVmContext,
+    isVmExtern,
+    type VmAny,
+    type VmArray,
+    type VmContext,
+    type VmRecord,
+    type VmValue,
+    isVmModule,
+} from '@mirascript/mirascript';
 import {
     type CompiledExpression,
     type Expression,
@@ -7,16 +15,27 @@ import {
     ExpressionTag,
     isExpression,
 } from './expression.js';
-import { DEFAULTS, evaluateEval } from './eval.js';
+import { evaluateEval } from './eval.js';
 import { parse } from './parser.js';
 import { TypeInfo } from './type.js';
+import type { Evaluator } from './main.js';
 const { hasOwn } = Object;
 
 const RAW = Symbol.for('@private/expression:raw');
 
 /** 是否需要创建代理对象 */
-function needsProxy(value: unknown): value is Expression | object {
-    return isExpression(value) || (value != null && typeof value == 'object');
+function needsProxy(value: ExpressionOrValue | undefined): value is Expression | VmArray | VmRecord {
+    // 先检查 isExpression，因为 'function' 也有可能是 Expression
+    if (isExpression(value)) {
+        return true;
+    }
+    if (value == null || typeof value != 'object') {
+        return false;
+    }
+    if (isVmExtern(value) || isVmModule(value)) {
+        return false;
+    }
+    return true;
 }
 
 /** 创建代理对象 */
@@ -53,13 +72,10 @@ class ScopeProxyHandler implements ProxyHandler<object> {
         if (p === RAW) {
             return target;
         }
-        const value = Reflect.get(target, p) as unknown;
-        if (!needsProxy(value)) {
+        const value = Reflect.get(target, p) as ExpressionOrValue;
+        if (isVmExtern(target) || !needsProxy(value)) {
             return value;
         }
-        if (isVmExtern(target)) {
-            return createProxy(value, this.scope, this.path);
-        }
         return createProxy(value, this.scope, [...this.path, p]);
     }
 }
@@ -70,58 +86,61 @@ export class Scope {
     static readonly MAX_RECURSION = 500;
     constructor(
         /** 生成环境的工厂函数 */
-        readonly scope?:
+        readonly scope:
             | ((key: string) => ExpressionOrValue | undefined)
-            | Record<string, ExpressionOrValue | undefined>,
+            | Record<string, ExpressionOrValue | undefined>
+            | null = null,
         /** 求值失败是否抛异常 */
         readonly throws = true,
         /** 执行环境名称 */
         readonly name = '<anonymous>',
-    ) {
-        if (scope == null) {
-            this.getter = (key) => this.context?.imported.get(key);
-        } else if (typeof scope == 'function') {
-            this.getter = (key) => {
-                const v = scope(key);
-                if (v === undefined) return this.context?.imported.get(key);
-                if (!needsProxy(v)) return v;
-                return createProxy(v, this, [key]) as VmValue;
-            };
-        } else {
-            this.getter = (key) => {
-                if (!hasOwn(scope, key)) return this.context?.imported.get(key);
-                const v = scope[key];
-                if (!needsProxy(v)) return v;
-                return createProxy(v, this, [key]) as VmValue;
-            };
-        }
-    }
+    ) {}
 
-    protected readonly getter: (key: string) => VmAny;
-    /** 上下文 */
-    protected context: Context | null = null;
+    /** 执行器上下文 */
+    protected evaluator: Evaluator | null = null;
     /** 求值计数 */
     protected evalCounter = 0;
-    /** 重置执行环境 */
-    reset(context: Context | null): () => void {
-        const oldContext = this.context;
+    /** 重置执行器 */
+    reset(evaluator: Evaluator | null): () => void {
+        const oldEvaluator = this.evaluator;
         const oldCounter = this.evalCounter;
-        this.context = context;
+        this.evaluator = evaluator;
         this.evalCounter = 0;
         return () => {
-            this.context = oldContext;
+            this.evaluator = oldEvaluator;
             this.evalCounter = oldCounter;
         };
     }
     /** 函数的执行环境，惰性求值 */
-    protected _proxy?: VmContext;
+    protected _proxy: VmContext | null = null;
     /** 函数的执行环境，惰性求值 */
     get proxy(): VmContext {
-        this._proxy ??= createVmContext(this.getter);
-        return this._proxy;
+        if (this._proxy != null) return this._proxy;
+        let getter: (key: string) => VmAny;
+        const { scope } = this;
+        if (scope == null) {
+            getter = (key) => this.evaluator?.imported.get(key);
+        } else if (typeof scope == 'function') {
+            getter = (key) => {
+                const v = scope(key);
+                if (v === undefined) return this.evaluator?.imported.get(key);
+                if (!needsProxy(v)) return v;
+                return createProxy(v, this, [key]) as VmValue;
+            };
+        } else {
+            getter = (key) => {
+                if (!hasOwn(scope, key)) return this.evaluator?.imported.get(key);
+                const v = scope[key];
+                if (!needsProxy(v)) return v;
+                return createProxy(v, this, [key]) as VmValue;
+            };
+        }
+        const proxy = createVmContext(getter);
+        this._proxy = proxy;
+        return proxy;
     }
 
-    /** 检查环境中是否有值 */
+    /** 检查环境中是否有值，不包含 evaluator 和 default context 中的值 */
     has(key: string): boolean {
         const { scope } = this;
         if (scope == null) return false;
@@ -134,8 +153,8 @@ export class Scope {
         return v !== undefined;
     }
 
-    /** 获取环境中的值 */
-    get(key: string): VmAny {
+    /** 获取环境中的值，不包含 evaluator 和 default context 中的值 */
+    get<V extends VmValue>(key: string): V | undefined {
         const { scope } = this;
         if (scope == null) return undefined;
         let v;
@@ -144,13 +163,11 @@ export class Scope {
         } else if (hasOwn(scope, key)) {
             v = scope[key];
         }
-        if (!isExpression(v)) return v;
-        return this.eval(v, [key]);
+        if (!isExpression(v)) return v satisfies VmValue | undefined as V | undefined;
+        return this.eval(v, [key]) satisfies VmValue as V;
     }
 
-    /**
-     * 表达式递归求值
-     */
+    /** 表达式递归求值 */
     eval(expression: Expression | CompiledExpression, path: readonly PropertyKey[]): VmValue {
         if (this.evalCounter >= Scope.MAX_RECURSION) {
             throw new Error(`Execution recursion exceeds limit`);
@@ -158,27 +175,24 @@ export class Scope {
 
         this.evalCounter++;
         try {
-            let result;
+            let result: VmValue | null = null;
             if (typeof expression == 'function') {
-                result = expression(this) as VmValue;
+                result = expression(this, this.evaluator!);
             } else {
-                const { context } = this;
-                if (!context) {
-                    throw new Error(`Undefined context`);
+                const { evaluator } = this;
+                if (!evaluator) {
+                    throw new Error(`Undefined evaluator`);
                 }
-                const exp = parse(context, expression.source, this.throws);
+                const exp = parse(evaluator, expression.source, this.throws, false);
                 if (exp.func != null) {
-                    result = evaluateEval(context, exp, this);
+                    result = evaluateEval(evaluator, exp, this);
                 } else if (exp.error != null) {
                     throw exp.error;
-                } else {
-                    result = DEFAULTS;
                 }
             }
-            if (result === DEFAULTS) return null;
             const tag = expression[ExpressionTag];
             if (!tag) return result;
-            return TypeInfo.to(result, TypeInfo.parse(tag));
+            return TypeInfo.to(result, tag);
         } catch (ex) {
             throw new Error(`${(ex as Error).message || String(ex)}\nIn ${this.name}: @ ${path.join('/')}`);
         }