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

package/tests/definition.ts

@@ -1,42 +1,229 @@
+import { jest } from '@jest/globals';
 import * as def from '../dist/definitions.js';
+import { Expression } from '../dist/expression.js';
 
 describe('definitions', () => {
     it('should handle parameter', () => {
-        expect(def.Parameter()).toBeDefined();
-        expect(def.isParameter(def.Parameter())).toBe(true);
+        expect(def.isParameter(null)).toBe(false);
+        expect(def.isParameter(() => void 0)).toBe(false);
+        expect(def.isParameter({ key: '', name: '', description: '', type: 'real', value: 0 })).toBe(true);
+        expect(def.isParameter({ type: 'label' })).toBe(false);
+        expect(def.isParameter({ name: '', description: '', items: [] })).toBe(false);
     });
 
     it('should handle parameter group', () => {
-        expect(def.ParameterGroup()).toBeDefined();
-        expect(def.isParameterGroup(def.ParameterGroup())).toBe(true);
+        expect(def.isParameterGroup(null)).toBe(false);
+        expect(def.isParameterGroup(() => void 0)).toBe(false);
+        expect(def.isParameterGroup({ name: '', description: '', items: [] })).toBe(true);
+        expect(def.isParameterGroup({ items: [] })).toBe(false);
+        expect(def.isParameterGroup({ key: '', name: '', description: '', items: [] })).toBe(false);
     });
 
     it('should handle parameter decoration', () => {
-        expect(def.ParameterDecoration()).toBeDefined();
-        expect(def.isParameterDecoration(def.ParameterDecoration())).toBe(true);
+        expect(def.isParameterDecoration(null)).toBe(false);
+        expect(def.isParameterDecoration(() => void 0)).toBe(false);
+        expect(def.isParameterDecoration({ type: 'label' })).toBe(true);
+        expect(def.isParameterDecoration({ name: '', description: '', items: [] })).toBe(false);
+        expect(def.isParameterDecoration({ key: '', name: '', description: '', type: 'real', value: 0 })).toBe(false);
     });
 
     it('should handle parameter decoration group', () => {
-        expect(def.ParameterDecorationGroup()).toBeDefined();
-        expect(def.isParameterDecorationGroup(def.ParameterDecorationGroup())).toBe(true);
+        expect(def.isParameterDecorationGroup(null)).toBe(false);
+        expect(def.isParameterDecorationGroup(() => void 0)).toBe(false);
+        expect(def.isParameterDecorationGroup({ items: [] })).toBe(true);
+        expect(def.isParameterDecorationGroup({ name: '', description: '', items: [] })).toBe(false);
     });
 
     it('should handle variable', () => {
-        expect(def.Variable()).toBeDefined();
-        expect(def.isVariable(def.Variable())).toBe(true);
+        expect(def.isVariable(null)).toBe(false);
+        expect(def.isVariable(() => void 0)).toBe(false);
+        expect(def.isVariable({ key: '', value: 0 })).toBe(true);
+        expect(def.isVariable({ key: '', name: '', description: '', type: 'real', value: 0 })).toBe(false);
     });
 
     it('should handle choice', () => {
-        expect(def.Choice()).toBeDefined();
-        expect(def.isChoice(def.Choice())).toBe(true);
+        expect(def.isChoice(null)).toBe(false);
+        expect(def.isChoice(() => void 0)).toBe(false);
+        expect(def.isChoice({ name: '', description: '' })).toBe(true);
+        expect(def.isChoice({ key: null, name: '', description: '' })).toBe(true);
+        expect(def.isChoice({ key: '', name: '', description: '' })).toBe(true);
+    });
+
+    it('should handle constraint', () => {
+        expect(def.isConstraint(null)).toBe(false);
+        expect(def.isConstraint(() => void 0)).toBe(false);
+        expect(def.isConstraint({ name: '', description: '' })).toBe(false);
+        expect(def.isConstraint({ key: null, name: '', description: '' })).toBe(false);
+        expect(def.isConstraint({ key: '', name: '', description: '' })).toBe(false);
+        expect(def.isConstraint({ message: '' })).toBe(false);
+        expect(def.isConstraint({ condition: '' })).toBe(false);
+        expect(def.isConstraint({ message: '', condition: '' })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', level: 'error' })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', level: 'error', messageData: '' })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', messageData: {} })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', messageData: null })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', messageData: undefined })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', messageData: () => void 0 })).toBe(true);
+        expect(def.isConstraint({ message: '', condition: '', messageData: 1 })).toBe(false);
+    });
 
