epic-designer-gold 0.0.4 → 0.0.6

package/packages/utils/__test__/common/deepEqual.test.ts

@@ -1,105 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { deepEqual } from '../../';
-
-describe('deepEqual', () => {
-  it('应当返回 true 当两个简单对象相等时', () => {
-    const obj1 = { a: 1, b: 2, c: 3 };
-    const obj2 = { a: 1, b: 2, c: 3 };
-
-    expect(deepEqual(obj1, obj2)).toBe(true);
-  });
-
-  it('应当返回 false 当两个简单对象不相等时', () => {
-    const obj1 = { a: 1, b: 2, c: 3 };
-    const obj2 = { a: 1, b: 2, c: 4 };
-
-    expect(deepEqual(obj1, obj2)).toBe(false);
-  });
-
-  it('应当返回 true 当两个对象的嵌套结构相等时', () => {
-    const obj1 = { a: { b: { c: 1 } } };
-    const obj2 = { a: { b: { c: 1 } } };
-
-    expect(deepEqual(obj1, obj2)).toBe(true);
-  });
-
-  it('应当返回 false 当两个对象的嵌套结构不相等时', () => {
-    const obj1 = { a: { b: { c: 1 } } };
-    const obj2 = { a: { b: { c: 2 } } };
-
-    expect(deepEqual(obj1, obj2)).toBe(false);
-  });
-
-  it('应当返回 true 当两个数组相等时', () => {
-    const arr1 = [1, 2, 3];
-    const arr2 = [1, 2, 3];
-
-    expect(deepEqual(arr1, arr2)).toBe(true);
-  });
-
-  it('应当返回 false 当两个数组不相等时', () => {
-    const arr1 = [1, 2, 3];
-    const arr2 = [1, 2, 4];
-
-    expect(deepEqual(arr1, arr2)).toBe(false);
-  });
-
-  it('应当返回 true 当两个对象相等但属性顺序不同', () => {
-    const obj1 = { a: 1, b: 2, c: 3 };
-    const obj2 = { c: 3, b: 2, a: 1 };
-
-    expect(deepEqual(obj1, obj2)).toBe(true);
-  });
-
-  it('应当返回 true 当两个对象相等且有环形引用时', () => {
-    const obj1: any = { a: 1 };
-    obj1.b = obj1;
-    const obj2: any = { a: 1 };
-    obj2.b = obj2;
-
-    expect(deepEqual(obj1, obj2)).toBe(true);
-  });
-
-  it('应当返回 false 当两个对象相等但一个有环形引用时', () => {
-    const obj1: any = { a: 1 };
-    obj1.b = obj1;
-    const obj2 = { a: 1, b: obj1 };
-
-    expect(deepEqual(obj1, obj2)).toBe(false);
-  });
-
-  it('应当返回 true 当忽略指定属性时对象仍然相等', () => {
-    const obj1 = { a: 1, b: 2, c: 3 };
-    const obj2 = { a: 1, b: 2 };
-
-    expect(deepEqual(obj1, obj2, ['c'])).toBe(true);
-  });
-
-  it('应当返回 false 当忽略指定属性时对象不相等', () => {
-    const obj1 = { a: 1, b: 2, c: 3 };
-    const obj2 = { a: 1, b: 3 };
-
-    expect(deepEqual(obj1, obj2, ['c'])).toBe(false);
-  });
-
-  it('应当返回 true 当忽略指定属性时对象仍然相等，且忽略的属性具有不同的值', () => {
-    const obj1 = { a: { b: 1 }, c: 2 };
-    const obj2 = { a: { b: 1 }, c: 3 };
-
-    expect(deepEqual(obj1, obj2, ['c'])).toBe(true);
-  });
-
-  it('应当返回 true 当两个空对象相等时', () => {
-    const obj1 = {};
-    const obj2 = {};
-
-    expect(deepEqual(obj1, obj2)).toBe(true);
-  });
-
-  it('应当返回 false 当一个对象为空而另一个对象非空时', () => {
-    const obj1 = {};
-    const obj2 = { a: 1 };
-
-    expect(deepEqual(obj1, obj2)).toBe(false);
-  });
-});

