@cicctencent/formily 0.0.0-stage → 0.0.1

package/tests/unit/transform.spec.ts

@@ -0,0 +1,253 @@
+import {
+  emitEnum,
+  getComponentName,
+  getXData,
+  isAnyOf,
+  isOneOf,
+  mergePropertiesColors,
+  oneOfTransformEnum,
+  simpleGenerationSchemaItem,
+} from '../../src/transform/utils/func';
+import { TransformCore } from '../../src/transform';
+
+describe('transform', () => {
+  it('setComponentProps', () => {
+    const testTransform = new TransformCore({ ctx: null, schema: {} });
+    const result = {};
+    testTransform.setComponentProps(result, { a: 1 });
+    expect(result).toEqual({ 'x-component-props': { a: 1 } });
+  });
+  it('setDecoratorProps', () => {
+    const testTransform = new TransformCore({ ctx: null, schema: {} });
+
+    /** Switch */
+    const result = { 'x-component': 'Switch' };
+    testTransform.setDecoratorProps(result);
+    expect(result).toEqual({
+      'x-component': 'Switch',
+      'x-decorator-props': { wrapperAlign: 'right', labelAlign: 'left' },
+    });
+    /** Switch */
+    // Other 代表非Switch组件
+    const result1 = { 'x-component': 'Other' };
+    testTransform.setDecoratorProps(result1);
+    expect(result1).toEqual({
+      'x-component': 'Other',
+      'x-decorator-props': {
+        layout: 'vertical',
+        labelAlign: 'left',
+        labelWrap: true,
+      },
+    });
+
+    /** description 说明 */
+    const result2 = { 'x-component': 'Other', description: '说明文案' };
+    testTransform.setDecoratorProps(result2);
+    expect(result2).toEqual({
+      'x-component': 'Other',
+      'x-decorator-props': {
+        layout: 'vertical',
+        labelAlign: 'left',
+        labelWrap: true,
+        tooltip: '说明文案',
+      },
+    });
+
+    /** description(input) 说明 */
+    const result3 = { 'x-component': 'Input', description: '说明文案' };
+    testTransform.setDecoratorProps(result3);
+    expect(result3).toEqual({
+      'x-component': 'Input',
+      'x-decorator-props': {
+        layout: 'vertical',
+        labelAlign: 'left',
+        labelWrap: true,
+      },
+      'x-component-props': { toolTip: '说明文案' },
+    });
+
+    /** 必填项 */
+    const result4 = { 'x-component': 'Input', asterisk: true };
+    testTransform.setDecoratorProps(result4);
+    expect(result4).toEqual({
+      'x-component': 'Input',
+      asterisk: true,
+      'x-decorator-props': {
+        layout: 'vertical',
+        labelAlign: 'left',
+        labelWrap: true,
+        asterisk: true,
+      },
+    });
+
+    /** 默认选项 */
+    const result5 = { 'x-component': 'Input', 'x-decorator-props': { a: 1 } };
+    testTransform.setDecoratorProps(result5);
+    expect(result5).toEqual({
+      'x-component': 'Input',
+      'x-decorator-props': {
+        layout: 'vertical',
+        labelAlign: 'left',
+        labelWrap: true,
+        a: 1,
+      },
+    });
+  });
+  it('compileEvent', () => {
+    const testTransform = new TransformCore({ ctx: null, schema: {} });
+    /** UploadButton */
+    const result1 = testTransform.compileEvent({
+      'x-component': 'UploadButton',
+    });
+    const keys = Object.keys(result1);
+    expect(keys.includes('@fileUpload')).toEqual(true);
+  });
+  /**
+   *   获取组件名
+   */
+  it('getComponentName', () => {
+    const result1 = getComponentName({ type: 'string' });
+    expect(result1).toEqual('Input');
+    const result2 = getComponentName({ enum: [] });
+    expect(result2).toEqual('Select');
+    /**  vjsf */
+    const result3 = getComponentName({ 'ui:widget': 'UploadWidget' });
+    expect(result3).toEqual('UploadButton');
+    const result4 = getComponentName({ format: 'color' });
+    expect(result4).toEqual('ColorPicker');
+    const result5 = getComponentName({ format: 'date-time' });
+    expect(result5).toEqual('DateTime');
+    const result6 = getComponentName({ anyOf: [] });
+    expect(result6).toEqual('AnyOf');
+  });
+
+  it('isAnyOf', () => {
+    expect(isAnyOf({ anyOf: [] })).toEqual(true);
+    expect(isAnyOf({ items: [] })).toEqual(false);
+  });
+
+  it('isOneOf', () => {
+    expect(isOneOf({ oneOf: [] })).toEqual(true);
+    expect(isOneOf({ items: [] })).toEqual(false);
+  });
+
+  it('simpleGenerationSchemaItem', () => {
+    expect(
+      simpleGenerationSchemaItem({
+        type: 'string',
+      })
+    ).toEqual({
+      type: 'string',
+      'x-component': 'Input',
+      'x-decorator': 'FormItem',
+      'x-decorator-props': {
+        layout: 'vertical',
+        labelAlign: 'left',
+        labelWrap: true,
+      },
+    });
+  });
+  it('getXData', () => {
+    expect(getXData({ 'x-data': true })).toEqual(true);
+    expect(getXData({ 'x-data': 1 })).toEqual(1);
+    expect(getXData({})).toEqual({});
+  });
+
+  it('emitEnum', () => {
+    const values = [1, 2, 3, 4, 5];
+    const names = ['a', 'b', 'c', 'd', 'e'];
+    expect(emitEnum(values, names)).toEqual([
+      { label: 'a', value: 1 },
+      { label: 'b', value: 2 },
+      { label: 'c', value: 3 },
+      { label: 'd', value: 4 },
+      { label: 'e', value: 5 },
+    ]);
+    /** formily 协议的 enum */
+    expect(emitEnum([{ label: 'a', value: 1 }])).toEqual([
+      { label: 'a', value: 1 },
+    ]);
+  });
+
+  it('oneOfTransformEnum', () => {
+    const result = oneOfTransformEnum([
+      {
+        title: '检查用户是否风测',
+        properties: {
+          name: {
+            const: 'goTovRiskEvaluate',
+            default: 'goTovRiskEvaluate',
+          },
+        },
+      },
+      {
+        title: '理财通授权-联系顾问',
+        properties: {
+          name: {
+            const: 'goWithConsultDetail',
+            default: 'goWithConsultDetail',
+          },
+        },
+      },
+    ]);
+    expect(result).toEqual([
+      { label: '检查用户是否风测', value: { name: 'goTovRiskEvaluate' } },
+      { label: '理财通授权-联系顾问', value: { name: 'goWithConsultDetail' } },
+    ]);
+  });
+
+  it('mergePropertiesColors', () => {
+    expect(mergePropertiesColors(null)).toEqual({});
+    expect(
+      mergePropertiesColors({
+        a: {},
+        b: {},
+        color: {},
+        backgroundColor: {},
+        background: {},
+        c: { format: 'color' },
+        d: { 'ui:widget': 'el-color-picker' },
+      })
+    ).toEqual({
+      color: {},
+      backgroundColor: {},
+      background: {},
+      c: { format: 'color' },
+      d: { 'ui:widget': 'el-color-picker' },
+    });
+  });
+
+  it('compileItem', () => {
+    const testTransform = new TransformCore({ ctx: null, schema: {} });
+
+    /** 类型推断组件名 */
+    const result1 = testTransform.compileItem({
+      type: 'string',
+    });
+    expect(result1['x-component']).toEqual('Input');
+    expect(result1.type).toEqual('string');
+    expect(result1['x-decorator']).toEqual('FormItem');
+    expect(result1['x-decorator-props']).toEqual({
+      layout: 'vertical',
+      labelAlign: 'left',
+      labelWrap: true,
+    });
+    expect(result1['x-component-props']).toHaveProperty('@getData');
+
+    /** formily 协议属性照搬 */
+    const result2 = testTransform.compileItem({
+      type: 'string',
+      required: true,
+    });
+    expect(result2.type).toEqual('string');
+    expect(result2['x-component']).toEqual('Input');
+    expect(result2.required).toEqual(true);
+    expect(result2['x-decorator']).toEqual('FormItem');
+    expect(result2['x-decorator-props']).toEqual({
+      layout: 'vertical',
+      labelAlign: 'left',
+      labelWrap: true,
+    });
+    expect(result2['x-component-props']).toHaveProperty('@getData');
+  });
+});

