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

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,75 +72,99 @@ 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]);
     }
 }
 
+/** 最大求值计数 */
+const MAX_RECURSION = 500;
 /** 函数的执行环境 */
 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;
-            };
-        }
-    }
+    ) {}
+    /** 枚举环境中的值 */
+    enumerator: (() => Iterable<string>) | null | undefined = null;
+    /** 描述环境中的值 */
+    describer: ((key: string) => string | undefined) | null | undefined = null;
 
-    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;
+        let enumerate: () => Iterable<string>;
+        let describe: ((key: string) => string | undefined) | undefined;
+        const { scope, enumerator, describer } = this;
+        if (scope == null) {
+            getter = (key) => this.evaluator?.imported.get(key);
+            enumerate = () => this.evaluator?.imported.keys() ?? [];
+            describe = () => undefined;
+        } 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;
+            };
+        }
+        if (typeof enumerator == 'function') {
+            enumerate = () => {
+                const keys = enumerator();
+                const imported = this.evaluator?.imported.keys() ?? [];
+                return [...keys, ...imported];
+            };
+        } else {
+            enumerate = () => this.evaluator?.imported.keys() ?? [];
+        }
+        if (typeof describer == 'function') {
+            describe = (key) => {
+                const d = describer(key);
+                if (d) return d;
+                return undefined;
+            };
+        }
+        const proxy = createVmContext(getter, enumerate, describe);
+        this._proxy = proxy;
+        return proxy;
     }
 