package/packages/utils/__test__/common/findSchemaById.test.ts

@@ -1,80 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { findSchemaById } from '../../';
-
-describe('findSchemaById 函数测试', () => {
-    const schemas = [
-        {
-            type: "page",
-            id: "root",
-            label: "页面",
-            children: [
-                {
-                    label: "表单",
-                    type: "form",
-                    componentProps: {
-                        name: "default",
-                        labelWidth: "100px",
-                        labelLayout: "fixed",
-                        labelCol: {
-                            span: 5
-                        },
-                        wrapperCol: {
-                            span: 19
-                        }
-                    },
-                    children: [
-                        {
-                            label: "输入框",
-                            type: "input",
-                            field: "input_ttuyobv9",
-                            input: true,
-                            componentProps: {
-                                placeholder: "请输入"
-                            },
-                            id: "input_ttuyobv9"
-                        },
-                        {
-                            label: "数字输入框",
-                            type: "number",
-                            field: "number_m7ogpi26",
-                            input: true,
-                            componentProps: {
-                                style: {
-                                    width: "100%"
-                                },
-                                placeholder: "请输入"
-                            },
-                            id: "number_m7ogpi26"
-                        }
-                    ],
-                    id: "form_oyvwbf00"
-                }
-            ],
-            componentProps: {
-                style: {
-                    padding: "16px"
-                }
-            }
-        }
-    ];
-
-    it('应该返回正确的节点', () => {
-        const result = findSchemaById(schemas, 'input_ttuyobv9');
-        expect(result).toEqual({
-            label: "输入框",
-            type: "input",
-            field: "input_ttuyobv9",
-            input: true,
-            componentProps: {
-                placeholder: "请输入"
-            },
-            id: "input_ttuyobv9"
-        });
-    });
-
-    it('应该抛出错误当节点不存在', () => {
-        expect(() => findSchemaById(schemas, 'non_existent_id')).toThrowError(
-            '没有查询到id为non_existent_id的节点'
-        );
-    });
-});

package/packages/utils/__test__/common/findSchemas.test.ts

@@ -1,98 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { findSchemas } from '../../';
-
-describe('findSchemas 函数测试', () => {
-    const schemas = [
-        {
-            type: "page",
-            id: "root",
-            label: "页面",
-            children: [
-                {
-                    label: "表单",
-                    type: "form",
-                    componentProps: {
-                        name: "default",
-                        labelWidth: "100px",
-                        labelLayout: "fixed",
-                        labelCol: {
-                            span: 5
-                        },
-                        wrapperCol: {
-                            span: 19
-                        }
-                    },
-                    children: [
-                        {
-                            label: "输入框",
-                            type: "input",
-                            field: "input_ttuyobv9",
-                            input: true,
-                            componentProps: {
-                                placeholder: "请输入"
-                            },
-                            id: "input_ttuyobv9"
-                        },
-                        {
-                            label: "数字输入框",
-                            type: "number",
-                            field: "number_m7ogpi26",
-                            input: true,
-                            componentProps: {
-                                style: {
-                                    width: "100%"
-                                },
-                                placeholder: "请输入"
-                            },
-                            id: "number_m7ogpi26"
-                        }
-                    ],
-                    id: "form_oyvwbf00"
-                }
-            ],
-            componentProps: {
-                style: {
-                    padding: "16px"
-                }
-            }
-        }
-    ];
-
-    it('应该返回所有符合条件的节点', () => {
-        const result = findSchemas(schemas, (item) => item.type === 'input');
-        expect(result).toHaveLength(1);
-        expect(result[0].id).toBe('input_ttuyobv9');
-    });
-
-    it('应该在 once 为 true 时返回一个符合条件的节点', () => {
-        const result = findSchemas(schemas, (item) => item.type === 'number', true);
-        expect(result).toEqual({
-            label: "数字输入框",
-            type: "number",
-            field: "number_m7ogpi26",
-            input: true,
-            componentProps: {
-                style: {
-                    width: "100%"
-                },
-                placeholder: "请输入"
-            },
-            id: "number_m7ogpi26"
-        });
-    });
-
-    it('应该根据过滤函数跳过某些节点的子节点', () => {
-        const result = findSchemas(schemas, (item) => item.type === 'input', false, (item) => item.type !== 'form');
-        expect(result).toHaveLength(0);
-    });
-
-    it('应该返回 false 当 once 为 true 时没有符合条件的节点', () => {
-        const result = findSchemas(schemas, (item) => item.type === 'checkbox', true);
-        expect(result).toBe(false);
-    });
-
-    it('应该返回所有符合条件的节点，当没有符合条件的节点时返回空数组', () => {
-        const result = findSchemas(schemas, (item) => item.type === 'checkbox');
-        expect(result).toHaveLength(0);
-    });
-});

