befly 3.9.38 → 3.9.39

package/tests/syncDb-schema.test.ts

@@ -9,170 +9,171 @@
  * 注意：这些是模拟测试，实际数据库操作需要集成测试
  */
 
-import { describe, test, expect, beforeAll, mock } from 'bun:test';
-import { setDbType } from '../sync/syncDb/constants.js';
+import { describe, test, expect, beforeAll } from "bun:test";
+
+import { setDbType } from "../sync/syncDb/constants.js";
 
 // 设置数据库类型为 MySQL
-setDbType('mysql');
+setDbType("mysql");
 
 let tableExists: any;
 let getTableColumns: any;
 let getTableIndexes: any;
 
 beforeAll(async () => {
-    const schema = await import('../sync/syncDb/schema.js');
+    const schema = await import("../sync/syncDb/schema.js");
     tableExists = schema.tableExists;
     getTableColumns = schema.getTableColumns;
     getTableIndexes = schema.getTableIndexes;
 });
 
-describe('tableExists', () => {
-    test('sql 客户端未初始化时抛出错误', async () => {
+describe("tableExists", () => {
+    test("sql 客户端未初始化时抛出错误", async () => {
         try {
-            await tableExists(null, 'user');
+            await tableExists(null, "user");
             expect(true).toBe(false); // 不应该到这里
         } catch (error: any) {
-            expect(error.message).toBe('SQL 客户端未初始化');
+            expect(error.message).toBe("SQL 客户端未初始化");
         }
     });
 
-    test('传入有效 sql 客户端时正常执行', async () => {
+    test("传入有效 sql 客户端时正常执行", async () => {
         // 创建模拟 SQL 客户端
         const mockSql = Object.assign(
-            async function (strings: TemplateStringsArray, ...values: any[]) {
+            async function (_strings: TemplateStringsArray, ..._values: any[]) {
                 // 模拟 MySQL 查询返回
                 return [{ count: 1 }];
             },
             {
-                unsafe: async (query: string) => []
+                unsafe: async (_query: string) => []
             }
         );
 
-        const result = await tableExists(mockSql, 'user', 'test_db');
+        const result = await tableExists(mockSql, "user", "test_db");
         expect(result).toBe(true);
     });
 
-    test('表不存在时返回 false', async () => {
+    test("表不存在时返回 false", async () => {
         const mockSql = Object.assign(
-            async function (strings: TemplateStringsArray, ...values: any[]) {
+            async function (_strings: TemplateStringsArray, ..._values: any[]) {
                 return [{ count: 0 }];
             },
             {
-                unsafe: async (query: string) => []
+                unsafe: async (_query: string) => []
             }
         );
 
-        const result = await tableExists(mockSql, 'nonexistent', 'test_db');
+        const result = await tableExists(mockSql, "nonexistent", "test_db");
         expect(result).toBe(false);
     });
 });
 
-describe('getTableColumns', () => {
-    test('返回正确的列信息结构', async () => {
+describe("getTableColumns", () => {
+    test("返回正确的列信息结构", async () => {
         const mockSql = Object.assign(
-            async function (strings: TemplateStringsArray, ...values: any[]) {
+            async function (_strings: TemplateStringsArray, ..._values: any[]) {
                 // 模拟 MySQL information_schema 返回
                 return [
                     {
-                        COLUMN_NAME: 'id',
-                        DATA_TYPE: 'bigint',
+                        COLUMN_NAME: "id",
+                        DATA_TYPE: "bigint",
                         CHARACTER_MAXIMUM_LENGTH: null,
-                        IS_NULLABLE: 'NO',
+                        IS_NULLABLE: "NO",
                         COLUMN_DEFAULT: null,
-                        COLUMN_COMMENT: '主键ID',
-                        COLUMN_TYPE: 'bigint unsigned'
+                        COLUMN_COMMENT: "主键ID",
+                        COLUMN_TYPE: "bigint unsigned"
                     },
                     {
-                        COLUMN_NAME: 'user_name',
-                        DATA_TYPE: 'varchar',
+                        COLUMN_NAME: "user_name",
+                        DATA_TYPE: "varchar",
                         CHARACTER_MAXIMUM_LENGTH: 50,
-                        IS_NULLABLE: 'NO',
-                        COLUMN_DEFAULT: '',
-                        COLUMN_COMMENT: '用户名',
-                        COLUMN_TYPE: 'varchar(50)'
+                        IS_NULLABLE: "NO",
+                        COLUMN_DEFAULT: "",
+                        COLUMN_COMMENT: "用户名",
+                        COLUMN_TYPE: "varchar(50)"
                     },
                     {
-                        COLUMN_NAME: 'age',
-                        DATA_TYPE: 'bigint',
+                        COLUMN_NAME: "age",
+                        DATA_TYPE: "bigint",
                         CHARACTER_MAXIMUM_LENGTH: null,
-                        IS_NULLABLE: 'YES',
-                        COLUMN_DEFAULT: '0',
-                        COLUMN_COMMENT: '年龄',
-                        COLUMN_TYPE: 'bigint'
+                        IS_NULLABLE: "YES",
+                        COLUMN_DEFAULT: "0",
+                        COLUMN_COMMENT: "年龄",
+                        COLUMN_TYPE: "bigint"
                     }
                 ];
             },
             {
-                unsafe: async (query: string) => []
+                unsafe: async (_query: string) => []
             }
         );
 
-        const columns = await getTableColumns(mockSql, 'user', 'test_db');
+        const columns = await getTableColumns(mockSql, "user", "test_db");
 
         expect(columns.id).toBeDefined();
-        expect(columns.id.type).toBe('bigint');
+        expect(columns.id.type).toBe("bigint");
         expect(columns.id.nullable).toBe(false);
-        expect(columns.id.comment).toBe('主键ID');
+        expect(columns.id.comment).toBe("主键ID");
 
         expect(columns.user_name).toBeDefined();
-        expect(columns.user_name.type).toBe('varchar');
+        expect(columns.user_name.type).toBe("varchar");
         expect(columns.user_name.max).toBe(50);
         expect(columns.user_name.nullable).toBe(false);
-        expect(columns.user_name.defaultValue).toBe('');
+        expect(columns.user_name.defaultValue).toBe("");
 
         expect(columns.age).toBeDefined();
         expect(columns.age.nullable).toBe(true);
-        expect(columns.age.defaultValue).toBe('0');
+        expect(columns.age.defaultValue).toBe("0");
     });
 });
 
-describe('getTableIndexes', () => {
-    test('返回正确的索引信息结构', async () => {
+describe("getTableIndexes", () => {
+    test("返回正确的索引信息结构", async () => {
         const mockSql = Object.assign(
-            async function (strings: TemplateStringsArray, ...values: any[]) {
+            async function (_strings: TemplateStringsArray, ..._values: any[]) {
                 // 模拟 MySQL information_schema.STATISTICS 返回
                 // 注意：PRIMARY 索引被排除
                 return [
-                    { INDEX_NAME: 'idx_created_at', COLUMN_NAME: 'created_at' },
-                    { INDEX_NAME: 'idx_user_name', COLUMN_NAME: 'user_name' }
+                    { INDEX_NAME: "idx_created_at", COLUMN_NAME: "created_at" },
+                    { INDEX_NAME: "idx_user_name", COLUMN_NAME: "user_name" }
                 ];
             },
             {
-                unsafe: async (query: string) => []
+                unsafe: async (_query: string) => []
             }
         );
 
-        const indexes = await getTableIndexes(mockSql, 'user', 'test_db');
+        const indexes = await getTableIndexes(mockSql, "user", "test_db");
 
         // PRIMARY 索引被排除，不应存在
         expect(indexes.PRIMARY).toBeUndefined();
 
         expect(indexes.idx_created_at).toBeDefined();
-        expect(indexes.idx_created_at).toContain('created_at');
+        expect(indexes.idx_created_at).toContain("created_at");
 
         expect(indexes.idx_user_name).toBeDefined();
-        expect(indexes.idx_user_name).toContain('user_name');
+        expect(indexes.idx_user_name).toContain("user_name");
     });
 
-    test('复合索引包含多个列', async () => {
+    test("复合索引包含多个列", async () => {
         const mockSql = Object.assign(
-            async function (strings: TemplateStringsArray, ...values: any[]) {
+            async function (_strings: TemplateStringsArray, ..._values: any[]) {
                 // 模拟复合索引，同一索引名包含多个列
                 return [
-                    { INDEX_NAME: 'idx_composite', COLUMN_NAME: 'user_id' },
-                    { INDEX_NAME: 'idx_composite', COLUMN_NAME: 'created_at' }
+                    { INDEX_NAME: "idx_composite", COLUMN_NAME: "user_id" },
+                    { INDEX_NAME: "idx_composite", COLUMN_NAME: "created_at" }
                 ];
             },
             {
-                unsafe: async (query: string) => []
+                unsafe: async (_query: string) => []
             }
         );
 
-        const indexes = await getTableIndexes(mockSql, 'user', 'test_db');
+        const indexes = await getTableIndexes(mockSql, "user", "test_db");
 
         expect(indexes.idx_composite).toBeDefined();
         expect(indexes.idx_composite.length).toBe(2);
-        expect(indexes.idx_composite).toContain('user_id');
-        expect(indexes.idx_composite).toContain('created_at');
+        expect(indexes.idx_composite).toContain("user_id");
+        expect(indexes.idx_composite).toContain("created_at");
     });
 });

package/tests/syncDb-types.test.ts

@@ -8,11 +8,12 @@
  * - generateDefaultSql
  */
 
-import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
-import { setDbType } from '../sync/syncDb/constants.js';
+import { describe, test, expect, beforeAll } from "bun:test";
+
+import { setDbType } from "../sync/syncDb/constants.js";
 
 // 设置数据库类型为 MySQL
-setDbType('mysql');
+setDbType("mysql");
 
 // 动态导入以确保环境变量生效
 let isStringOrArrayType: any;
@@ -21,118 +22,118 @@ let resolveDefaultValue: any;
 let generateDefaultSql: any;
 
 beforeAll(async () => {
-    const types = await import('../sync/syncDb/types.js');
+    const types = await import("../sync/syncDb/types.js");
     isStringOrArrayType = types.isStringOrArrayType;
     getSqlType = types.getSqlType;
     resolveDefaultValue = types.resolveDefaultValue;
     generateDefaultSql = types.generateDefaultSql;
 });
 
-describe('isStringOrArrayType', () => {
-    test('string 类型返回 true', () => {
-        expect(isStringOrArrayType('string')).toBe(true);
+describe("isStringOrArrayType", () => {
+    test("string 类型返回 true", () => {
+        expect(isStringOrArrayType("string")).toBe(true);
     });
 
-    test('array_string 类型返回 true', () => {
-        expect(isStringOrArrayType('array_string')).toBe(true);
+    test("array_string 类型返回 true", () => {
+        expect(isStringOrArrayType("array_string")).toBe(true);
     });
 
-    test('number 类型返回 false', () => {
-        expect(isStringOrArrayType('number')).toBe(false);
+    test("number 类型返回 false", () => {
+        expect(isStringOrArrayType("number")).toBe(false);
     });
 
-    test('text 类型返回 false', () => {
-        expect(isStringOrArrayType('text')).toBe(false);
+    test("text 类型返回 false", () => {
+        expect(isStringOrArrayType("text")).toBe(false);
     });
 
-    test('array_text 类型返回 false', () => {
-        expect(isStringOrArrayType('array_text')).toBe(false);
+    test("array_text 类型返回 false", () => {
+        expect(isStringOrArrayType("array_text")).toBe(false);
     });
 });
 
-describe('resolveDefaultValue', () => {
-    test('null 值 + string 类型 => 空字符串', () => {
-        expect(resolveDefaultValue(null, 'string')).toBe('');
+describe("resolveDefaultValue", () => {
+    test("null 值 + string 类型 => 空字符串", () => {
+        expect(resolveDefaultValue(null, "string")).toBe("");
     });
 
-    test('null 值 + number 类型 => 0', () => {
-        expect(resolveDefaultValue(null, 'number')).toBe(0);
+    test("null 值 + number 类型 => 0", () => {
+        expect(resolveDefaultValue(null, "number")).toBe(0);
     });
 
     test('"null" 字符串 + number 类型 => 0', () => {
-        expect(resolveDefaultValue('null', 'number')).toBe(0);
+        expect(resolveDefaultValue("null", "number")).toBe(0);
     });
 
     test('null 值 + array_string 类型 => "[]"', () => {
-        expect(resolveDefaultValue(null, 'array_string')).toBe('[]');
+        expect(resolveDefaultValue(null, "array_string")).toBe("[]");
     });
 
     test('null 值 + text 类型 => "null"', () => {
-        expect(resolveDefaultValue(null, 'text')).toBe('null');
+        expect(resolveDefaultValue(null, "text")).toBe("null");
     });
 
     test('null 值 + array_text 类型 => "null"（TEXT 不支持默认值）', () => {
-        expect(resolveDefaultValue(null, 'array_text')).toBe('null');
+        expect(resolveDefaultValue(null, "array_text")).toBe("null");
     });
 
-    test('有实际值时直接返回', () => {
-        expect(resolveDefaultValue('admin', 'string')).toBe('admin');
-        expect(resolveDefaultValue(100, 'number')).toBe(100);
-        expect(resolveDefaultValue(0, 'number')).toBe(0);
+    test("有实际值时直接返回", () => {
+        expect(resolveDefaultValue("admin", "string")).toBe("admin");
+        expect(resolveDefaultValue(100, "number")).toBe(100);
+        expect(resolveDefaultValue(0, "number")).toBe(0);
     });
 });
 
-describe('generateDefaultSql', () => {
-    test('number 类型生成数字默认值', () => {
-        expect(generateDefaultSql(0, 'number')).toBe(' DEFAULT 0');
-        expect(generateDefaultSql(100, 'number')).toBe(' DEFAULT 100');
+describe("generateDefaultSql", () => {
+    test("number 类型生成数字默认值", () => {
+        expect(generateDefaultSql(0, "number")).toBe(" DEFAULT 0");
+        expect(generateDefaultSql(100, "number")).toBe(" DEFAULT 100");
     });
 
-    test('string 类型生成带引号默认值', () => {
-        expect(generateDefaultSql('admin', 'string')).toBe(" DEFAULT 'admin'");
-        expect(generateDefaultSql('', 'string')).toBe(" DEFAULT ''");
+    test("string 类型生成带引号默认值", () => {
+        expect(generateDefaultSql("admin", "string")).toBe(" DEFAULT 'admin'");
+        expect(generateDefaultSql("", "string")).toBe(" DEFAULT ''");
     });
 
-    test('text 类型不生成默认值', () => {
-        expect(generateDefaultSql('null', 'text')).toBe('');
+    test("text 类型不生成默认值", () => {
+        expect(generateDefaultSql("null", "text")).toBe("");
     });
 
-    test('array_string 类型生成 JSON 数组默认值', () => {
-        expect(generateDefaultSql('[]', 'array_string')).toBe(" DEFAULT '[]'");
+    test("array_string 类型生成 JSON 数组默认值", () => {
+        expect(generateDefaultSql("[]", "array_string")).toBe(" DEFAULT '[]'");
     });
 
-    test('array_text 类型不生成默认值（MySQL TEXT 不支持）', () => {
-        expect(generateDefaultSql('[]', 'array_text')).toBe('');
+    test("array_text 类型不生成默认值（MySQL TEXT 不支持）", () => {
+        expect(generateDefaultSql("[]", "array_text")).toBe("");
     });
 
-    test('单引号被正确转义', () => {
-        expect(generateDefaultSql("it's", 'string')).toBe(" DEFAULT 'it''s'");
+    test("单引号被正确转义", () => {
+        expect(generateDefaultSql("it's", "string")).toBe(" DEFAULT 'it''s'");
     });
 });
 
-describe('getSqlType', () => {
-    test('string 类型带长度', () => {
-        const result = getSqlType('string', 100);
-        expect(result).toBe('VARCHAR(100)');
+describe("getSqlType", () => {
+    test("string 类型带长度", () => {
+        const result = getSqlType("string", 100);
+        expect(result).toBe("VARCHAR(100)");
     });
 
-    test('array_string 类型带长度', () => {
-        const result = getSqlType('array_string', 500);
-        expect(result).toBe('VARCHAR(500)');
+    test("array_string 类型带长度", () => {
+        const result = getSqlType("array_string", 500);
+        expect(result).toBe("VARCHAR(500)");
     });
 
-    test('number 类型无符号', () => {
-        const result = getSqlType('number', null, true);
-        expect(result).toBe('BIGINT UNSIGNED');
+    test("number 类型无符号", () => {
+        const result = getSqlType("number", null, true);
+        expect(result).toBe("BIGINT UNSIGNED");
     });
 
-    test('number 类型有符号', () => {
-        const result = getSqlType('number', null, false);
-        expect(result).toBe('BIGINT');
+    test("number 类型有符号", () => {
+        const result = getSqlType("number", null, false);
+        expect(result).toBe("BIGINT");
     });
 
-    test('text 类型', () => {
-        const result = getSqlType('text', null);
-        expect(result).toBe('MEDIUMTEXT');
+    test("text 类型", () => {
+        const result = getSqlType("text", null);
+        expect(result).toBe("MEDIUMTEXT");
     });
 });

package/tests/syncMenu-paths.test.ts

@@ -0,0 +1,68 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { __test__ } from "../sync/syncMenu.js";
+
+const testRootDir = join(process.cwd(), "temp", "test-sync-menu-views");
+const viewsDir = join(testRootDir, "views");
+
+function writeVueIndex(dir: string, title: string, order?: number): void {
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+
+    const metaOrder = typeof order === "number" ? `, order: ${order}` : "";
+
+    const content = `<script setup>\ndefinePage({ meta: { title: "${title}"${metaOrder} } });\n</script>\n\n<template>\n    <div />\n</template>\n`;
+    writeFileSync(join(dir, "index.vue"), content, { encoding: "utf8" });
+}
+
+beforeAll(() => {
+    if (existsSync(testRootDir)) {
+        rmSync(testRootDir, { recursive: true, force: true });
+    }
+    mkdirSync(viewsDir, { recursive: true });
+
+    // 根级 index：应映射为 prefix 本身（不带尾随 /）
+    writeVueIndex(join(viewsDir, "index"), "Root", 2);
+
+    // 带数字后缀目录：应清理后缀
+    writeVueIndex(join(viewsDir, "user_1"), "User", 1);
+});
+
+afterAll(() => {
+    if (existsSync(testRootDir)) {
+        rmSync(testRootDir, { recursive: true, force: true });
+    }
+});
+
+describe("syncMenu - scanViewsDir paths", () => {
+    test("根级 index 不应生成尾随斜杠", async () => {
+        const prefix = "/addon/addonAdmin";
+        const menus = await __test__.scanViewsDir(viewsDir, prefix);
+
+        const root = menus.find((m) => m.path === prefix);
+        expect(root).toBeDefined();
+        expect(root?.path).toBe(prefix);
+    });
+
+    test("目录名 _数字 后缀应被清理", async () => {
+        const prefix = "/addon/addonAdmin";
+        const menus = await __test__.scanViewsDir(viewsDir, prefix);
+
+        const user = menus.find((m) => m.path === "/addon/addonAdmin/user");
+        expect(user).toBeDefined();
+        expect(user?.name).toBe("User");
+        expect(user?.sort).toBe(1);
+    });
+});
+
+describe("syncMenu - normalizeMenuPath", () => {
+    test("去掉尾随 / 且折叠多 /", () => {
+        expect(__test__.normalizeMenuPath("/addon/a/")).toBe("/addon/a");
+        expect(__test__.normalizeMenuPath("//addon//a//b/")).toBe("/addon/a/b");
+        expect(__test__.normalizeMenuPath("addon/a")).toBe("/addon/a");
+        expect(__test__.normalizeMenuPath("/")).toBe("/");
+    });
+});

package/tests/util.test.ts

@@ -1,99 +1,100 @@
-import { describe, test, expect } from 'bun:test';
-import { keysToCamel } from 'befly-shared/keysToCamel';
-import { keysToSnake } from 'befly-shared/keysToSnake';
-import { arrayKeysToCamel } from 'befly-shared/arrayKeysToCamel';
-import { calcPerfTime } from 'befly-shared/calcPerfTime';
-import { fieldClear } from 'befly-shared/fieldClear';
+import { describe, test, expect } from "bun:test";
 
-describe('Util - keysToCamel', () => {
-    test('转换对象键名为驼峰', () => {
-        const result = keysToCamel({ user_name: 'John', user_id: 123 });
-        expect(result.userName).toBe('John');
+import { arrayKeysToCamel } from "../utils/arrayKeysToCamel.js";
+import { calcPerfTime } from "../utils/calcPerfTime.js";
+import { fieldClear } from "../utils/fieldClear.js";
+import { keysToCamel } from "../utils/keysToCamel.js";
+import { keysToSnake } from "../utils/keysToSnake.js";
+
+describe("Util - keysToCamel", () => {
+    test("转换对象键名为驼峰", () => {
+        const result = keysToCamel({ user_name: "John", user_id: 123 });
+        expect(result.userName).toBe("John");
         expect(result.userId).toBe(123);
     });
 
-    test('保持已有驼峰格式', () => {
-        const result = keysToCamel({ userName: 'John', userId: 123 });
-        expect(result.userName).toBe('John');
+    test("保持已有驼峰格式", () => {
+        const result = keysToCamel({ userName: "John", userId: 123 });
+        expect(result.userName).toBe("John");
         expect(result.userId).toBe(123);
     });
 
-    test('处理空对象', () => {
+    test("处理空对象", () => {
         const result = keysToCamel({});
         expect(Object.keys(result).length).toBe(0);
     });
 
-    test('处理嵌套对象', () => {
-        const result = keysToCamel({ user_info: { first_name: 'John' } });
+    test("处理嵌套对象", () => {
+        const result = keysToCamel({ user_info: { first_name: "John" } });
         expect(result.userInfo).toBeDefined();
     });
 });
 
-describe('Util - keysToSnake', () => {
-    test('转换对象键名为下划线', () => {
-        const result = keysToSnake({ userName: 'John', userId: 123 });
-        expect(result.user_name).toBe('John');
+describe("Util - keysToSnake", () => {
+    test("转换对象键名为下划线", () => {
+        const result = keysToSnake({ userName: "John", userId: 123 });
+        expect(result.user_name).toBe("John");
         expect(result.user_id).toBe(123);
     });
 
-    test('保持已有下划线格式', () => {
-        const result = keysToSnake({ user_name: 'John', user_id: 123 });
-        expect(result.user_name).toBe('John');
+    test("保持已有下划线格式", () => {
+        const result = keysToSnake({ user_name: "John", user_id: 123 });
+        expect(result.user_name).toBe("John");
         expect(result.user_id).toBe(123);
     });
 
-    test('处理空对象', () => {
+    test("处理空对象", () => {
         const result = keysToSnake({});
         expect(Object.keys(result).length).toBe(0);
     });
 });
 
-describe('Util - arrayKeysToCamel', () => {
-    test('转换数组中对象键名为驼峰', () => {
+describe("Util - arrayKeysToCamel", () => {
+    test("转换数组中对象键名为驼峰", () => {
         const result = arrayKeysToCamel([
-            { user_name: 'John', user_id: 1 },
-            { user_name: 'Jane', user_id: 2 }
+            { user_name: "John", user_id: 1 },
+            { user_name: "Jane", user_id: 2 }
         ]);
-        expect(result[0].userName).toBe('John');
+        expect(result[0].userName).toBe("John");
         expect(result[0].userId).toBe(1);
-        expect(result[1].userName).toBe('Jane');
+        expect(result[1].userName).toBe("Jane");
         expect(result[1].userId).toBe(2);
     });
 
-    test('处理空数组', () => {
+    test("处理空数组", () => {
         const result = arrayKeysToCamel([]);
         expect(result.length).toBe(0);
     });
 });
 
-describe('Util - fieldClear', () => {
-    test('移除 null 和 undefined', () => {
-        const result = fieldClear({ a: 1, b: null, c: undefined, d: 'test' }, { excludeValues: [null, undefined] });
+describe("Util - fieldClear", () => {
+    test("移除 null 和 undefined", () => {
+        const result = fieldClear({ a: 1, b: null, c: undefined, d: "test" }, { excludeValues: [null, undefined] });
         expect(result.a).toBe(1);
         expect(result.b).toBeUndefined();
         expect(result.c).toBeUndefined();
-        expect(result.d).toBe('test');
+        expect(result.d).toBe("test");
     });
 
-    test('保留指定值', () => {
+    test("保留指定值", () => {
         const result = fieldClear({ a: 1, b: null, c: 0 }, { excludeValues: [null, undefined], keepMap: { c: 0 } });
         expect(result.a).toBe(1);
         expect(result.b).toBeUndefined();
         expect(result.c).toBe(0);
     });
 
-    test('处理空对象', () => {
+    test("处理空对象", () => {
         const result = fieldClear({});
         expect(Object.keys(result).length).toBe(0);
     });
 });
 
-describe('Util - calcPerfTime', () => {
-    test('计算性能时间', () => {
+describe("Util - calcPerfTime", () => {
+    test("计算性能时间", () => {
         const start = Bun.nanoseconds();
         const result = calcPerfTime(start);
-        expect(result).toContain('毫秒');
-        expect(typeof result).toBe('string');
+        expect(result).toContain("毫秒");
+        expect(typeof result).toBe("string");
         expect(result).toMatch(/\d+(\.\d+)?\s*毫秒/);
     });
 });