-    /** 检查环境中是否有值 */
+    /** 检查环境中是否有值，不包含 evaluator 和 default context 中的值 */
     has(key: string): boolean {
         const { scope } = this;
         if (scope == null) return false;
@@ -134,8 +177,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,41 +187,34 @@ 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) {
+        if (this.evalCounter >= MAX_RECURSION) {
+            this.evalCounter = 0;
             throw new Error(`Execution recursion exceeds limit`);
         }
 
         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 exp = parse(context, expression.source, this.throws);
+                const { evaluator } = this;
+                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('/')}`);
         }

package/src/type.ts

@@ -1,5 +1,5 @@
 import type { TypeName, VmValue, VmValueMap } from '@mirascript/mirascript';
-import { lib } from '@mirascript/mirascript/subtle';
+import { convert } from '@mirascript/mirascript/subtle';
 
 /** 类型信息 */
 export type TypeInfo = 'string' | 'number' | 'boolean';
@@ -12,10 +12,11 @@ type TypeMap = VmValueMap & {
     s: string;
     f: number;
     b: boolean;
+    '': VmValue;
 };
 
 /** Ts 类型 */
-export type TsTypeOf<T extends TypeInfo | LegacyType> = TypeMap[T];
+export type TsTypeOf<T extends TypeInfo | LegacyType | '', I extends VmValue = VmValue> = T extends '' ? I : TypeMap[T];
 
 /** 兼容的旧类型 */
 export type LegacyType = 's' | 'f' | 'b';
@@ -48,38 +49,52 @@ export namespace TypeInfo {
     }
 
     /** 转换类型 */
-    export function to<T extends TypeInfo | LegacyType>(value: VmValue | undefined, type: T): TsTypeOf<T> {
-        /** 返回类型 */
-        type R = TsTypeOf<T>;
-        if (!type) return value as R;
+    export function to<T extends TypeInfo | LegacyType | '', I extends VmValue = VmValue, F = undefined>(
+        value: I | undefined,
+        type: T,
+        fallback?: F,
+    ): TsTypeOf<T> | Exclude<F, undefined> {
+        const c = converter(type);
+        return (c as typeof convert.toNumber)(value, fallback) as TsTypeOf<T>;
+    }
+
+    /** 不转换 */
+    function identity<T extends VmValue, F = undefined>(
+        value: T | undefined,
+        _fallback?: F,
+    ): T /* | Exclude<F, undefined>  */ {
+        if (value == null) return null as T;
+        return value;
+    }
+
+    /** 获取转换器 */
+    type Converters = {
+        string: typeof convert.toString;
+        s: typeof convert.toString;
+        number: typeof convert.toNumber;
+        f: typeof convert.toNumber;
+        boolean: typeof convert.toBoolean;
+        b: typeof convert.toBoolean;
+        '': typeof identity;
+    };
+    /** 获取转换器 */
+    export function converter<T extends TypeInfo | LegacyType | ''>(type: T): Converters[T] {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
         switch (type) {
             case 'b':
             case 'boolean':
-                return lib.to_boolean(value) as R;
+                return toBoolean as Converters[T];
             case 'f':
             case 'number':
-                return lib.to_number(value) as R;
+                return toNumber as Converters[T];
             case 's':
             case 'string':
-                return lib.to_string(value) as R;
+                return toString as Converters[T];
             default:
-                (type) satisfies never;
-                return value as R;
+                (type) satisfies '';
+                return identity as Converters[T];
         }
     }
 
-    /** 转换为字符串 */
-    export function toString(value: VmValue | undefined): string {
-        return lib.to_string(value);
-    }
-
-    /** 转换为数字 */
-    export function toNumber(value: VmValue | undefined): number {
-        return lib.to_number(value);
-    }
-
-    /** 转换为布尔值 */
-    export function toBoolean(value: VmValue | undefined): boolean {
-        return lib.to_boolean(value);
-    }
+    export const { toBoolean, toFormat, toNumber, toString } = convert;
 }

package/tests/analyze.ts

@@ -1,15 +1,54 @@
 import { Evaluator, Expression, Scope } from '../dist/index.js';
 
 const e = new Evaluator();
-const s = new Scope({}, false);
+e.import({ w: 123 });
+const s = new Scope({ sin: 12 }, false);
 
-describe.skip('Analyze', () => {
+describe('Analyze', () => {
     it('simple', () => {
-        expect(e.analyze(Expression('a+b'), s)).toEqual([['a'], ['b']]);
+        expect(e.analyze(Expression('  '), s)).toEqual([]);
+        expect(e.analyze(Expression('a + b + @c'), s)).toEqual([['a'], ['b'], ['@c']]);
+    });
+    it('bad', () => {
+        expect(e.analyze(Expression('a + '), s)).toEqual([]);
+        expect(e.analyze(Expression('a.b.'), s)).toEqual([]);
+        expect(() => e.analyze(Expression('a.b.'))).toThrow();
+    });
+    it('local', () => {
+        expect(e.analyze(Expression('let a = 12; a + nil'), s)).toEqual([]);
+        expect(e.analyze(Expression('let a = 12; a + nil'), s)).toEqual([]);
+        expect(e.analyze(Expression('let a = 12; a + b'), s)).toEqual([['b']]);
+    });
+    it('repeat', () => {
+        expect(e.analyze(Expression('a + b + a + a.b + b.c + a * a !. b'), s)).toEqual([
+            ['a'],
+            ['b'],
+            ['a', 'b'],
+            ['b', 'c'],
+        ]);
+    });
+    it('prefixed', () => {
+        expect(e.analyze(Expression('@@a + $b + c. $$ + $'), s)).toEqual([['@@a'], ['$b'], ['c', '$$'], ['$']]);
+    });
+    it('unicode', () => {
+        expect(e.analyze(Expression('变量.属性 + 变量2[索引] + 函数()'), s)).toEqual([
+            ['变量', '属性'],
+            ['变量2'],
+            ['索引'],
+            ['函数'],
+        ]);
     });
     it('access', () => {
-        expect(e.analyze(Expression('a.b[1]+b'), s)).toEqual([['a', 'b'], ['b']]);
-        expect(e.analyze(Expression('a.b["x"]+b'), s)).toEqual([['a', 'b', 'x'], ['b']]);
-        expect(e.analyze(Expression('a.b[x]+b'), s)).toEqual([['a', 'b'], ['x'], ['b']]);
+        expect(e.analyze(Expression('a .b [1]+b'), s)).toEqual([['a', 'b'], ['b']]);
+        expect(e.analyze(Expression('a. b["x"]+b'), s)).toEqual([['a', 'b'], ['b']]);
+        expect(e.analyze(Expression('a.b[x] + b + c.12.3'), s)).toEqual([['a', 'b'], ['x'], ['b'], ['c', 12, 3]]);
+    });
+    it('with lib', () => {
+        const e0 = new Evaluator();
+        const exp = Expression('sin(x) + y::z.t()::cos() + w.123');
+        expect(e.analyze(exp, s)).toEqual([['sin'], ['x'], ['z', 't'], ['y']]);
+        expect(e0.analyze(exp, s)).toEqual([['sin'], ['x'], ['z', 't'], ['y'], ['w', 123]]);
+        expect(e.analyze(exp)).toEqual([['x'], ['z', 't'], ['y']]);
+        expect(e0.analyze(exp)).toEqual([['x'], ['z', 't'], ['y'], ['w', 123]]);
     });
 });

package/tests/compile.ts

@@ -0,0 +1,65 @@
+import { Evaluator, Expression, Scope } from '../dist/index.js';
+
+const e = new Evaluator({
+    logger: {
+        warn: () => void 0,
+        error: () => void 0,
+        info: () => void 0,
+        debug: () => void 0,
+    },
+});
+const s = new Scope({}, false);
+
+describe('Evaluator.compile should work correctly', () => {
+    it('should eval const', () => {
+        const result = e.compile(Expression('12'), false);
+        expect(result(s, e)).toBe(12);
+        expect(e.evaluate(result, s)).toBe(12);
+    });
+
+    it('should eval exp', () => {
+        const result = e.compile(Expression('exp(2)'), false);
+        expect(result(s, e)).toBe(Math.exp(2));
+        expect(e.evaluate(result, s)).toBe(Math.exp(2));
+    });
+
+    it('should eval error', () => {
+        const result = e.compile(Expression('exp+++'), false);
+        expect(result(s, e)).toBe(null);
+        expect(e.evaluate(result, s)).toBe(null);
+    });
+});
+
+describe('Evaluator.compile should convert result', () => {
+    it('should eval const', () => {
+        const result = e.compile(Expression('12', 'string'), false);
+        expect(result(s, e)).toBe('12');
+        expect(e.evaluate(result, s)).toBe('12');
+    });
+
+    it('should eval exp', () => {
+        const result = e.compile(Expression('exp(2)', 's'), false);
+        expect(result(s, e)).toBe(Math.exp(2).toString());
+        expect(e.evaluate(result, s)).toBe(Math.exp(2).toString());
+    });
+
+    it('should not convert defaults', () => {
+        {
+            const result = e.compile(Expression('nil', 's'), false);
+            expect(result(s, e)).toBe(null);
+            expect(e.evaluate(result, s, 1)).toBe(1);
+        }
+        {
+            // syntax error
+            const result = e.compile(Expression('exp+++', 's'), false);
+            expect(result(s, e)).toBe(null);
+            expect(e.evaluate(result, s, 1)).toBe(1);
+        }
+        {
+            // runtime error
+            const result = e.compile(Expression('x() + 1', 's'), false);
+            expect(result(s, e)).toBe(null);
+            expect(e.evaluate(result, s, 1)).toBe(1);
+        }
+    });
+});

package/tests/condition.ts

@@ -1,6 +1,16 @@
 import { Evaluator, type ExpressionSource, Scope } from '../dist/index.js';
 
-const e = new Evaluator();
+const e = new Evaluator({
+    logger: undefined,
+});
+const en = new Evaluator({
+    logger: {
+        warn: () => void 0,
+        error: () => void 0,
+        info: () => void 0,
+        debug: () => void 0,
+    },
+});
 const s = new Scope(undefined, false);
 
 describe('Evaluate conditions', () => {
@@ -9,7 +19,6 @@ describe('Evaluate conditions', () => {
         expect(e.evaluateCondition(false, s)).toBe(false);
     });
     it('can evaluate empty literals', () => {
-        // @ts-expect-error null
         expect(e.evaluateCondition(null, s)).toBe(true);
         expect(e.evaluateCondition(undefined, s)).toBe(true);
     });
@@ -18,20 +27,28 @@ describe('Evaluate conditions', () => {
         expect(e.evaluateCondition('true' as ExpressionSource<boolean>, s)).toBe(true);
         expect(e.evaluateCondition('false' as ExpressionSource<boolean>, s)).toBe(false);
     });
-    it('can convert to boolean', () => {
-        expect(e.evaluateCondition('""' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('nil' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('undefined' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('0' as ExpressionSource<boolean>, s)).toBe(true);
-        expect(e.evaluateCondition('nan' as ExpressionSource<boolean>, s)).toBe(true);
+    it('can evaluate to boolean', () => {
         expect(e.evaluateCondition('(false)' as ExpressionSource<boolean>, s)).toBe(false);
-
-        expect(e.evaluateCondition('""' as ExpressionSource<boolean>, s, false)).toBe(true);
-        expect(e.evaluateCondition('nil' as ExpressionSource<boolean>, s, false)).toBe(false);
-        expect(e.evaluateCondition('undefined' as ExpressionSource<boolean>, s, false)).toBe(false);
-        expect(e.evaluateCondition('0' as ExpressionSource<boolean>, s, false)).toBe(true);
-        expect(e.evaluateCondition('nan' as ExpressionSource<boolean>, s, false)).toBe(true);
+        expect(e.evaluateCondition('(true)' as ExpressionSource<boolean>, s)).toBe(true);
         expect(e.evaluateCondition('(false)' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(e.evaluateCondition('(true)' as ExpressionSource<boolean>, s, false)).toBe(true);
+    });
+    it('can evaluate to nil', () => {
+        expect(e.evaluateCondition('{}' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(e.evaluateCondition('{}' as ExpressionSource<boolean>, s, false)).toBe(false);
+    });
+    it('do not convert to boolean', () => {
+        expect(en.evaluateCondition('""' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('nil' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('undefined' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('0' as ExpressionSource<boolean>, s)).toBe(true);
+        expect(en.evaluateCondition('nan' as ExpressionSource<boolean>, s)).toBe(true);
+
+        expect(en.evaluateCondition('""' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('nil' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('undefined' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('0' as ExpressionSource<boolean>, s, false)).toBe(false);
+        expect(en.evaluateCondition('nan' as ExpressionSource<boolean>, s, false)).toBe(false);
     });
     it('can evaluate complex', () => {
         expect(e.evaluateCondition('12>3' as ExpressionSource<boolean>, s)).toBe(true);
@@ -42,8 +59,7 @@ describe('Evaluate conditions', () => {
         expect(e.evaluateCondition('12<=3' as ExpressionSource<boolean>, s)).toBe(false);
     });
     it('can return default on error', () => {
-        expect(e.evaluateCondition('12>>3' as ExpressionSource<boolean>, undefined, true)).toBe(true);
-        // @ts-expect-error null
-        expect(e.evaluateCondition('12>>3' as ExpressionSource<boolean>, null, false)).toBe(false);
+        expect(en.evaluateCondition('12>>3' as ExpressionSource<boolean>, undefined, true)).toBe(true);
+        expect(en.evaluateCondition('12>>3' as ExpressionSource<boolean>, null, false)).toBe(false);
     });
 });