package/packages/utils/__test__/common/getFormSchemas.test.ts

@@ -1,124 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getFormSchemas } from '../../';
-
-describe('getFormSchemas 函数测试', () => {
-  const schemas = [
-    {
-      type: "page",
-      id: "root",
-      label: "页面",
-      children: [
-        {
-          label: "表单",
-          type: "form",
-          componentProps: {
-            name: "default",
-            labelWidth: "100px",
-            labelLayout: "fixed",
-            labelCol: {
-              span: 5
-            },
-            wrapperCol: {
-              span: 19
-            }
-          },
-          children: [
-            {
-              label: "输入框",
-              type: "input",
-              field: "input_ttuyobv9",
-              input: true,
-              componentProps: {
-                placeholder: "请输入"
-              },
-              id: "input_ttuyobv9"
-            },
-            {
-              label: "数字输入框",
-              type: "number",
-              field: "number_m7ogpi26",
-              input: true,
-              componentProps: {
-                style: {
-                  width: "100%"
-                },
-                placeholder: "请输入"
-              },
-              id: "number_m7ogpi26"
-            },
-          ],
-          id: "form_oyvwbf00"
-        }
-      ],
-      componentProps: {
-        style: {
-          padding: "16px"
-        }
-      }
-    }
-  ];
-
-  it('应该返回指定表单名称中的输入字段', () => {
-    const result = getFormSchemas(schemas, 'default');
-    expect(result).toHaveLength(2);
-    expect(result).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: 'input_ttuyobv9' }),
-      expect.objectContaining({ id: 'number_m7ogpi26' })
-    ]));
-  });
-
-  it('应该使用默认的表单名称', () => {
-    const result = getFormSchemas(schemas);
-    expect(result).toHaveLength(2);
-    expect(result).toEqual(expect.arrayContaining([
-      expect.objectContaining({ id: 'input_ttuyobv9' }),
-      expect.objectContaining({ id: 'number_m7ogpi26' })
-    ]));
-  });
-
-  it('应该返回空数组当表单没有输入字段', () => {
-    const emptySchemas = [
-      {
-        type: "page",
-        id: "root",
-        label: "页面",
-        children: [
-          {
-            label: "表单",
-            type: "form",
-            componentProps: {
-              name: "emptyForm",
-              labelWidth: "100px",
-              labelLayout: "fixed",
-              labelCol: {
-                span: 5
-              },
-              wrapperCol: {
-                span: 19
-              }
-            },
-            children: [
-              {
-                label: "非输入框",
-                type: "text",
-                componentProps: {
-                  placeholder: "不是输入框"
-                },
-                id: "text_field"
-              }
-            ],
-            id: "form_empty"
-          }
-        ],
-        componentProps: {
-          style: {
-            padding: "16px"
-          }
-        }
-      }
-    ];
-
-    const result = getFormSchemas(emptySchemas, 'emptyForm');
-    expect(result).toHaveLength(0);
-  });
-});

