@cloudpss/expression 0.6.0-alpha.19 → 0.6.0-alpha.20

package/tests/definition.ts

@@ -84,7 +84,6 @@ describe('definitions', () => {
         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(
             null,
         );
@@ -108,7 +107,7 @@ describe('definitions', () => {
                 value: 1,
                 choices: [{ key: '0', name: '', description: '' }],
             }),
-        ).toBe('0');
+        ).toBe('');
         expect(
             def.toArgumentValue(null, {
                 type: 'choice',
@@ -121,8 +120,9 @@ describe('definitions', () => {
                     { key: 1, name: '', description: '' },
                 ],
             }),
-        ).toBe('0');
+        ).toBe('');
         expect(def.toArgumentValue(null, { type: 'logical', key: '', name: '', description: '', value: 1 })).toBe(null);
+        expect(def.toArgumentValue('0', { type: 'logical', key: '', name: '', description: '', value: 1 })).toBe(0);
         expect(
             def.toArgumentValue(null, {
                 type: 'logical',
@@ -135,7 +135,7 @@ describe('definitions', () => {
                     { key: 1, name: '', description: '' },
                 ],
             }),
-        ).toBe(0);
+        ).toBe(null);
         expect(
             def.toArgumentValue(null, {
                 type: 'logical',
@@ -166,7 +166,7 @@ describe('definitions', () => {
                     { key: '1', name: '', description: '' },
                 ],
             }),
-        ).toBe('0');
+        ).toBe('');
         expect(
             def.toArgumentValue(null, {
                 type: 'multiSelect',
@@ -196,7 +196,7 @@ describe('definitions', () => {
                 value: [1],
                 choices: [],
             }),
-        ).toStrictEqual([]);
+        ).toStrictEqual(null);
         expect(
             def.toArgumentValue('', {
                 type: 'multiSelect',
@@ -206,7 +206,7 @@ describe('definitions', () => {
                 value: [1],
                 choices: Expression(''),
             }),
-        ).toStrictEqual(['']);
+        ).toStrictEqual(null);
         expect(
             def.toArgumentValue(['', '1', '  2 '], {
                 type: 'multiSelect',
@@ -216,7 +216,37 @@ describe('definitions', () => {
                 value: [1],
                 choices: [],
             }),
-        ).toStrictEqual([1, 2]);
+        ).toStrictEqual(null);
+        expect(
+            def.toArgumentValue(['0', '1', '  2 '], {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [1],
+                choices: [],
+            }),
+        ).toStrictEqual([0, 1, 2]);
+        expect(
+            def.toArgumentValue(['0', '1', '  2 '], {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: [],
+                choices: [],
+            }),
+        ).toStrictEqual([0, 1, 2]);
+        expect(
+            def.toArgumentValue([1, 2], {
+                type: 'multiSelect',
+                key: '',
+                name: '',
+                description: '',
+                value: ['1'],
+                choices: [],
+            }),
+        ).toStrictEqual(['1', '2']);
         expect(
             def.toArgumentValue(['', '1', '  2 '], {
                 type: 'multiSelect',
@@ -226,6 +256,6 @@ describe('definitions', () => {
                 value: [1],
                 choices: Expression(''),
             }),
-        ).toStrictEqual(['', '1', '  2 ']);
+        ).toStrictEqual(null);
     });
 });

package/tests/eval-complex.ts

@@ -102,7 +102,7 @@ describe('Evaluator should work correctly', () => {
         const result = e.evaluate(Expression('a + a + a + a + a + a + a + a + a + a'), s);
         expect(result).toBe(10);
     });
-    it('should report loop', () => {
+    it('should report loop by scope', () => {
         const s = new Scope(
             {
                 a: Expression('b'),
@@ -111,6 +111,17 @@ describe('Evaluator should work correctly', () => {
             },
             true,
         );
+        expect(() => e.evaluate(Expression('a'), s)).toThrow(/Execution recursion exceeds limit/);
+    });
+    it('should report loop by mirascript', () => {
+        const s = new Scope(
+            {
+                a: Expression('fn x{b}x()'),
+                b: Expression('fn x{c}x()'),
+                c: Expression('fn x{a}x()'),
+            },
+            true,
+        );
         expect(() => e.evaluate(Expression('a'), s)).toThrow(/Maximum call depth exceeded/);
     });
 

package/tests/main.ts

@@ -6,4 +6,53 @@ describe('Evaluator', () => {
         expect(new Evaluator(null).logger).toBeTruthy();
         expect(new Evaluator({}).logger).toBeTruthy();
     });
+
+    describe('can evaluate choices', () => {
+        const e = new Evaluator();
+
+        it('on logical type', () => {
+            const c0 = e.evaluateChoices({ type: 'logical', value: null as never }, null);
+            expect(c0.length).toBe(2);
+            expect(c0[0].key).toBe(false);
+            expect(c0[1].key).toBe(true);
+
+            const c1 = e.evaluateChoices(
+                {
+                    type: 'logical',
+                    // @ts-expect-error Incomplete choice definition
+                    choices: [{}, { key: true, name: 'Yes' }],
+                    value: null as never,
+                },
+                null,
+            );
+            expect(c1.length).toBe(2);
+            expect(c1[0].key).toBe(false);
+            expect(c1[1].key).toBe(true);
+            expect(c1[0].name).toBe('');
+            expect(c1[1].name).toBe('Yes');
+
+            const c2 = e.evaluateChoices(
+                {
+                    type: 'logical',
+                    // @ts-expect-error Incomplete choice definition
+                    choices: [{ key: 0 }, { key: '1' }, { key: 2 }],
+                    value: null as never,
+                },
+                null,
+            );
+            expect(c2.length).toBe(2);
+            expect(c2[0].key).toBe(0);
+            expect(c2[1].key).toBe(1);
+
+            const c3 = e.evaluateChoices({ type: 'logical', choices: [], value: 0 }, null);
+            expect(c3.length).toBe(2);
+            expect(c3[0].key).toBe(0);
+            expect(c3[1].key).toBe(1);
+
+            const c4 = e.evaluateChoices({ type: 'logical', value: 'x' }, null);
+            expect(c4.length).toBe(2);
+            expect(c4[0].key).toBe('0');
+            expect(c4[1].key).toBe('1');
+        });
+    });
 });

package/tests/migrate.ts

@@ -273,6 +273,27 @@ describe('migrate', () => {
         [`sum(m)`, `sum(m::flatten())`, 10],
         [`prod([1,2,3])`, `product([1, 2, 3])`, 6],
         [`prod(f)`, `product(f)`, 1],
+        [`abs(f) + round(f) + f`, `abs(f) + round(f) + f`, 3],
+        [
+            `abs([1,2,3;-4,-5,-6])`,
+            `matrix.entrywise([[1, 2, 3], [-4, -5, -6]], nil, abs)`,
+            [
+                [1, 2, 3],
+                [4, 5, 6],
+            ],
+        ],
+        [`max(1, 2, f) + f`, `max(1, 2, f) + f`, 3],
+        [`min(1, 2, f) + f`, `min(1, 2, f) + f`, 2],
+        [
+            `max([1,2;3,4], 1)`,
+            dedent`
+                max([[1, 2], [3, 4]], 1)
+                // # 转换日志
+                // - W: 函数行为可能不一致: max
+                // # 原始 math.js 表达式
+                // max([1,2;3,4], 1)`,
+            VmError,
+        ],
     ])('should migrate expression: %s', (f, t, r) => {
         const migrated = migrateMathJs(f as ExpressionSource, false, s);
         expect(migrated).toBe(t);