-        expect(def.Choice('x').key).toBe('x');
-        expect(def.isChoice(def.Choice('x'))).toBe(true);
+    it('should generate track id', () => {
+        const mockRandom = jest
+            .spyOn(Math, 'random')
+            .mockReturnValueOnce(0)
+            .mockReturnValueOnce(1 - 2 ** -53);
+        const id1 = def.generateTrackId();
+        const id2 = def.generateTrackId();
+        mockRandom.mockRestore();
+        expect(id1).toBe(1);
+        expect(id2).toBe(0x7fff_ffff);
+    });
 
-        expect(def.Choice(0).key).toBe(0);
-        expect(def.isChoice(def.Choice(0))).toBe(true);
+    it('should convert argument value', () => {
+        // @ts-expect-error 未知类型
+        expect(def.toArgumentValue(undefined, { type: 'xxx', key: '', name: '', description: '', value: 1 })).toBe(
+            null,
+        );
+        // @ts-expect-error 测试 undefined 输入
+        expect(def.toArgumentValue(undefined, { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(0);
+        expect(def.toArgumentValue(null, { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(0);
+        expect(def.toArgumentValue('12', { type: 'real', key: '', name: '', description: '', value: 1 })).toBe(12);
+        expect(def.toArgumentValue(null, { type: 'text', key: '', name: '', description: '', value: '1' })).toBe('');
+        expect(def.toArgumentValue(12, { type: 'text', key: '', name: '', description: '', value: '1' })).toBe('12');
+        expect(
+            def.toArgumentValue(null, { type: 'grouped', key: '', name: '', description: '', value: {}, items: [] }),
+        ).toBe(null);
 
-        expect(def.Choice(false).key).toBe(false);
-        expect(def.isChoice(def.Choice(false))).toBe(true);
+        expect(
+            def.toArgumentValue(null, { type: 'choice', key: '', name: '', description: '', value: 1, choices: [] }),
+        ).toBe(0);
+        expect(
+            def.toArgumentValue(null, {
+                type: 'choice',
+                key: '',
+                name: '',
+                description: '',
+                value: 1,
+                choices: [{ key: '0', name: '', description: '' }],
+            }),
+        ).toBe('0');
+        expect(
+            def.toArgumentValue(null, {
+                type: 'choice',
+                key: '',
+                name: '',
+                description: '',
+                value: 1,
+                choices: [
+                    { key: '0', name: '', description: '' },
+                    { key: 1, name: '', description: '' },
+                ],
+            }),
+        ).toBe('0');
+        expect(def.toArgumentValue(null, { type: 'logical', key: '', name: '', description: '', value: 1 })).toBe(0);
+        expect(
+            def.toArgumentValue(null, {
+                type: 'logical',
+                key: '',
+                name: '',
+                description: '',
+                value: false,
+                choices: [
+                    { key: 0, name: '', description: '' },
+                    { key: 1, name: '', description: '' },
+                ],
+            }),
+        ).toBe(0);
+        expect(
+            def.toArgumentValue(null, {
+                type: 'logical',
+                key: '',
+                name: '',
+                description: '',
+                value: true,
+            }),
+        ).toBe(false);
+        expect(
+            def.toArgumentValue(null, {
+                type: 'logical',
+                key: '',
+                name: '',
+                description: '',
+                value: 'true',
+            }),
+        ).toBe('');
+        expect(
+            def.toArgumentValue(null, {
+                type: 'logical',
+                key: '',
+                name: '',
+                description: '',
+                value: 'true',
+                choices: [
+                    { key: '0', name: '', description: '' },
+                    { key: '1', name: '', description: '' },
+                ],
+            }),
+        ).toBe('0');
+        expect(
+            def.toArgumentValue(null, {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: [],
+            }),
+        ).toStrictEqual([]);
+        expect(
+            def.toArgumentValue(1, {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: [],
+            }),
+        ).toStrictEqual([1]);
+        expect(
+            def.toArgumentValue('', {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: [],
+            }),
+        ).toStrictEqual([0]);
+        expect(
+            def.toArgumentValue('', {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: Expression(''),
+            }),
+        ).toStrictEqual(['']);
+        expect(
+            def.toArgumentValue(['', '1'], {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: [],
+            }),
+        ).toStrictEqual([0, 1]);
+        expect(
+            def.toArgumentValue(['', '1'], {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: Expression(''),
+            }),
+        ).toStrictEqual(['', '1']);
     });
 });

package/tests/eval-complex.ts

@@ -44,18 +44,15 @@ describe('Evaluator should work correctly', () => {
         const result = e.evaluate(Expression('a.0'), s);
         expect(result).toBe(36);
     });
-    it('should eval deep with extern', () => {
+    it('should not eval deep with extern', () => {
         const s = new Scope(
             {
-                a: new VmExtern([Expression('b.0 + d.0')]),
-                b: new VmExtern([Expression('c.0 + d.0')]),
-                c: new VmExtern([12]),
-                d: new VmExtern([Expression('c.0')]),
+                a: new VmExtern([Expression('1')]),
             },
             false,
         );
-        const result = e.evaluate(Expression('a.0'), s);
-        expect(result).toBe(36);
+        const result = e.evaluate<VmExtern>(Expression('a.0'), s);
+        expect(result?.value).toStrictEqual(Expression('1'));
     });
     it('should eval deep with compiled expression', () => {
         const s = new Scope(
@@ -132,7 +129,7 @@ describe('Evaluator should work correctly', () => {
             a: new ArrayBuffer(0),
             v: new DataView(new ArrayBuffer(0)),
             test() {
-                expect(this).toBeProxy();
+                expect(this).not.toBeProxy();
                 expect(this.d).not.toBeProxy();
                 expect(this.r).not.toBeProxy();
                 // eslint-disable-next-line @typescript-eslint/unbound-method
@@ -144,7 +141,7 @@ describe('Evaluator should work correctly', () => {
             },
         });
         const s = new Scope({ o }, true);
-        expect(e.evaluate(Expression('o.test()'), s)).toBe(3);
-        expect(e.evaluate(Expression('o.z'), s)).toBe(3);
+        expect(e.evaluate<VmExtern>(Expression('o.test()'), s)?.value).toStrictEqual(Expression('o.y+o.x.p'));
+        expect(e.evaluate<VmExtern>(Expression('o.z'), s)?.value).toStrictEqual(Expression('o.y+o.x.p'));
     });
 });

package/tests/eval.ts

@@ -1,9 +1,17 @@
-import { Evaluator, Expression, Scope } from '../dist/index.js';
+import { Evaluator, Expression, Scope, VmFunction } from '../dist/index.js';
 
-const e = new Evaluator();
+const e = new Evaluator({
+    logger: {
+        warn: () => void 0,
+        error: () => void 0,
+        info: () => void 0,
+        debug: () => void 0,
+    },
+});
 const s = new Scope({}, false);
+const st = new Scope(null, true);
 
-describe('Evaluator should work correctly', () => {
+describe('Evaluator.evaluate should work correctly', () => {
     it('should eval const', () => {
         const result = e.evaluate(Expression('12'), s);
         expect(result).toBe(12);
@@ -16,11 +24,39 @@ describe('Evaluator should work correctly', () => {
 
     it('should eval error', () => {
         const result = e.evaluate(Expression('exp+++'), s);
-        expect(result).toBe(undefined);
+        expect(result).toBe(null);
+    });
+
+    it('should eval null', () => {
+        const result = e.evaluate(null, s);
+        expect(result).toBe(null);
+    });
+    it('should eval undefined', () => {
+        const result = e.evaluate(undefined, s);
+        expect(result).toBe(null);
+    });
+    it('should eval value', () => {
+        {
+            const result = e.evaluate(1, s);
+            expect(result).toBe(1);
+        }
+        {
+            const result = e.evaluate('', s);
+            expect(result).toBe('');
+        }
+        {
+            const result = e.evaluate(false, s);
+            expect(result).toBe(false);
+        }
+    });
+    it('should eval vm function', () => {
+        const f = VmFunction(() => 1);
+        const result = e.evaluate(f, s);
+        expect(result).toBe(f);
     });
 });
 
-describe('Evaluator should convert result', () => {
+describe('Evaluator.evaluate should convert result', () => {
     it('should eval const', () => {
         const result = e.evaluate(Expression('12', 'string'), s);
         expect(result).toBe('12');
@@ -31,12 +67,23 @@ describe('Evaluator should convert result', () => {
         expect(result).toBe(Math.exp(2).toString());
     });
 
-    it('should not convert when error', () => {
-        // syntax error
-        const result = e.evaluate(Expression('exp+++', 's'), s, 1);
-        expect(result).toBe(1);
-        // runtime error
-        const result2 = e.evaluate(Expression('x() + 1', 's'), s, 1);
-        expect(result2).toBe(1);
+    it('should not convert defaults', () => {
+        {
+            const result = e.evaluate(Expression('nil', 's'), s, 1);
+            expect(result).toBe(1);
+        }
+        {
+            // syntax error
+            expect(() => e.evaluate(Expression('exp+++', 's'), undefined, 1)).toThrow();
+        }
+        {
+            // syntax error cached
+            expect(() => e.evaluate(Expression('exp+++', 's'), st)).toThrow();
+        }
+        {
+            // runtime error
+            const result = e.evaluate(Expression('x() + 1', 's'), s, 1);
+            expect(result).toBe(1);
+        }
     });
 });

package/tests/import.ts

@@ -2,8 +2,22 @@ import { VmFunction } from '@mirascript/mirascript';
 import { Evaluator, Expression, Scope } from '../dist/index.js';
 import { lib } from '@mirascript/mirascript/subtle';
 
-const e = new Evaluator();
-const e2 = new Evaluator();
+const e = new Evaluator({
+    logger: {
+        warn: () => void 0,
+        error: () => void 0,
+        info: () => void 0,
+        debug: () => void 0,
+    },
+});
+const e2 = new Evaluator({
+    logger: {
+        warn: () => void 0,
+        error: () => void 0,
+        info: () => void 0,
+        debug: () => void 0,
+    },
+});
 const s = new Scope(undefined, false);
 
 describe('Import should work correctly', () => {
@@ -11,7 +25,7 @@ describe('Import should work correctly', () => {
         e.import({ add: (x: number, y: number) => x + y });
         expect(e.evaluate(Expression('add(1,2)'), s)).toBe(3);
         expect(e.evaluate(Expression('add::type()'), s)).toBe('extern');
-        expect(e2.evaluate(Expression('add(1,2)'), s)).toBe(undefined);
+        expect(e2.evaluate(Expression('add(1,2)'), s)).toBe(null);
         expect(e2.evaluate(Expression('add::type()'), s)).toBe('nil');
     });
 
@@ -19,7 +33,7 @@ describe('Import should work correctly', () => {
         e.import({ add: (x: number, y: number) => x + y });
         expect(e.evaluate(Expression('add(1,2)'), s)).toBe(3);
         e.import({ add: undefined });
-        expect(e.evaluate(Expression('add(1,2)'), s)).toBe(undefined);
+        expect(e.evaluate(Expression('add(1,2)'), s)).toBe(null);
     });
 
     it('can replace modules', () => {

package/tests/main.ts

@@ -0,0 +1,9 @@
+import { Evaluator } from '../dist/main.js';
+
+describe('Evaluator', () => {
+    it('should have logger', () => {
+        expect(new Evaluator().logger).toBeTruthy();
+        expect(new Evaluator(null).logger).toBeTruthy();
+        expect(new Evaluator({}).logger).toBeTruthy();
+    });
+});

package/tests/migrate.ts

@@ -0,0 +1,77 @@
+import { migrateMathJs } from '@cloudpss/expression/migrate';
+import type { ExpressionSource } from '../dist/expression.js';
+import { Scope } from '../dist/scope.js';
+
+const s = new Scope({
+    a: [1, 2, 3],
+    m: [
+        [1, 2],
+        [3, 4],
+    ],
+    f: 1,
+    s: 's',
+    b: false,
+});
+
+describe('migrate', () => {
+    it('should migrate constant expressions', () => {
+        const m = (e: string) => migrateMathJs(e as ExpressionSource, false, undefined);
+        expect(m('')).toBe('');
+        expect(m('   ')).toBe('');
+        expect(m('undefined')).toBe('');
+        expect(m('null')).toBe('nil');
+        expect(m('true')).toBe('true');
+        expect(m('false')).toBe('false');
+        expect(m('123')).toBe('123');
+        expect(m('-123.45e+6')).toBe('-123.45e+6');
+        expect(m('+123.45e-6')).toBe('+123.45e-6');
+        expect(m('.45e-6')).toBe('4.5e-7');
+    });
+
+    it.each([
+        ['sin(0)', 'sin(0)'],
+        ['sin(f)', 'sin(f)'],
+        ['f', 'f'],
+        ['$a', '$a'],
+        ['$a + 1', 'matrix.add($a, 1)'],
+        ['size(a)[1]', 'len(a)'],
+        ['size(s)[1]', 'len(chars(s))'],
+        ['(a).length', 'len((a))'],
+        ['(s).length', 'len(chars((s)))'],
+        ['count(s)', 'len(chars(s))'],
+        ['b ? true : false', 'b'],
+        ['b ? false : true', '!b'],
+        ['is(f, "string") ? count(f) != 0 : false', "type(f) == 'string' && f != ''"],
+        ['is(f, "string") ? equalText(f, "xyz") : false', "f == 'xyz'"],
+        ['b ? 1 : 2', 'if b { 1 } else { 2 }'],
+        ['f >0', 'f > 0'],
+        ['f >=0', 'f >= 0'],
+        ['f <0', 'f < 0'],
+        ['1<f<2', '1 < f && f < 2'],
+        ['1 + 2 + f', '1 + 2 + f'],
+        ['PI', '@pi'],
+        ['pi', '@pi'],
+        ['E', '@e'],
+        ['e', '@e'],
+        ['[1,2,3]', '[1, 2, 3]'],
+        ['[1;2;3]', '[[1], [2], [3]]'],
+        ['{ x: 1, y: 2 }', '(x: 1, y: 2)'],
+        ['{ x: f, y: b }', '(x: f, y: b)'],
+        ['equalText("a", "b")', "'a' == 'b'"],
+        ['equalText("a", s)', "'a' == s"],
+        ['equalText(s, "b")', "s == 'b'"],
+        ['equalText(s, f)', 's == to_string(f)'],
+        ['b | b', 'to_number(b || b)'],
+        ['b & b', 'to_number(b && b)'],
+        ['not b', '!b'],
+        ['12!', 'factorial(12)'],
+        ['- b', '-b'],
+        ['+ b', '+b'],
+        ['- f', '-f'],
+        ['size(f)', 'matrix.size(f)'],
+        ['size(m)', 'matrix.size(m)'],
+    ])('should migrate expression: %s', (f, t) => {
+        const m = (e: string) => migrateMathJs(e as ExpressionSource, false, s);
+        expect(m(f)).toBe(t);
+    });
+});

package/tests/scope.ts

@@ -10,7 +10,7 @@ describe('Scope should work correctly', () => {
     it('can create from function', () => {
         const s = new Scope((k) => (k === 'a' ? 12 : undefined), false);
         expect(e.evaluate(Expression('a'), s)).toBe(12);
-        expect(e.evaluate(Expression('b'), s)).toBe(undefined);
+        expect(e.evaluate(Expression('b'), s)).toBe(null);
     });
     it('can create from object', () => {
         const s = new Scope({ a: 12, b: Expression('a + 1') }, false);
@@ -22,8 +22,8 @@ describe('Scope should work correctly', () => {
 describe('Scope should not leak dangerous objects', () => {
     it('should not access prototype fields', () => {
         const s = new Scope({}, false);
-        expect(e.evaluate(Expression('__proto__'), s)).toBe(undefined);
-        expect(e.evaluate(Expression('toString'), s)).toBe(undefined);
+        expect(e.evaluate(Expression('__proto__'), s)).toBe(null);
+        expect(e.evaluate(Expression('toString'), s)).toBe(null);
     });
     it('should access same name props', () => {
         const s = new Scope({ ['__proto__']: 12, toString: 'x' }, false);

package/tests/template.ts

@@ -0,0 +1,36 @@
+import { Evaluator, Expression, Scope } from '../dist/index.js';
+
+const e = new Evaluator();
+const s = new Scope({}, false);
+
+describe('Evaluator.template should work correctly', () => {
+    it('should eval null', () => {
+        const result = e.template(null, s);
+        expect(result).toBe('');
+    });
+    it('should eval undefined', () => {
+        const result = e.template(undefined, s);
+        expect(result).toBe('');
+    });
+    it('should eval empty', () => {
+        const result = e.template('', s);
+        expect(result).toBe('');
+    });
+    it('should eval const', () => {
+        const result = e.template('12', s);
+        expect(result).toBe('12');
+    });
+
+    it('should eval exp', () => {
+        const result = e.template('$(1 + 1)', s);
+        expect(result).toBe('2');
+    });
+    it('should eval error', () => {
+        const result = e.template('$(exp+++)', s);
+        expect(result).toBe('$(exp+++)');
+    });
+    it('should eval bad type', () => {
+        // @ts-expect-error 测试错误输入
+        expect(() => e.template(new Date(0), s)).toThrow(TypeError);
+    });
+});

package/dist/context.d.ts

@@ -1,41 +0,0 @@
-import { LRUCache } from 'lru-cache';
-import type { ExpressionCache } from './parser.js';
-import type { VmValue } from '@mirascript/mirascript';
-/** 日志 */
-export interface Logger {
-    /**
-     * error
-     */
-    error(...args: unknown[]): void;
-    /**
-     * warning
-     */
-    warn(...args: unknown[]): void;
-    /**
-     * info
-     */
-    info(...args: unknown[]): void;
-    /**
-     * debug
-     */
-    debug(...args: unknown[]): void;
-}
-/** 选项 */
-export interface Options {
-    /** 日志 */
-    logger: Logger;
-    /** 表达式缓存 */
-    expressionCacheSize: number;
-}
-/** 执行上下文 */
-export declare class Context {
-    constructor(options?: Partial<Options>);
-    readonly imported: Map<string, VmValue>;
-    /** Logger */
-    get logger(): Logger;
-    /** 选项 */
-    readonly options: Options;
-    /** 表达式缓存 */
-    readonly expressionCache: LRUCache<string, ExpressionCache, unknown>;
-}
-//# sourceMappingURL=context.d.ts.map

package/dist/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACrC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD,SAAS;AACT,MAAM,WAAW,MAAM;IACnB;;OAEG;IACH,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAChC;;OAEG;IACH,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAC/B;;OAEG;IACH,IAAI,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;IAC/B;;OAEG;IACH,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;CACnC;AAED,SAAS;AACT,MAAM,WAAW,OAAO;IACpB,SAAS;IACT,MAAM,EAAE,MAAM,CAAC;IACf,YAAY;IACZ,mBAAmB,EAAE,MAAM,CAAC;CAC/B;AAOD,YAAY;AACZ,qBAAa,OAAO;gBACJ,OAAO,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;IAItC,QAAQ,CAAC,QAAQ,uBAA8B;IAC/C,aAAa;IACb,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD,SAAS;IACT,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B,YAAY;IACZ,QAAQ,CAAC,eAAe,6CAAC;CAC5B"}

package/dist/context.js

@@ -1,18 +0,0 @@
-import { LRUCache } from 'lru-cache';
-const defaultOptions = {
-    logger: console,
-    expressionCacheSize: 50,
-};
-/** 执行上下文 */
-export class Context {
-    constructor(options) {
-        this.imported = new Map();
-        this.options = { ...options, ...defaultOptions };
-        this.expressionCache = new LRUCache({ max: this.options.expressionCacheSize });
-    }
-    /** Logger */
-    get logger() {
-        return this.options.logger ?? console;
-    }
-}
-//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAgCrC,MAAM,cAAc,GAAY;IAC5B,MAAM,EAAE,OAAO;IACf,mBAAmB,EAAE,EAAE;CAC1B,CAAC;AAEF,YAAY;AACZ,MAAM,OAAO,OAAO;IAChB,YAAY,OAA0B;QAI7B,aAAQ,GAAG,IAAI,GAAG,EAAmB,CAAC;QAH3C,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG,OAAO,EAAE,GAAG,cAAc,EAAE,CAAC;QACjD,IAAI,CAAC,eAAe,GAAG,IAAI,QAAQ,CAA0B,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;IAC5G,CAAC;IAED,aAAa;IACb,IAAI,MAAM;QACN,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC;IAC1C,CAAC;CAMJ"}

package/jest.config.js

@@ -1,3 +0,0 @@
-import { config } from '../jest.config.js';
-
-export default { ...config };