package/packages/utils/__test__/common/getMatchedById.test.ts

@@ -1,79 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getMatchedById } from '../../';
-
-// 示例数据
-const schemas = [
-    {
-        type: "page",
-        id: "root",
-        label: "页面",
-        children: [
-            {
-                label: "表单",
-                type: "form",
-                componentProps: {
-                    name: "default",
-                    labelWidth: "100px",
-                    labelLayout: "fixed",
-                    labelCol: {
-                        span: 5
-                    },
-                    wrapperCol: {
-                        span: 19
-                    }
-                },
-                children: [
-                    {
-                        label: "输入框",
-                        type: "input",
-                        field: "input_ttuyobv9",
-                        input: true,
-                        componentProps: {
-                            placeholder: "请输入"
-                        },
-                        id: "input_ttuyobv9"
-                    },
-                    {
-                        label: "数字输入框",
-                        type: "number",
-                        field: "number_m7ogpi26",
-                        input: true,
-                        componentProps: {
-                            style: {
-                                width: "100%"
-                            },
-                            placeholder: "请输入"
-                        },
-                        id: "number_m7ogpi26"
-                    }
-                ],
-                id: "form_oyvwbf00"
-            }
-        ],
-        componentProps: {
-            style: {
-                padding: "16px"
-            }
-        }
-    }
-];
-
-// 测试用例
-describe('getMatchedById', () => {
-    it('应该找到正确的节点路径', () => {
-        const idToFind = 'number_m7ogpi26';
-        const result = getMatchedById(schemas, idToFind);
-
-        expect(result).toHaveLength(3); // 路径长度应为 3
-        expect(result[0].id).toBe('root');
-        expect(result[1].id).toBe('form_oyvwbf00');
-        expect(result[2].id).toBe('number_m7ogpi26');
-    });
-
-    it('应该返回空数组当节点不存在时', () => {
-        const idToFind = 'non_existent_id';
-        const result = getMatchedById(schemas, idToFind);
-
-        expect(result).toHaveLength(0);
-    });
-});

package/packages/utils/__test__/common/getUUID.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getUUID } from '../../';
-
-describe('getUUID 函数测试', () => {
-  it('应该生成指定长度的 UUID', () => {
-    const length = 10;
-    const uuid = getUUID(length);
-    expect(uuid.length).toBe(length);
-    expect(uuid).toMatch(/^[a-z0-9]+$/); // 验证 UUID 是由小写字母和数字组成
-  });
-
-  it('应该生成长度在 1 到 11 之间的 UUID', () => {
-    for (let length = 1; length <= 11; length++) {
-      const uuid = getUUID(length);
-      expect(uuid.length).toBe(length);
-    }
-  });
-
-  it('生成的 UUID 应该是唯一的', () => {
-    const numTests = 1000; // 测试生成 UUID 的数量
-    const uuids = new Set<string>();
-
-    for (let i = 0; i < numTests; i++) {
-      const uuid = getUUID();
-      uuids.add(uuid);
-    }
-
-    expect(uuids.size).toBe(numTests);
-  });
-});

package/packages/utils/__test__/common/getValueByPath.test.ts

