befly-shared 1.4.1 → 1.4.2

package/dist/types/arrayToTree.d.ts

@@ -1,9 +1,6 @@
-/**
- * arrayToTree 类型定义（类型模块，仅供 type 引用）。
- */
-export type ArrayToTreeResult<T extends Record<string, any>> = {
+export type ArrayToTreeResult<T extends Record<string, unknown>> = {
     flat: Array<T>;
     tree: Array<T>;
     map: Map<string, T>;
 };
-export type ArrayToTree = <T extends Record<string, any>>(items: T[], id?: string, pid?: string, children?: string, sort?: string) => ArrayToTreeResult<T>;
+export type ArrayToTree = <T extends Record<string, unknown>>(items: Array<T>, id?: string, pid?: string, children?: string, sort?: string) => ArrayToTreeResult<T>;

package/dist/types/arrayToTree.js

@@ -1,4 +1 @@
-/**
- * arrayToTree 类型定义（类型模块，仅供 type 引用）。
- */
 export {};

package/dist/types/cleanParams.d.ts

@@ -0,0 +1 @@
+export type CleanParams = <TData extends Record<string, unknown>>(data: TData, dropValues?: readonly unknown[], dropKeyValue?: Record<string, readonly unknown[]>) => Partial<TData>;

package/dist/types/cleanParams.js

@@ -0,0 +1 @@
+export {};

package/dist/types/fieldClear.d.ts

@@ -0,0 +1,11 @@
+export interface FieldClearOptions {
+    pickKeys?: string[];
+    omitKeys?: string[];
+    keepValues?: unknown[];
+    excludeValues?: unknown[];
+    keepMap?: Record<string, unknown>;
+}
+export type FieldClearResult<T> = T extends Array<infer U> ? Array<FieldClearResult<U>> : T extends object ? {
+    [K in keyof T]?: T[K];
+} : T;
+export type FieldClear = <T = unknown>(data: T | T[], options?: FieldClearOptions) => FieldClearResult<T>;

package/dist/types/fieldClear.js

@@ -0,0 +1 @@
+export {};

package/dist/types/hashPassword.d.ts

@@ -1,4 +1 @@
-/**
- * hashPassword 类型定义（类型模块，仅供 type 引用）。
- */
 export type HashPassword = (password: string, salt?: string) => Promise<string>;

package/dist/types/hashPassword.js

@@ -1,4 +1 @@
-/**
- * hashPassword 类型定义（类型模块，仅供 type 引用）。
- */
 export {};

package/dist/types/withDefaultColumns.d.ts

@@ -1,4 +1,2 @@
-/**
- * withDefaultColumns 类型定义（类型模块，仅供 type 引用）。
- */
-export type WithDefaultColumns = (columns: any[], customConfig?: Record<string, any>) => any[];
+export type TableColumnLike = Record<string, unknown>;
+export type WithDefaultColumns = (columns: Array<TableColumnLike>, customConfig?: Record<string, Record<string, unknown>>) => Array<Record<string, unknown>>;

package/dist/types/withDefaultColumns.js

@@ -1,4 +1 @@
-/**
- * withDefaultColumns 类型定义（类型模块，仅供 type 引用）。
- */
 export {};

package/dist/utils/arrayToTree.d.ts

@@ -1,4 +1,4 @@
-export type ArrayToTreeResult<T extends Record<string, any>> = {
+export type ArrayToTreeResult<T extends Record<string, unknown>> = {
     flat: Array<T>;
     tree: Array<T>;
     map: Map<string, T>;
@@ -9,6 +9,6 @@ export type ArrayToTreeResult<T extends Record<string, any>> = {
  * - 默认字段：id / pid / children / sort
  * - pid 为空字符串或父节点不存在时，视为根节点
  * - 内部会 clone 一份节点对象，并写入 children: []
- * - 默认自带递归排序：按 sort 升序；sort 缺省/非法或 < 1 视为 999999；sort 相同按 id 自然序1
+ * - 默认自带递归排序：按 sort 升序；sort 缺省/非法或 < 1 视为 999999；sort 相同按 id 自然序
  */
-export declare function arrayToTree<T extends Record<string, any>>(items: T[], id?: string, pid?: string, children?: string, sort?: string): ArrayToTreeResult<T>;
+export declare function arrayToTree<T extends Record<string, unknown>>(items: Array<T>, id?: string, pid?: string, children?: string, sort?: string): ArrayToTreeResult<T>;

package/dist/utils/arrayToTree.js

@@ -4,7 +4,7 @@
  * - 默认字段：id / pid / children / sort
  * - pid 为空字符串或父节点不存在时，视为根节点
  * - 内部会 clone 一份节点对象，并写入 children: []
- * - 默认自带递归排序：按 sort 升序；sort 缺省/非法或 < 1 视为 999999；sort 相同按 id 自然序1
+ * - 默认自带递归排序：按 sort 升序；sort 缺省/非法或 < 1 视为 999999；sort 相同按 id 自然序
  */
 export function arrayToTree(items, id = "id", pid = "pid", children = "children", sort = "sort") {
     const idKey = typeof id === "string" && id.length > 0 ? id : "id";
@@ -24,14 +24,16 @@ export function arrayToTree(items, id = "id", pid = "pid", children = "children"
         return "";
     };
     for (const item of safeItems) {
-        const rawId = item ? item[idKey] : undefined;
-        const rawPid = item ? item[pidKey] : undefined;
+        const itemObj = typeof item === "object" && item !== null ? item : null;
+        const rawId = itemObj ? itemObj[idKey] : undefined;
+        const rawPid = itemObj ? itemObj[pidKey] : undefined;
         const normalizedId = normalizeKey(rawId);
         const normalizedPid = normalizeKey(rawPid);
         const nextNode = Object.assign({}, item);
-        nextNode[idKey] = normalizedId;
-        nextNode[pidKey] = normalizedPid;
-        nextNode[childrenKey] = [];
+        const nextNodeObj = nextNode;
+        nextNodeObj[idKey] = normalizedId;
+        nextNodeObj[pidKey] = normalizedPid;
+        nextNodeObj[childrenKey] = [];
         flat.push(nextNode);
         if (normalizedId.length > 0) {
             map.set(normalizedId, nextNode);
@@ -39,20 +41,26 @@ export function arrayToTree(items, id = "id", pid = "pid", children = "children"
     }
     const tree = [];
     for (const node of flat) {
-        const selfId = normalizeKey(node ? node[idKey] : undefined);
-        const parentId = normalizeKey(node ? node[pidKey] : undefined);
+        const nodeObj = node;
+        const selfId = normalizeKey(nodeObj[idKey]);
+        const parentId = normalizeKey(nodeObj[pidKey]);
         if (parentId.length > 0 && parentId !== selfId) {
             const parent = map.get(parentId);
-            if (parent && Array.isArray(parent[childrenKey])) {
-                parent[childrenKey].push(node);
-                continue;
+            if (parent) {
+                const parentObj = parent;
+                const childrenValue = parentObj[childrenKey];
+                if (Array.isArray(childrenValue)) {
+                    childrenValue.push(node);
+                    continue;
+                }
             }
         }
         tree.push(node);
     }
     const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
     const getSortValue = (node) => {
-        const raw = node ? node[sortKey] : undefined;
+        const nodeObj = node;
+        const raw = nodeObj[sortKey];
         if (typeof raw !== "number") {
             return 999999;
         }
@@ -70,8 +78,10 @@ export function arrayToTree(items, id = "id", pid = "pid", children = "children"
         if (aSort !== bSort) {
             return aSort - bSort;
         }
-        const aId = a ? a[idKey] : "";
-        const bId = b ? b[idKey] : "";
+        const aObj = a;
+        const bObj = b;
+        const aId = aObj[idKey];
+        const bId = bObj[idKey];
         return collator.compare(typeof aId === "string" ? aId : "", typeof bId === "string" ? bId : "");
     };
     const sortTreeInPlace = (nodes, seen) => {
@@ -89,7 +99,8 @@ export function arrayToTree(items, id = "id", pid = "pid", children = "children"
                 continue;
             }
             seen.add(node);
-            const childNodes = node[childrenKey];
+            const nodeObj = node;
+            const childNodes = nodeObj[childrenKey];
             if (Array.isArray(childNodes) && childNodes.length > 0) {
                 sortTreeInPlace(childNodes, seen);
             }

package/dist/utils/cleanParams.d.ts

@@ -0,0 +1 @@
+export declare function cleanParams<TData extends Record<string, unknown>>(data: TData, dropValues?: readonly unknown[], dropKeyValue?: Record<string, readonly unknown[]>): Partial<TData>;

package/dist/utils/cleanParams.js

@@ -0,0 +1,29 @@
+export function cleanParams(data, dropValues, dropKeyValue) {
+    const globalDropValues = dropValues ?? [];
+    const perKeyDropValues = dropKeyValue ?? {};
+    const globalDropSet = new Set(globalDropValues);
+    const out = {};
+    for (const key of Object.keys(data)) {
+        const value = data[key];
+        // 默认强制移除 null / undefined
+        if (value === null || value === undefined) {
+            continue;
+        }
+        // 如果该 key 配了规则：以 key 规则为准，不再应用全局 dropValues
+        if (Object.hasOwn(perKeyDropValues, key)) {
+            const keyDropValues = perKeyDropValues[key] ?? [];
+            const keyDropSet = new Set(keyDropValues);
+            if (keyDropSet.has(value)) {
+                continue;
+            }
+            out[key] = value;
+            continue;
+        }
+        // 未配置 key 规则：应用全局 dropValues
+        if (globalDropSet.has(value)) {
+            continue;
+        }
+        out[key] = value;
+    }
+    return out;
+}

package/dist/utils/fieldClear.d.ts

@@ -1,11 +1,11 @@
 export interface FieldClearOptions {
     pickKeys?: string[];
     omitKeys?: string[];
-    keepValues?: any[];
-    excludeValues?: any[];
-    keepMap?: Record<string, any>;
+    keepValues?: unknown[];
+    excludeValues?: unknown[];
+    keepMap?: Record<string, unknown>;
 }
 export type FieldClearResult<T> = T extends Array<infer U> ? Array<FieldClearResult<U>> : T extends object ? {
     [K in keyof T]?: T[K];
 } : T;
-export declare function fieldClear<T = any>(data: T | T[], options?: FieldClearOptions): FieldClearResult<T>;
+export declare function fieldClear<T = unknown>(data: T | T[], options?: FieldClearOptions): FieldClearResult<T>;

package/dist/utils/fieldClear.js

@@ -1,5 +1,3 @@
-// fieldClear 工具函数实现（shared 版）
-// 支持 pick/omit/keepValues/excludeValues/keepMap，处理对象和数组
 function isObject(val) {
     return val !== null && typeof val === "object" && !Array.isArray(val);
 }
@@ -24,7 +22,7 @@ export function fieldClear(data, options = {}) {
         for (const key of keys) {
             const value = obj[key];
             // 1. keepMap 优先
-            if (keepMap && Object.prototype.hasOwnProperty.call(keepMap, key)) {
+            if (keepMap && Object.hasOwn(keepMap, key)) {
                 if (Object.is(keepMap[key], value)) {
                     result[key] = value;
                     continue;

package/dist/utils/hashPassword.d.ts

@@ -1,11 +1,8 @@
 /**
- * 密码哈希工具
- * 使用 SHA-256 + 盐值对密码进行单向哈希
- */
-/**
- * 使用 SHA-256 对密码进行哈希
- * @param password - 原始密码
- * @param salt - 盐值，默认为 befly
- * @returns 哈希后的密码（十六进制字符串）
+ * 使用 SHA-256 对密码进行哈希（前端实现：WebCrypto）。
+ *
+ * 注意：这是前端/管理后台用途的工具函数。
+ * - 禁止在接口端/服务端使用该函数作为密码存储方案
+ * - 服务端应使用 core 侧既定密码策略（例如 Cipher.hashPassword）
  */
 export declare function hashPassword(password: string, salt?: string): Promise<string>;

package/dist/utils/hashPassword.js

@@ -1,21 +1,15 @@
 /**
- * 密码哈希工具
- * 使用 SHA-256 + 盐值对密码进行单向哈希
- */
-/**
- * 使用 SHA-256 对密码进行哈希
- * @param password - 原始密码
- * @param salt - 盐值，默认为 befly
- * @returns 哈希后的密码（十六进制字符串）
+ * 使用 SHA-256 对密码进行哈希（前端实现：WebCrypto）。
+ *
+ * 注意：这是前端/管理后台用途的工具函数。
+ * - 禁止在接口端/服务端使用该函数作为密码存储方案
+ * - 服务端应使用 core 侧既定密码策略（例如 Cipher.hashPassword）
  */
 export async function hashPassword(password, salt = "befly") {
     const data = password + salt;
-    // 将字符串转换为 Uint8Array
     const encoder = new TextEncoder();
     const dataBuffer = encoder.encode(data);
-    // 使用 Web Crypto API 进行 SHA-256 哈希
     const hashBuffer = await crypto.subtle.digest("SHA-256", dataBuffer);
-    // 将 ArrayBuffer 转换为十六进制字符串
     const hashArray = Array.from(new Uint8Array(hashBuffer));
     const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
     return hashHex;

package/dist/utils/scanViewsDir.js

@@ -106,9 +106,16 @@ export function extractDefinePageMetaFromScriptSetup(scriptSetup) {
     if (!titleMatch) {
         return null;
     }
+    const title = titleMatch[2];
+    if (typeof title !== "string") {
+        return null;
+    }
     const orderMatch = scriptSetup.match(/definePage\s*\([\s\S]*?meta\s*:\s*\{[\s\S]*?order\s*:\s*(\d+)/);
+    if (!orderMatch) {
+        return { title: title };
+    }
     return {
-        title: titleMatch[2],
-        order: orderMatch ? Number(orderMatch[1]) : undefined
+        title: title,
+        order: Number(orderMatch[1])
     };
 }

package/dist/utils/withDefaultColumns.d.ts

@@ -1,14 +1,11 @@
+export type TableColumnLike = Record<string, unknown>;
 /**
  * 为表格列添加默认配置（纯函数）。
  *
- * 设计目标：
- * - 不依赖浏览器/Node 特定 API
- * - 不修改入参 columns 的对象引用（会返回新数组，并对每个列对象做浅拷贝合并）
- *
  * 默认行为：
  * - base 默认：{ width: 200, ellipsis: true }
  * - 特殊列：operation/state/id
  * - colKey 以 At/At2 结尾时：默认 { align: "center" }
- * - customConfig 可覆盖/扩展默认 specialColumnConfig（浅合并/替换：若传入 operation 配置，将整体替换默认 operation 配置，默认 fixed="right" 不会被保留）
+ * - customConfig 可覆盖/扩展默认 specialColumnConfig
  */
-export declare function withDefaultColumns(columns: any[], customConfig?: Record<string, any>): any[];
+export declare function withDefaultColumns(columns: Array<TableColumnLike>, customConfig?: Record<string, Record<string, unknown>>): Array<Record<string, unknown>>;

package/dist/utils/withDefaultColumns.js

@@ -1,15 +1,11 @@
 /**
  * 为表格列添加默认配置（纯函数）。
  *
- * 设计目标：
- * - 不依赖浏览器/Node 特定 API
- * - 不修改入参 columns 的对象引用（会返回新数组，并对每个列对象做浅拷贝合并）
- *
  * 默认行为：
  * - base 默认：{ width: 200, ellipsis: true }
  * - 特殊列：operation/state/id
  * - colKey 以 At/At2 结尾时：默认 { align: "center" }
- * - customConfig 可覆盖/扩展默认 specialColumnConfig（浅合并/替换：若传入 operation 配置，将整体替换默认 operation 配置，默认 fixed="right" 不会被保留）
+ * - customConfig 可覆盖/扩展默认 specialColumnConfig
  */
 export function withDefaultColumns(columns, customConfig) {
     const safeColumns = Array.isArray(columns) ? columns : [];
@@ -19,7 +15,8 @@ export function withDefaultColumns(columns, customConfig) {
         id: { width: 200, align: "center" }
     }, customConfig || {});
     return safeColumns.map((col) => {
-        const colKey = col && col.colKey;
+        const colObj = typeof col === "object" && col !== null ? col : {};
+        const colKey = typeof colObj["colKey"] === "string" ? colObj["colKey"] : undefined;
         let specialConfig = colKey ? specialColumnConfig[colKey] : undefined;
         if (!specialConfig && typeof colKey === "string" && (colKey.endsWith("At") || colKey.endsWith("At2"))) {
             specialConfig = { align: "center" };
@@ -32,7 +29,7 @@ export function withDefaultColumns(columns, customConfig) {
         if (specialConfig) {
             Object.assign(merged, specialConfig);
         }
-        Object.assign(merged, col);
+        Object.assign(merged, colObj);
         return merged;
     });
 }

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "befly-shared",
-    "version": "1.4.1",
-    "gitHead": "b566edda48fcd5e8e7c66d001fefedc68520036a",
+    "version": "1.4.2",
+    "gitHead": "540d9551c589cb33d711c593e561f0fffc0aac0c",
     "private": false,
-    "description": "Befly 纯函数与纯常量共享包（不包含 Node/浏览器特定实现）",
+    "description": "Befly 前端/Vite 共享工具包（仅供 admin 与 Vite 工具使用，禁止接口端/服务端导入）",
     "license": "Apache-2.0",
     "author": "chensuiyi <bimostyle@qq.com>",
     "files": [

package/dist/types/deepTransformKeys.d.ts

@@ -1,12 +0,0 @@
-/**
- * deepTransformKeys 类型定义（类型模块，仅供 type 引用）。
- *
- * 注意：types 模块不包含运行时实现；运行时请从 befly-shared/utils/* 引入。
- */
-export type KeyTransformer = (key: string) => string;
-export type PresetTransform = "camel" | "snake" | "kebab" | "pascal" | "upper" | "lower";
-export interface TransformOptions {
-    maxDepth?: number;
-    excludeKeys?: string[];
-}
-export type DeepTransformKeys = <T = any>(data: any, transformer: KeyTransformer | PresetTransform, options?: TransformOptions) => T;

package/dist/types/deepTransformKeys.js

@@ -1,6 +0,0 @@
-/**
- * deepTransformKeys 类型定义（类型模块，仅供 type 引用）。
- *
- * 注意：types 模块不包含运行时实现；运行时请从 befly-shared/utils/* 引入。
- */
-export {};

package/dist/types/normalizePathnameListInput.d.ts

@@ -1,4 +0,0 @@
-/**
- * normalizePathnameListInput 类型定义（类型模块，仅供 type 引用）。
- */
-export type NormalizePathnameListInput = (value: unknown, fieldLabel: string, forbidMethodPrefix: boolean) => string[];

package/dist/types/normalizePathnameListInput.js

@@ -1,4 +0,0 @@
-/**
- * normalizePathnameListInput 类型定义（类型模块，仅供 type 引用）。
- */
-export {};

package/dist/utils/deepTransformKeys.d.ts

@@ -1,84 +0,0 @@
-/**
- * 键名转换函数类型
- */
-export type KeyTransformer = (key: string) => string;
-/**
- * 预设的转换方式
- * - camel: 小驼峰 user_id → userId
- * - snake: 下划线 userId → user_id
- * - kebab: 短横线 userId → user-id
- * - pascal: 大驼峰 user_id → UserId
- * - upper: 大写 userId → USERID
- * - lower: 小写 UserId → userid
- */
-export type PresetTransform = "camel" | "snake" | "kebab" | "pascal" | "upper" | "lower";
-/**
- * 转换选项
- */
-export interface TransformOptions {
-    /** 最大递归深度，默认 100。设置为 0 表示不限制深度（不推荐） */
-    maxDepth?: number;
-    /** 排除的键名列表，这些键名不会被转换 */
-    excludeKeys?: string[];
-}
-/**
- * 深度递归遍历数据结构，转换所有键名
- * 支持嵌套对象和数组，自动防止循环引用和栈溢出
- *
- * @param data - 源数据（对象、数组或其他类型）
- * @param transformer - 转换函数或预设方式
- * @param options - 转换选项
- * @returns 键名转换后的新数据
- *
- * @example
- * // 小驼峰
- * deepTransformKeys({ user_id: 123, user_info: { first_name: 'John' } }, 'camel')
- * // { userId: 123, userInfo: { firstName: 'John' } }
- *
- * @example
- * // 下划线
- * deepTransformKeys({ userId: 123, userInfo: { firstName: 'John' } }, 'snake')
- * // { user_id: 123, user_info: { first_name: 'John' } }
- *
- * @example
- * // 短横线
- * deepTransformKeys({ userId: 123, userInfo: { firstName: 'John' } }, 'kebab')
- * // { 'user-id': 123, 'user-info': { 'first-name': 'John' } }
- *
- * @example
- * // 大驼峰
- * deepTransformKeys({ user_id: 123 }, 'pascal')
- * // { UserId: 123 }
- *
- * @example
- * // 大写
- * deepTransformKeys({ userId: 123 }, 'upper')
- * // { USERID: 123 }
- *
- * @example
- * // 小写
- * deepTransformKeys({ UserId: 123 }, 'lower')
- * // { userid: 123 }
- *
- * @example
- * // 自定义转换函数
- * deepTransformKeys({ user_id: 123 }, (key) => `prefix_${key}`)
- * // { prefix_user_id: 123 }
- *
- * @example
- * // 限制递归深度
- * deepTransformKeys(deepData, 'camel', { maxDepth: 10 })
- *
- * @example
- * // 排除特定键名
- * deepTransformKeys({ _id: '123', user_name: 'John' }, 'camel', { excludeKeys: ['_id'] })
- * // { _id: '123', userName: 'John' }
- *
- * @example
- * // 嵌套数组和对象
- * deepTransformKeys({
- *   user_list: [{ user_id: 1, user_tags: [{ tag_name: 'vip' }] }]
- * }, 'camel')
- * // { userList: [{ userId: 1, userTags: [{ tagName: 'vip' }] }] }
- */
-export declare const deepTransformKeys: <T = any>(data: any, transformer: KeyTransformer | PresetTransform, options?: TransformOptions) => T;

package/dist/utils/deepTransformKeys.js

@@ -1,139 +0,0 @@
-import { isPlainObject } from "es-toolkit/compat";
-import { camelCase, snakeCase, kebabCase, pascalCase } from "es-toolkit/string";
-/**
- * 深度递归遍历数据结构，转换所有键名
- * 支持嵌套对象和数组，自动防止循环引用和栈溢出
- *
- * @param data - 源数据（对象、数组或其他类型）
- * @param transformer - 转换函数或预设方式
- * @param options - 转换选项
- * @returns 键名转换后的新数据
- *
- * @example
- * // 小驼峰
- * deepTransformKeys({ user_id: 123, user_info: { first_name: 'John' } }, 'camel')
- * // { userId: 123, userInfo: { firstName: 'John' } }
- *
- * @example
- * // 下划线
- * deepTransformKeys({ userId: 123, userInfo: { firstName: 'John' } }, 'snake')
- * // { user_id: 123, user_info: { first_name: 'John' } }
- *
- * @example
- * // 短横线
- * deepTransformKeys({ userId: 123, userInfo: { firstName: 'John' } }, 'kebab')
- * // { 'user-id': 123, 'user-info': { 'first-name': 'John' } }
- *
- * @example
- * // 大驼峰
- * deepTransformKeys({ user_id: 123 }, 'pascal')
- * // { UserId: 123 }
- *
- * @example
- * // 大写
- * deepTransformKeys({ userId: 123 }, 'upper')
- * // { USERID: 123 }
- *
- * @example
- * // 小写
- * deepTransformKeys({ UserId: 123 }, 'lower')
- * // { userid: 123 }
- *
- * @example
- * // 自定义转换函数
- * deepTransformKeys({ user_id: 123 }, (key) => `prefix_${key}`)
- * // { prefix_user_id: 123 }
- *
- * @example
- * // 限制递归深度
- * deepTransformKeys(deepData, 'camel', { maxDepth: 10 })
- *
- * @example
- * // 排除特定键名
- * deepTransformKeys({ _id: '123', user_name: 'John' }, 'camel', { excludeKeys: ['_id'] })
- * // { _id: '123', userName: 'John' }
- *
- * @example
- * // 嵌套数组和对象
- * deepTransformKeys({
- *   user_list: [{ user_id: 1, user_tags: [{ tag_name: 'vip' }] }]
- * }, 'camel')
- * // { userList: [{ userId: 1, userTags: [{ tagName: 'vip' }] }] }
- */
-export const deepTransformKeys = (data, transformer, options = {}) => {
-    const { maxDepth = 100, excludeKeys = [] } = options;
-    // 获取实际的转换函数
-    let transformFn;
-    if (typeof transformer === "function") {
-        transformFn = transformer;
-    }
-    else if (transformer === "camel") {
-        transformFn = camelCase;
-    }
-    else if (transformer === "snake") {
-        transformFn = snakeCase;
-    }
-    else if (transformer === "kebab") {
-        transformFn = kebabCase;
-    }
-    else if (transformer === "pascal") {
-        transformFn = pascalCase;
-    }
-    else if (transformer === "upper") {
-        transformFn = (key) => key.toUpperCase();
-    }
-    else {
-        transformFn = (key) => key.toLowerCase();
-    }
-    // 用于检测循环引用的 WeakSet
-    const visited = new WeakSet();
-    // 创建排除键名集合，提升查找性能
-    const excludeSet = new Set(excludeKeys);
-    // 递归转换函数
-    const transform = (value, depth) => {
-        // 处理 null 和 undefined
-        if (value === null || value === undefined) {
-            return value;
-        }
-        // 处理数组
-        if (Array.isArray(value)) {
-            // 检测循环引用
-            if (visited.has(value)) {
-                return value;
-            }
-            visited.add(value);
-            // 检查深度限制：如果达到限制，返回原数组
-            if (maxDepth > 0 && depth >= maxDepth) {
-                visited.delete(value);
-                return value;
-            }
-            const result = value.map((item) => transform(item, depth + 1));
-            visited.delete(value);
-            return result;
-        }
-        // 处理对象
-        if (isPlainObject(value)) {
-            // 检测循环引用
-            if (visited.has(value)) {
-                return value;
-            }
-            visited.add(value);
-            // 检查深度限制：如果达到限制，返回原对象
-            if (maxDepth > 0 && depth >= maxDepth) {
-                visited.delete(value);
-                return value;
-            }
-            const result = {};
-            for (const [key, val] of Object.entries(value)) {
-                // 检查是否在排除列表中
-                const transformedKey = excludeSet.has(key) ? key : transformFn(key);
-                result[transformedKey] = transform(val, depth + 1);
-            }
-            visited.delete(value);
-            return result;
-        }
-        // 其他类型（字符串、数字、布尔值等）直接返回
-        return value;
-    };
-    return transform(data, 0);
-};

package/dist/utils/normalizePathnameListInput.d.ts

@@ -1,16 +0,0 @@
-/**
- * 将未知输入规范化为 pathname 字符串数组。
- *
- * 规则（契约）：
- * - value 为“假值”（null/undefined/""/0/false/NaN）时返回空数组 []。
- * - value 必须是 string[]，否则抛错：`${fieldLabel} 必须是字符串数组`。
- * - 数组元素必须满足：
- *   - 类型为 string
- *   - 不允许为空字符串
- *   - 不允许包含任何空白字符（空格/制表符/换行等）
- *   - 必须以 "/" 开头（pathname）
- * - forbidMethodPrefix=true 时，禁止 "GET/POST/..." 等 method 前缀，并给出更明确的错误提示。
- *
- * 注意：该函数不会做任何隐式修复/转换（例如 trim/split/JSON.parse/去重/排序）。
- */
-export declare function normalizePathnameListInput(value: unknown, fieldLabel: string, forbidMethodPrefix: boolean): string[];

package/dist/utils/normalizePathnameListInput.js

@@ -1,48 +0,0 @@
-const HTTP_METHOD_PREFIX_RE = /^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\b/i;
-/**
- * 将未知输入规范化为 pathname 字符串数组。
- *
- * 规则（契约）：
- * - value 为“假值”（null/undefined/""/0/false/NaN）时返回空数组 []。
- * - value 必须是 string[]，否则抛错：`${fieldLabel} 必须是字符串数组`。
- * - 数组元素必须满足：
- *   - 类型为 string
- *   - 不允许为空字符串
- *   - 不允许包含任何空白字符（空格/制表符/换行等）
- *   - 必须以 "/" 开头（pathname）
- * - forbidMethodPrefix=true 时，禁止 "GET/POST/..." 等 method 前缀，并给出更明确的错误提示。
- *
- * 注意：该函数不会做任何隐式修复/转换（例如 trim/split/JSON.parse/去重/排序）。
- */
-export function normalizePathnameListInput(value, fieldLabel, forbidMethodPrefix) {
-    // “假值”统一视为空数组：null/undefined/""/0/false/NaN
-    if (!value)
-        return [];
-    if (!Array.isArray(value)) {
-        throw new Error(`${fieldLabel} 必须是字符串数组`);
-    }
-    const out = [];
-    for (let i = 0; i < value.length; i += 1) {
-        const item = value[i];
-        const itemLabel = `${fieldLabel}[${i}]`;
-        if (typeof item !== "string") {
-            throw new Error(`${itemLabel} 必须是字符串`);
-        }
-        if (item.length === 0) {
-            throw new Error(`${itemLabel} 不允许为空字符串`);
-        }
-        // 优先给出 method 前缀提示（更明确）
-        if (forbidMethodPrefix && HTTP_METHOD_PREFIX_RE.test(item)) {
-            throw new Error(`${itemLabel} 不允许包含 method 前缀，应为 url.pathname（例如 /api/app/xxx）`);
-        }
-        // 不做 trim 自动转换：含任何空白字符都视为不合法
-        if (/\s/.test(item)) {
-            throw new Error(`${itemLabel} 不允许包含空白字符（空格/制表符/换行等）`);
-        }
-        if (!item.startsWith("/")) {
-            throw new Error(`${itemLabel} 必须是 pathname（以 / 开头）`);
-        }
-        out.push(item);
-    }
-    return out;
-}