package/tests/unit/utils.spec.ts

@@ -0,0 +1,10 @@
+import { isSchemaConfig } from "../../src/utils/common"
+
+describe('utils', () => {
+
+  it("isSchemaConfig", () => {
+    expect(isSchemaConfig({ type: "1" })).toEqual(true);
+    expect(isSchemaConfig({ a: "1", "x-component": "Input" })).toEqual(true);
+    expect(isSchemaConfig({ a: "1", v: {} })).toEqual(false);
+  })
+})

package/tests/unit/validate.spec.ts

@@ -0,0 +1,256 @@
+import { case1, case2 } from "../fixtures/validate";
+import { getAnyOfConfig } from "../../src/utils/anyof_utils";
+import { FormilyValidate } from "../../src/validate";
+
+
+describe('validate',() =>{
+    it('insertPath',() => {
+      const validate = new FormilyValidate({schema:{},data:{}});
+      validate.insertPath('a');
+      expect(validate.path).toEqual('a');
+      validate.insertPath('b');
+      expect(validate.path).toEqual('a.b');
+    })
+
+    it('deletePath', () => {
+      const validate = new FormilyValidate({schema:{},data:{}});
+
+      validate.insertPath('a');
+      validate.insertPath('b');
+      validate.insertPath('c');
+      validate.deletePath();
+      expect(validate.path).toEqual('a.b');
+    })
+
+    it('getObjectValues', () =>{
+        const validate = new FormilyValidate({ schema: {}, data: {}})
+        validate.pathList = []
+        expect(validate.getObjectValues({ a: '1', v: '2',  d: {  c: '3' } })).toEqual(['1','2','3']);
+        expect(validate.getObjectValues({ a: '1', v: '2',  d: [ '3','3','3','3' ] })).toEqual(['1','2','3', '3', '3', '3']);
+
+        validate.pathList = ['d','c']
+        expect(validate.getObjectValues({ a: '1', v: '2',  d: {  c: '3' } })).toEqual(['3']);
+    })
+
+    it('getAnyOfConfig', () =>{
+        const vdata1 = [
+          {
+              title: '填写资讯ID',
+              required: [],
+              properties: {
+                  remarkUnderId: {
+                      type: 'string',
+                      'ui:options': {
+                          placeholder: '请输入备注',
+                      },
+                  },
+              },
+              'x-data': {
+                  activity: true, // 默认选项
+              },
+          },
+          {
+              title: '直接新增',
+              required: ['title'],
+              properties: {
+                  title: {
+                      type: 'string',
+                      default: '央行发布重磅报告！货币政策怎么走？注意那些风险，基金市场如何布局面？',
+                      'ui:options': {
+                          placeholder: '请输入文章标题',
+                      },
+                      'err:required': '请输入文章标题',
+                      required: true,
+                  },
+                  remark: {
+                      type: 'string',
+                      'ui:options': {
+                          placeholder: '请输入备注',
+                      },
+                  },
+              },
+          },
+      ];
+      expect(getAnyOfConfig(vdata1,{remarkUnderId: ''})).toEqual({
+        title: '填写资讯ID',
+        required: [],
+        properties: {
+            remarkUnderId: {
+                type: 'string',
+                'ui:options': {
+                    placeholder: '请输入备注',
+                },
+            },
+        },
+        'x-data': {
+            activity: true, // 默认选项
+        },
+    })
+    })
+
+    it('getAnyofPropertiesData', () =>{
+      const vdata1 = [
+        {
+            title: '填写资讯ID',
+            required: [],
+            properties: {
+                remarkUnderId: {
+                    type: 'string',
+                    'ui:options': {
+                        placeholder: '请输入备注',
+                    },
+                },
+            },
+            'x-data': {
+                activity: true, // 默认选项
+            },
+        },
+        {
+            title: '直接新增',
+            required: ['title'],
+            properties: {
+                title: {
+                    type: 'string',
+                    default: '央行发布重磅报告！货币政策怎么走？注意那些风险，基金市场如何布局面？',
+                    'ui:options': {
+                        placeholder: '请输入文章标题',
+                    },
+                    'err:required': '请输入文章标题',
+                    required: true,
+                },
+                remark: {
+                    type: 'string',
+                    'ui:options': {
+                        placeholder: '请输入备注',
+                    },
+                },
+            },
+        },
+    ];
+    //   expect(getAnyofPropertiesData(vdata1,{ remarkUnderId: '' }).config).toEqual(null);
+    })
+    it('parseExpression', ()=>{
+        const validate = new FormilyValidate({ schema: {}, data: {}})
+        const data = {
+          middlewares: [
+              {
+                  name: "goWithConsultDetail"
+              }
+          ],
+          handler: {
+              name: "goToPage",
+              options: {
+                  url: "",
+                  buryReportName: ""
+              }
+          },
+        type: "click"
+      }
+        expect(validate.parseExpression(['..a'],null,'{{$deps[0] == 222}}','d.f',case2)).toEqual(87);
+
+        expect(validate.parseExpression(['.name'],null,'{{$deps[0] === "goToHome"}}','handler.options',data)).toEqual("goToPage");
+    })
+    it('parseReactions',() =>{
+        const validate = new FormilyValidate({ schema: {}, data: { subscribeType: 98, test:null}});
+        validate.insertPath('subscribeType');
+
+        const data1 = {
+            title: "订阅id",
+            type: "string",
+            default: "",
+            "x-reactions": {
+                dependencies: [
+                    ".subscribeType"
+                ],
+                fulfill: {
+                    schema: {
+                        "x-component-props.cmdParams.subType": "{{$deps[0]}}"
+                    }
+                }
+            },
+        }
+        validate.parseReactions(data1)
+        expect(data1).toEqual({...data1,'x-component-props':{ cmdParams: { subType: 98}}})
+    })
+
+    it('checkResult',()=>{
+        const validate = new FormilyValidate({ schema: {}, data: { }});
+        expect(validate.checkResult(1)).toEqual(true);
+        expect(validate.checkResult(0)).toEqual(true);
+        expect(validate.checkResult([])).toEqual(false);
+        expect(validate.checkResult([1])).toEqual(true);
+        expect(validate.checkResult({})).toEqual(false);
+        expect(validate.checkResult({a:5})).toEqual(true);
+        expect(validate.checkResult({a:5, __validate_value__: false})).toEqual(false);
+        expect(validate.checkResult({a:5, __validate_value__: true})).toEqual(true);
+        expect(validate.checkResult(null)).toEqual(false);
+        expect(validate.checkResult('')).toEqual(false);
+        expect(validate.checkResult(undefined)).toEqual(false);
+        expect(validate.checkResult([{a:5}])).toEqual(true);
+        expect(validate.checkResult([{ a: 5, __validate_value__: false},{ b: 6, __validate_value__: true}])).toEqual(false);
+        expect(validate.checkResult([{ a: 5, __validate_value__: true},{ b: 6, __validate_value__: true}])).toEqual(true);
+    })
+
+    it('validateReactions',()=>{
+      const validate = new FormilyValidate({ schema: {}, data: { }});
+      const data1 = {
+        'x-reactions':{}
+      }
+      expect(validate.validateReactions(data1)).toEqual(false)
+      const data2 = {
+        'x-reactions':{
+          dependencies:['.showTitle'],
+          fulfill:{
+            schema:{
+              'x-visible': '{{$deps[0]===true}}'
+            }
+          }
+        }
+      }
+      expect(validate.validateReactions(data2)).toEqual(true)
+      const data3 = {
+        'x-reactions':{
+          dependencies:['.showTitle'],
+          fulfill:{
+            schema:{
+              'x-component-props.show': '{{$deps[0]}}'
+            }
+          }
+        }
+      }
+      expect(validate.validateReactions(data3)).toEqual(false)
+    })
+    it('calc',()=>{
+      const validate = new FormilyValidate({ schema: {}, data: { }});
+      expect(validate.calc("6===6")).toEqual(true)
+      expect(validate.calc("6")).toEqual(6)
+      expect(validate.calc("6 === '6'")).toEqual(false);
+      expect(validate.calc("6 == '6'")).toEqual(true);
+    })
+
+    it('calculateReactions', ()=>{
+      const validate = new FormilyValidate({ schema: {}, data: { }});
+      expect(validate.calculateReactions("{{6 === 6}}")).toEqual(true)
+      expect(validate.calculateReactions("{{6}}")).toEqual(true)
+      expect(validate.calculateReactions("{{6 == '6'}}")).toEqual(true)
+      expect(validate.calculateReactions("{{6 === '6'}}")).toEqual(false)
+    })
+
+    it("validate",()=>{
+      const data1 = { a: true , b: { b1: '111', b2: { c1: '222', c2: '333'}}};
+      const validate = new FormilyValidate({ schema: (case1 as any), data: data1});
+      expect(validate.validate()).toEqual([])
+
+
+      const data2 = { a: true , b: {  b2: { c1: '222'}}};
+      const validate2 = new FormilyValidate({ schema: (case1 as any), data: data2}).validate();
+      expect(validate2.length).toEqual(1)
+      expect(validate2[0].path).toEqual('b.b1')
+
+
+      const data3 = { a: true , b: { b1: '222',  b2: { c1: '222'}}};
+      const validate3 = new FormilyValidate({ schema: (case1 as any), data: data3}).validate();
+      expect(validate3.length).toEqual(1)
+      expect(validate3[0].path).toEqual('b.b2.c2')
+    })
+})

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "ESNext",
+        "declaration": true,
+        "noImplicitAny": false,
+        "removeComments": true,
+        "moduleResolution": "node",
+        "esModuleInterop": true,
+        "jsx": "preserve",
+        "noLib": false,
+        "target": "es6",
+        "sourceMap": true,
+        "allowSyntheticDefaultImports": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "useDefineForClassFields": true,
+        "baseUrl": ".",
+        "types": ["jest"],
+        "paths": {},
+        "lib": ["esnext", "dom", "dom.iterable", "scripthost"]
+    },
+    "exclude": ["node_modules"]
+}