@@ -1,54 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { getValueByPath } from '../../';
-
-describe('getValueByPath 函数测试', () => {
-    const data = {
-        user: {
-            profile: {
-                name: 'John Doe',
-                age: 30,
-                address: {
-                    city: 'New York',
-                    zip: '10001'
-                }
-            },
-            settings: {
-                theme: 'dark'
-            }
-        }
-    };
-
-    it('应该返回存在路径的值', () => {
-        expect(getValueByPath(data, 'user.profile.name')).toBe('John Doe');
-        expect(getValueByPath(data, 'user.profile.age')).toBe(30);
-        expect(getValueByPath(data, 'user.profile.address.city')).toBe('New York');
-    });
-
-    it('对于不存在的路径，应该返回默认值', () => {
-        expect(getValueByPath(data, 'user.profile.nonExistingField', '默认值')).toBe('默认值');
-        expect(getValueByPath(data, 'user.nonExistingField', '默认值')).toBe('默认值');
-    });
-
-    it('当路径为空时，应该返回默认值', () => {
-        expect(getValueByPath(data, '', '默认值')).toBe('默认值');
-    });
-
-    it('处理解析到 undefined 的路径', () => {
-        expect(getValueByPath(data, 'user.settings.nonExistingField', '默认值')).toBe('默认值');
-    });
-
-    it('应该处理包含嵌套对象的路径', () => {
-        expect(getValueByPath(data, 'user.profile.address.zip')).toBe('10001');
-    });
-
-    it('应该处理包含数组的路径', () => {
-        const dataWithArray = {
-            user: {
-                profile: {
-                    names: ['John', 'Jane']
-                }
-            }
-        };
-        expect(getValueByPath(dataWithArray, 'user.profile.names.1')).toBe('Jane');
-    });
-});

package/packages/utils/__test__/common/mapSchemas.test.ts

@@ -1,98 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { findSchemas } from '../../';
-
-describe('findSchemas 函数测试', () => {
-  const schemas = [
-    {
-      type: "page",
-      id: "root",
-      label: "页面",
-      children: [
-        {
-          label: "表单",
-          type: "form",
-          componentProps: {
-            name: "default",
-            labelWidth: "100px",
-            labelLayout: "fixed",
-            labelCol: {
-              span: 5
-            },
-            wrapperCol: {
-              span: 19
-            }
-          },
-          children: [
-            {
-              label: "输入框",
-              type: "input",
-              field: "input_ttuyobv9",
-              input: true,
-              componentProps: {
-                placeholder: "请输入"
-              },
-              id: "input_ttuyobv9"
-            },
-            {
-              label: "数字输入框",
-              type: "number",
-              field: "number_m7ogpi26",
-              input: true,
-              componentProps: {
-                style: {
-                  width: "100%"
-                },
-                placeholder: "请输入"
-              },
-              id: "number_m7ogpi26"
-            }
-          ],
-          id: "form_oyvwbf00"
-        }
-      ],
-      componentProps: {
-        style: {
-          padding: "16px"
-        }
-      }
-    }
-  ];
-
-  it('应该返回所有符合条件的节点', () => {
-    const result = findSchemas(schemas, (item) => item.type === 'input');
-    expect(result).toHaveLength(1);
-    expect(result[0].id).toBe('input_ttuyobv9');
-  });
-
-  it('应该在 once 为 true 时返回一个符合条件的节点', () => {
-    const result = findSchemas(schemas, (item) => item.type === 'number', true);
-    expect(result).toEqual({
-      label: "数字输入框",
-      type: "number",
-      field: "number_m7ogpi26",
-      input: true,
-      componentProps: {
-        style: {
-          width: "100%"
-        },
-        placeholder: "请输入"
-      },
-      id: "number_m7ogpi26"
-    });
-  });
-
-  it('应该根据过滤函数跳过某些节点的子节点', () => {
-    const result = findSchemas(schemas, (item) => item.type === 'input', false, (item) => item.type !== 'form');
-    expect(result).toHaveLength(0);
-  });
-
-  it('应该返回 false 当 once 为 true 时没有符合条件的节点', () => {
-    const result = findSchemas(schemas, (item) => item.type === 'checkbox', true);
-    expect(result).toBe(false);
-  });
-
-  it('应该返回空数组当没有符合条件的节点时', () => {
-    const result = findSchemas(schemas, (item) => item.type === 'checkbox');
-    expect(result).toHaveLength(0);
-  });
-});