epic-designer-gold 0.0.0 → 0.0.1

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

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,98 @@
+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);
+  });
+});