befly-shared 1.3.9 → 1.3.11

package/{types/arrayToTree.ts → dist/types/arrayToTree.d.ts}

@@ -1,11 +1,9 @@
 /**
  * arrayToTree 类型定义（类型模块，仅供 type 引用）。
  */
-
 export type ArrayToTreeResult<T extends Record<string, any>> = {
     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>;

package/dist/types/arrayToTree.js

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

package/{types/deepTransformKeys.ts → dist/types/deepTransformKeys.d.ts}

@@ -3,14 +3,10 @@
  *
  * 注意：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

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

package/{types/genShortId.ts → dist/types/genShortId.d.ts}

@@ -1,5 +1,4 @@
 /**
  * genShortId 类型定义（类型模块，仅供 type 引用）。
  */
-
 export type GenShortId = () => string;

package/dist/types/genShortId.js

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

package/{types/hashPassword.ts → dist/types/hashPassword.d.ts}

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

package/dist/types/hashPassword.js

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

package/{types/normalizePathnameListInput.ts → dist/types/normalizePathnameListInput.d.ts}

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

package/dist/types/normalizePathnameListInput.js

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

package/{types/scanViewsDir.ts → dist/types/scanViewsDir.d.ts}

@@ -1,25 +1,18 @@
 /**
  * scanViewsDir 相关纯函数的类型定义（类型模块，仅供 type 引用）。
  */
-
 export type ViewDirMeta = {
     title: string;
     order?: number;
 };
-
 export type MenuNodeLike<T> = {
     name?: string;
     path?: string;
     sort?: number;
     children?: T[];
 };
-
 export type CleanDirName = (name: string) => string;
-
 export type NormalizeMenuPath = (path: string) => string;
-
 export type NormalizeMenuTree = <T extends MenuNodeLike<T>>(menus: T[]) => T[];
-
 export type ExtractScriptSetupBlock = (vueContent: string) => string | null;
-
 export type ExtractDefinePageMetaFromScriptSetup = (scriptSetup: string) => ViewDirMeta | null;

package/dist/types/scanViewsDir.js

@@ -0,0 +1,4 @@
+/**
+ * scanViewsDir 相关纯函数的类型定义（类型模块，仅供 type 引用）。
+ */
+export {};

package/{types/withDefaultColumns.ts → dist/types/withDefaultColumns.d.ts}

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

package/dist/types/withDefaultColumns.js

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

package/dist/utils/arrayToTree.d.ts

@@ -0,0 +1,14 @@
+export type ArrayToTreeResult<T extends Record<string, any>> = {
+    flat: Array<T>;
+    tree: Array<T>;
+    map: Map<string, T>;
+};
+/**
+ * 将一维数组按 { id, pid } 组装为树形结构（纯函数 / 无副作用）。
+ *
+ * - 默认字段：id / pid / children / sort
+ * - pid 为空字符串或父节点不存在时，视为根节点
+ * - 内部会 clone 一份节点对象，并写入 children: []
+ * - 默认自带递归排序：按 sort 升序；sort 缺省/非法或 < 1 视为 999999；sort 相同按 id 自然序1
+ */
+export declare function arrayToTree<T extends Record<string, any>>(items: T[], id?: string, pid?: string, children?: string, sort?: string): ArrayToTreeResult<T>;

package/{utils/arrayToTree.ts → dist/utils/arrayToTree.js}

@@ -1,9 +1,3 @@
-export type ArrayToTreeResult<T extends Record<string, any>> = {
-    flat: Array<T>;
-    tree: Array<T>;
-    map: Map<string, T>;
-};
-
 /**
  * 将一维数组按 { id, pid } 组装为树形结构（纯函数 / 无副作用）。
  *
@@ -12,18 +6,15 @@ export type ArrayToTreeResult<T extends Record<string, any>> = {
  * - 内部会 clone 一份节点对象，并写入 children: []
  * - 默认自带递归排序：按 sort 升序；sort 缺省/非法或 < 1 视为 999999；sort 相同按 id 自然序1
  */
-export function arrayToTree<T extends Record<string, any>>(items: T[], id: string = "id", pid: string = "pid", children: string = "children", sort: string = "sort"): ArrayToTreeResult<T> {
+export function arrayToTree(items, id = "id", pid = "pid", children = "children", sort = "sort") {
     const idKey = typeof id === "string" && id.length > 0 ? id : "id";
     const pidKey = typeof pid === "string" && pid.length > 0 ? pid : "pid";
     const childrenKey = typeof children === "string" && children.length > 0 ? children : "children";
     const sortKey = typeof sort === "string" && sort.length > 0 ? sort : "sort";
-
-    const map = new Map<string, T>();
-    const flat: T[] = [];
-
+    const map = new Map();
+    const flat = [];
     const safeItems = Array.isArray(items) ? items : [];
-
-    const normalizeKey = (value: unknown): string => {
+    const normalizeKey = (value) => {
         if (typeof value === "string") {
             return value;
         }
@@ -32,47 +23,36 @@ export function arrayToTree<T extends Record<string, any>>(items: T[], id: strin
         }
         return "";
     };
-
     for (const item of safeItems) {
-        const rawId = item ? (item as any)[idKey] : undefined;
-        const rawPid = item ? (item as any)[pidKey] : undefined;
-
+        const rawId = item ? item[idKey] : undefined;
+        const rawPid = item ? item[pidKey] : undefined;
         const normalizedId = normalizeKey(rawId);
         const normalizedPid = normalizeKey(rawPid);
-
-        const nextNode = Object.assign({}, item) as T;
-        (nextNode as any)[idKey] = normalizedId;
-        (nextNode as any)[pidKey] = normalizedPid;
-        (nextNode as any)[childrenKey] = [];
-
+        const nextNode = Object.assign({}, item);
+        nextNode[idKey] = normalizedId;
+        nextNode[pidKey] = normalizedPid;
+        nextNode[childrenKey] = [];
         flat.push(nextNode);
-
         if (normalizedId.length > 0) {
             map.set(normalizedId, nextNode);
         }
     }
-
-    const tree: T[] = [];
-
+    const tree = [];
     for (const node of flat) {
-        const selfId = normalizeKey(node ? (node as any)[idKey] : undefined);
-        const parentId = normalizeKey(node ? (node as any)[pidKey] : undefined);
-
+        const selfId = normalizeKey(node ? node[idKey] : undefined);
+        const parentId = normalizeKey(node ? node[pidKey] : undefined);
         if (parentId.length > 0 && parentId !== selfId) {
             const parent = map.get(parentId);
-            if (parent && Array.isArray((parent as any)[childrenKey])) {
-                (parent as any)[childrenKey].push(node);
+            if (parent && Array.isArray(parent[childrenKey])) {
+                parent[childrenKey].push(node);
                 continue;
             }
         }
-
         tree.push(node);
     }
-
     const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
-
-    const getSortValue = (node: T): number => {
-        const raw = node ? (node as any)[sortKey] : undefined;
+    const getSortValue = (node) => {
+        const raw = node ? node[sortKey] : undefined;
         if (typeof raw !== "number") {
             return 999999;
         }
@@ -84,49 +64,38 @@ export function arrayToTree<T extends Record<string, any>>(items: T[], id: strin
         }
         return raw;
     };
-
-    const compareNode = (a: T, b: T): number => {
+    const compareNode = (a, b) => {
         const aSort = getSortValue(a);
         const bSort = getSortValue(b);
-
         if (aSort !== bSort) {
             return aSort - bSort;
         }
-
-        const aId = a ? (a as any)[idKey] : "";
-        const bId = b ? (b as any)[idKey] : "";
-
+        const aId = a ? a[idKey] : "";
+        const bId = b ? b[idKey] : "";
         return collator.compare(typeof aId === "string" ? aId : "", typeof bId === "string" ? bId : "");
     };
-
-    const sortTreeInPlace = (nodes: Array<T>, seen: WeakSet<object>): void => {
+    const sortTreeInPlace = (nodes, seen) => {
         if (!Array.isArray(nodes)) {
             return;
         }
-
         if (nodes.length > 1) {
             nodes.sort(compareNode);
         }
-
         for (const node of nodes) {
             if (typeof node !== "object" || node === null) {
                 continue;
             }
-
             if (seen.has(node)) {
                 continue;
             }
             seen.add(node);
-
-            const childNodes = (node as any)[childrenKey];
+            const childNodes = node[childrenKey];
             if (Array.isArray(childNodes) && childNodes.length > 0) {
                 sortTreeInPlace(childNodes, seen);
             }
         }
     };
-
-    sortTreeInPlace(tree, new WeakSet<object>());
-
+    sortTreeInPlace(tree, new WeakSet());
     return {
         flat: flat,
         tree: tree,

package/dist/utils/deepTransformKeys.d.ts

@@ -0,0 +1,84 @@
+/**
+ * 键名转换函数类型
+ */
+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/{utils/deepTransformKeys.ts → dist/utils/deepTransformKeys.js}

@@ -1,32 +1,5 @@
 import { isPlainObject } from "es-toolkit/compat";
 import { camelCase, snakeCase, kebabCase, pascalCase } from "es-toolkit/string";
-
-/**
- * 键名转换函数类型
- */
-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[];
-}
-
 /**
  * 深度递归遍历数据结构，转换所有键名
  * 支持嵌套对象和数组，自动防止循环引用和栈溢出
@@ -87,40 +60,41 @@ export interface TransformOptions {
  * }, 'camel')
  * // { userList: [{ userId: 1, userTags: [{ tagName: 'vip' }] }] }
  */
-export const deepTransformKeys = <T = any>(data: any, transformer: KeyTransformer | PresetTransform, options: TransformOptions = {}): T => {
+export const deepTransformKeys = (data, transformer, options = {}) => {
     const { maxDepth = 100, excludeKeys = [] } = options;
-
     // 获取实际的转换函数
-    let transformFn: KeyTransformer;
+    let transformFn;
     if (typeof transformer === "function") {
         transformFn = transformer;
-    } else if (transformer === "camel") {
+    }
+    else if (transformer === "camel") {
         transformFn = camelCase;
-    } else if (transformer === "snake") {
+    }
+    else if (transformer === "snake") {
         transformFn = snakeCase;
-    } else if (transformer === "kebab") {
+    }
+    else if (transformer === "kebab") {
         transformFn = kebabCase;
-    } else if (transformer === "pascal") {
+    }
+    else if (transformer === "pascal") {
         transformFn = pascalCase;
-    } else if (transformer === "upper") {
-        transformFn = (key: string) => key.toUpperCase();
-    } else {
-        transformFn = (key: string) => key.toLowerCase();
     }
-
+    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: any, depth: number): any => {
+    const transform = (value, depth) => {
         // 处理 null 和 undefined
         if (value === null || value === undefined) {
             return value;
         }
-
         // 处理数组
         if (Array.isArray(value)) {
             // 检测循环引用
@@ -128,18 +102,15 @@ export const deepTransformKeys = <T = any>(data: any, transformer: KeyTransforme
                 return value;
             }
             visited.add(value);
-
             // 检查深度限制：如果达到限制，返回原数组
             if (maxDepth > 0 && depth >= maxDepth) {
                 visited.delete(value);
                 return value;
             }
-
-            const result = value.map((item: any) => transform(item, depth + 1));
+            const result = value.map((item) => transform(item, depth + 1));
             visited.delete(value);
             return result;
         }
-
         // 处理对象
         if (isPlainObject(value)) {
             // 检测循环引用
@@ -147,14 +118,12 @@ export const deepTransformKeys = <T = any>(data: any, transformer: KeyTransforme
                 return value;
             }
             visited.add(value);
-
             // 检查深度限制：如果达到限制，返回原对象
             if (maxDepth > 0 && depth >= maxDepth) {
                 visited.delete(value);
                 return value;
             }
-
-            const result: any = {};
+            const result = {};
             for (const [key, val] of Object.entries(value)) {
                 // 检查是否在排除列表中
                 const transformedKey = excludeSet.has(key) ? key : transformFn(key);
@@ -163,10 +132,8 @@ export const deepTransformKeys = <T = any>(data: any, transformer: KeyTransforme
             visited.delete(value);
             return result;
         }
-
         // 其他类型（字符串、数字、布尔值等）直接返回
         return value;
     };
-
-    return transform(data, 0) as T;
+    return transform(data, 0);
 };

package/dist/utils/fieldClear.d.ts

@@ -0,0 +1,11 @@
+export interface FieldClearOptions {
+    pickKeys?: string[];
+    omitKeys?: string[];
+    keepValues?: any[];
+    excludeValues?: any[];
+    keepMap?: Record<string, any>;
+}
+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>;

package/{utils/fieldClear.ts → dist/utils/fieldClear.js}

@@ -1,40 +1,19 @@
-/**
- * @typedef {Object} FieldClearOptions
- * @property {string[]=} pickKeys
- * @property {string[]=} omitKeys
- * @property {any[]=} keepValues
- * @property {any[]=} excludeValues
- * @property {Record<string, any>=} keepMap
- */
-
+// fieldClear 工具函数实现（shared 版）
+// 支持 pick/omit/keepValues/excludeValues/keepMap，处理对象和数组
 function isObject(val) {
     return val !== null && typeof val === "object" && !Array.isArray(val);
 }
-
 function isArray(val) {
     return Array.isArray(val);
 }
-
-/**
- * 清理对象/数组字段
- * - 支持 pick/omit/keepValues/excludeValues
- * - 支持 keepMap 强制保留
- * @template T
- * @param {T|T[]} data
- * @param {FieldClearOptions=} options
- * @returns {any}
- */
 export function fieldClear(data, options = {}) {
     const pickKeys = options.pickKeys;
     const omitKeys = options.omitKeys;
     const keepValues = options.keepValues;
     const excludeValues = options.excludeValues;
     const keepMap = options.keepMap;
-
     const filterObj = (obj) => {
-        /** @type {Record<string, any>} */
         const result = {};
-
         let keys = Object.keys(obj);
         if (pickKeys && pickKeys.length) {
             keys = keys.filter((k) => pickKeys.includes(k));
@@ -42,10 +21,8 @@ export function fieldClear(data, options = {}) {
         if (omitKeys && omitKeys.length) {
             keys = keys.filter((k) => !omitKeys.includes(k));
         }
-
         for (const key of keys) {
             const value = obj[key];
-
             // 1. keepMap 优先
             if (keepMap && Object.prototype.hasOwnProperty.call(keepMap, key)) {
                 if (Object.is(keepMap[key], value)) {
@@ -53,42 +30,35 @@ export function fieldClear(data, options = {}) {
                     continue;
                 }
             }
-
             // 2. keepValues
             if (keepValues && keepValues.length && !keepValues.includes(value)) {
                 continue;
             }
-
             // 3. excludeValues
             if (excludeValues && excludeValues.length && excludeValues.includes(value)) {
                 continue;
             }
-
             result[key] = value;
         }
-
         return result;
     };
-
     if (isArray(data)) {
         return data
             .map((item) => {
-                if (isObject(item)) {
-                    return filterObj(item);
-                }
-                return item;
-            })
+            if (isObject(item)) {
+                return filterObj(item);
+            }
+            return item;
+        })
             .filter((item) => {
-                if (isObject(item)) {
-                    return Object.keys(item).length > 0;
-                }
-                return true;
-            });
+            if (isObject(item)) {
+                return Object.keys(item).length > 0;
+            }
+            return true;
+        });
     }
-
     if (isObject(data)) {
         return filterObj(data);
     }
-
     return data;
 }

package/dist/utils/genShortId.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 生成短 ID
+ * 由时间戳（base36）+ 随机字符组成，约 13 位
+ * - 前 8 位：时间戳（可排序）
+ * - 后 5 位：随机字符（防冲突）
+ * @returns 短 ID 字符串
+ * @example
+ * genShortId() // "lxyz1a2b3c4"
+ */
+export declare function genShortId(): string;

package/{utils/genShortId.ts → dist/utils/genShortId.js}

@@ -7,6 +7,6 @@
  * @example
  * genShortId() // "lxyz1a2b3c4"
  */
-export function genShortId(): string {
+export function genShortId() {
     return Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
 }

package/dist/utils/hashPassword.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 密码哈希工具
+ * 使用 SHA-256 + 盐值对密码进行单向哈希
+ */
+/**
+ * 使用 SHA-256 对密码进行哈希
+ * @param password - 原始密码
+ * @param salt - 盐值，默认为 befly
+ * @returns 哈希后的密码（十六进制字符串）
+ */
+export declare function hashPassword(password: string, salt?: string): Promise<string>;

package/{utils/hashPassword.ts → dist/utils/hashPassword.js}

@@ -2,26 +2,21 @@
  * 密码哈希工具
  * 使用 SHA-256 + 盐值对密码进行单向哈希
  */
-
 /**
  * 使用 SHA-256 对密码进行哈希
  * @param password - 原始密码
  * @param salt - 盐值，默认为 befly
  * @returns 哈希后的密码（十六进制字符串）
  */
-export async function hashPassword(password: string, salt: string = "befly"): Promise<string> {
+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/normalizePathnameListInput.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 将未知输入规范化为 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/{utils/normalizePathnameListInput.ts → dist/utils/normalizePathnameListInput.js}

@@ -1,5 +1,4 @@
 const HTTP_METHOD_PREFIX_RE = /^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\b/i;
-
 /**
  * 将未知输入规范化为 pathname 字符串数组。
  *
@@ -15,44 +14,35 @@ const HTTP_METHOD_PREFIX_RE = /^(GET|POST|PUT|PATCH|DELETE|OPTIONS|HEAD)\b/i;
  *
  * 注意：该函数不会做任何隐式修复/转换（例如 trim/split/JSON.parse/去重/排序）。
  */
-export function normalizePathnameListInput(value: unknown, fieldLabel: string, forbidMethodPrefix: boolean): string[] {
+export function normalizePathnameListInput(value, fieldLabel, forbidMethodPrefix) {
     // “假值”统一视为空数组：null/undefined/""/0/false/NaN
-    if (!value) return [];
-
+    if (!value)
+        return [];
     if (!Array.isArray(value)) {
         throw new Error(`${fieldLabel} 必须是字符串数组`);
     }
-
-    const out: string[] = [];
-
+    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;
 }

package/dist/utils/scanViewsDir.d.ts

@@ -0,0 +1,43 @@
+export type ViewDirMeta = {
+    title: string;
+    order?: number;
+};
+type MenuNodeLike<T> = {
+    name?: string;
+    path?: string;
+    sort?: number;
+    children?: T[];
+};
+/**
+ * 清理目录名中的数字后缀
+ * 如：login_1 → login, index_2 → index
+ */
+export declare function cleanDirName(name: string): string;
+/**
+ * 约束：统一 path 形态，避免隐藏菜单匹配、DB 同步出现重复
+ * - 必须以 / 开头
+ * - 折叠多个 /
+ * - 去掉尾随 /（根 / 除外）
+ */
+export declare function normalizeMenuPath(path: string): string;
+/**
+ * 递归规范化并按 path 去重（同 path 的 children 合并）
+ *
+ * 说明：该函数是纯函数，不依赖任何运行时环境；会返回新数组，但会在内部对克隆对象做合并赋值。
+ */
+export declare function normalizeMenuTree<T extends MenuNodeLike<T>>(menus: T[]): T[];
+/**
+ * 只取第一个 <script ... setup ...> 块
+ */
+export declare function extractScriptSetupBlock(vueContent: string): string | null;
+/**
+ * 从 <script setup> 中提取 definePage({ meta })
+ *
+ * 简化约束：
+ * - 每个页面只有一个 definePage
+ * - title 是纯字符串字面量
+ * - order 是数字字面量（可选）
+ * - 不考虑变量/表达式/多段 meta 组合
+ */
+export declare function extractDefinePageMetaFromScriptSetup(scriptSetup: string): ViewDirMeta | null;
+export {};

package/{utils/scanViewsDir.ts → dist/utils/scanViewsDir.js}

@@ -1,129 +1,97 @@
-export type ViewDirMeta = {
-    title: string;
-    order?: number;
-};
-
-type MenuNodeLike<T> = {
-    name?: string;
-    path?: string;
-    sort?: number;
-    children?: T[];
-};
-
 /**
  * 清理目录名中的数字后缀
  * 如：login_1 → login, index_2 → index
  */
-export function cleanDirName(name: string): string {
+export function cleanDirName(name) {
     return name.replace(/_\d+$/, "");
 }
-
 /**
  * 约束：统一 path 形态，避免隐藏菜单匹配、DB 同步出现重复
  * - 必须以 / 开头
  * - 折叠多个 /
  * - 去掉尾随 /（根 / 除外）
  */
-export function normalizeMenuPath(path: string): string {
+export function normalizeMenuPath(path) {
     let result = path;
-
     if (!result) {
         return "/";
     }
-
     if (!result.startsWith("/")) {
         result = `/${result}`;
     }
-
     result = result.replace(/\/+/g, "/");
-
     if (result.length > 1) {
         result = result.replace(/\/+$/, "");
     }
-
     return result;
 }
-
 /**
  * 递归规范化并按 path 去重（同 path 的 children 合并）
  *
  * 说明：该函数是纯函数，不依赖任何运行时环境；会返回新数组，但会在内部对克隆对象做合并赋值。
  */
-export function normalizeMenuTree<T extends MenuNodeLike<T>>(menus: T[]): T[] {
-    const map = new Map<string, T>();
-
+export function normalizeMenuTree(menus) {
+    const map = new Map();
     for (const menu of menus) {
         const rawPath = menu.path;
         const menuPath = rawPath ? normalizeMenuPath(rawPath) : "";
-
         if (!menuPath) {
             continue;
         }
-
         // 不使用 structuredClone：
         // - 结构中可能出现函数/类实例等不可 clone 的值
         // - 这里我们只需要“保留额外字段 + 递归 children 生成新数组”
         // 用浅拷贝即可满足需求
-        const cloned = Object.assign({}, menu) as T;
-        (cloned as any).path = menuPath;
-
+        const cloned = Object.assign({}, menu);
+        cloned.path = menuPath;
         const rawChildren = menu.children;
         if (rawChildren && rawChildren.length > 0) {
-            (cloned as any).children = normalizeMenuTree(rawChildren);
+            cloned.children = normalizeMenuTree(rawChildren);
         }
-
         const existing = map.get(menuPath);
         if (existing) {
-            const clonedChildren = (cloned as any).children as T[] | undefined;
+            const clonedChildren = cloned.children;
             if (clonedChildren && clonedChildren.length > 0) {
-                let existingChildren = (existing as any).children as T[] | undefined;
+                let existingChildren = existing.children;
                 if (!existingChildren) {
                     existingChildren = [];
-                    (existing as any).children = existingChildren;
+                    existing.children = existingChildren;
                 }
-
                 for (const child of clonedChildren) {
                     existingChildren.push(child);
                 }
-
-                (existing as any).children = normalizeMenuTree(existingChildren);
+                existing.children = normalizeMenuTree(existingChildren);
             }
-
             if (typeof cloned.sort === "number") {
-                (existing as any).sort = cloned.sort;
+                existing.sort = cloned.sort;
             }
-
             if (typeof cloned.name === "string" && cloned.name) {
-                (existing as any).name = cloned.name;
+                existing.name = cloned.name;
             }
-        } else {
+        }
+        else {
             map.set(menuPath, cloned);
         }
     }
-
     const result = Array.from(map.values());
-    result.sort((a, b) => ((a as any).sort ?? 999999) - ((b as any).sort ?? 999999));
+    result.sort((a, b) => (a.sort ?? 999999) - (b.sort ?? 999999));
     return result;
 }
-
 /**
  * 只取第一个 <script ... setup ...> 块
  */
-export function extractScriptSetupBlock(vueContent: string): string | null {
+export function extractScriptSetupBlock(vueContent) {
     const openTag = /<script\b[^>]*\bsetup\b[^>]*>/i.exec(vueContent);
     if (!openTag) {
         return null;
     }
-
     const start = openTag.index + openTag[0].length;
     const closeIndex = vueContent.indexOf("</script>", start);
     if (closeIndex < 0) {
         return null;
     }
-
     return vueContent.slice(start, closeIndex);
 }
-
 /**
  * 从 <script setup> 中提取 definePage({ meta })
  *
@@ -133,14 +101,12 @@ export function extractScriptSetupBlock(vueContent: string): string | null {
  * - order 是数字字面量（可选）
  * - 不考虑变量/表达式/多段 meta 组合
  */
-export function extractDefinePageMetaFromScriptSetup(scriptSetup: string): ViewDirMeta | null {
+export function extractDefinePageMetaFromScriptSetup(scriptSetup) {
     const titleMatch = scriptSetup.match(/definePage\s*\([\s\S]*?meta\s*:\s*\{[\s\S]*?title\s*:\s*(["'`])([^"'`]+)\1/);
     if (!titleMatch) {
         return null;
     }
-
     const orderMatch = scriptSetup.match(/definePage\s*\([\s\S]*?meta\s*:\s*\{[\s\S]*?order\s*:\s*(\d+)/);
-
     return {
         title: titleMatch[2],
         order: orderMatch ? Number(orderMatch[1]) : undefined

package/dist/utils/withDefaultColumns.d.ts

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

package/{utils/withDefaultColumns.ts → dist/utils/withDefaultColumns.js}

@@ -11,38 +11,28 @@
  * - colKey 以 At/At2 结尾时：默认 { align: "center" }
  * - customConfig 可覆盖/扩展默认 specialColumnConfig（浅合并/替换：若传入 operation 配置，将整体替换默认 operation 配置，默认 fixed="right" 不会被保留）
  */
-export function withDefaultColumns(columns: any[], customConfig?: Record<string, any>): any[] {
+export function withDefaultColumns(columns, customConfig) {
     const safeColumns = Array.isArray(columns) ? columns : [];
-
-    const specialColumnConfig: Record<string, any> = Object.assign(
-        {
-            operation: { width: 100, align: "center", fixed: "right" },
-            state: { width: 100, align: "center" },
-            id: { width: 200, align: "center" }
-        },
-        customConfig || {}
-    );
-
+    const specialColumnConfig = Object.assign({
+        operation: { width: 100, align: "center", fixed: "right" },
+        state: { width: 100, align: "center" },
+        id: { width: 200, align: "center" }
+    }, customConfig || {});
     return safeColumns.map((col) => {
-        const colKey = col && (col as any).colKey;
-
+        const colKey = col && col.colKey;
         let specialConfig = colKey ? specialColumnConfig[colKey] : undefined;
-
         if (!specialConfig && typeof colKey === "string" && (colKey.endsWith("At") || colKey.endsWith("At2"))) {
             specialConfig = { align: "center" };
         }
-
         const base = {
             width: 200,
             ellipsis: true
         };
-
         const merged = Object.assign({}, base);
         if (specialConfig) {
             Object.assign(merged, specialConfig);
         }
         Object.assign(merged, col);
-
         return merged;
     });
 }

package/package.json

@@ -1,23 +1,31 @@
 {
     "name": "befly-shared",
-    "version": "1.3.9",
-    "gitHead": "f5d17c019a58e82cfacec5ce3a1f04e3225ba838",
+    "version": "1.3.11",
+    "gitHead": "0914e9a6efb3f41136034f14d5f9cda4d5e7c3d0",
     "private": false,
     "description": "Befly 纯函数与纯常量共享包（不包含 Node/浏览器特定实现）",
     "license": "Apache-2.0",
     "author": "chensuiyi <bimostyle@qq.com>",
     "files": [
-        "package.json",
-        "types/",
-        "utils/"
+        "dist/"
     ],
     "type": "module",
     "exports": {
-        "./utils/*": "./utils/*.ts",
-        "./types/*": "./types/*.ts"
+        "./utils/*": {
+            "types": "./dist/utils/*.d.ts",
+            "default": "./dist/utils/*.js"
+        },
+        "./types/*": {
+            "types": "./dist/types/*.d.ts",
+            "default": "./dist/types/*.js"
+        }
     },
     "scripts": {
-        "test": "bun test"
+        "clean": "rimraf dist",
+        "build": "bunx tsgo -p tsconfig.build.json",
+        "test": "bun test",
+        "prepack": "bun run build && bun run ./scripts/ensureDist.ts",
+        "typecheck": "bunx tsgo -p tsconfig.json --noEmit"
     },
     "dependencies": {
         "es-toolkit": "^1.43.0"