befly-shared 1.2.8 → 1.3.1

package/dist/scanConfig.js

@@ -1,83 +0,0 @@
-import { existsSync } from 'node:fs';
-import { isAbsolute, join } from 'node:path';
-import { mergeAndConcat } from 'merge-anything';
-import { isPlainObject } from 'es-toolkit';
-import { get, set } from 'es-toolkit/compat';
-/**
- * 扫描并合并配置文件（矩阵搜索：dirs × files）
- * @param options - 加载选项
- * @returns 合并后的配置对象（或第一个找到的配置）
- */
-export async function scanConfig(options) {
-    const { 
-    //
-    cwd = process.cwd(), dirs, files, extensions = ['.js', '.ts', '.json'], mode = 'first', paths, defaults = {} } = options;
-    // 参数验证
-    if (!Array.isArray(dirs) || dirs.length === 0) {
-        throw new Error('dirs 必须是非空数组');
-    }
-    if (!Array.isArray(files) || files.length === 0) {
-        throw new Error('files 必须是非空数组');
-    }
-    const configs = [];
-    // 矩阵搜索：dirs × files × extensions
-    for (const dir of dirs) {
-        // 如果是绝对路径则直接使用，否则拼接 cwd
-        const fullDir = isAbsolute(dir) ? dir : join(cwd, dir);
-        for (const file of files) {
-            for (const ext of extensions) {
-                const fileName = file.endsWith(ext) ? file : file + ext;
-                const filePath = join(fullDir, fileName);
-                if (existsSync(filePath)) {
-                    try {
-                        // 动态导入配置文件（使用 import 断言处理 JSON）
-                        let data;
-                        if (ext === '.json') {
-                            // JSON 文件使用 import 断言
-                            const module = await import(filePath, { with: { type: 'json' } });
-                            data = module.default;
-                        }
-                        else {
-                            // JS/TS 文件使用动态导入
-                            const module = await import(filePath);
-                            data = module.default || module;
-                            // 处理 async 函数导出（如 defineAddonConfig）
-                            if (data instanceof Promise) {
-                                data = await data;
-                            }
-                        }
-                        // 验证配置数据
-                        if (!isPlainObject(data)) {
-                            continue;
-                        }
-                        configs.push(data);
-                        // 如果模式为 'first'，找到第一个配置后立即返回
-                        if (mode === 'first') {
-                            return data;
-                        }
-                        // 找到后跳过同名文件的其他扩展名
-                        break;
-                    }
-                    catch (error) {
-                        console.error(`加载配置文件失败: ${filePath}`, error.message);
-                    }
-                }
-            }
-        }
-    }
-    // 合并配置（使用 mergeAndConcat 深度合并）
-    // 合并顺序：defaults ← configs[0] ← configs[1] ← ...
-    const finalConfig = mergeAndConcat(defaults, ...configs);
-    // 如果指定了 paths，则只返回指定路径的字段
-    if (paths && paths.length > 0) {
-        const result = {};
-        for (const path of paths) {
-            const value = get(finalConfig, path);
-            if (value !== undefined) {
-                set(result, path, value);
-            }
-        }
-        return result;
-    }
-    return finalConfig;
-}

package/dist/scanFiles.js

@@ -1,39 +0,0 @@
-import { existsSync } from 'node:fs';
-import { relative, basename, normalize } from 'pathe';
-/**
- * 扫描指定目录下的文件
- * @param dir 目录路径
- * @param pattern Glob 模式
- * @param ignoreUnderline 是否忽略下划线开头的文件/目录
- */
-export async function scanFiles(dir, pattern = '**/*.{ts,js}', ignoreUnderline = true) {
-    if (!existsSync(dir))
-        return [];
-    const normalizedDir = normalize(dir);
-    const glob = new Bun.Glob(pattern);
-    const results = [];
-    for await (const file of glob.scan({ cwd: dir, onlyFiles: true, absolute: true })) {
-        if (file.endsWith('.d.ts'))
-            continue;
-        // 使用 pathe.normalize 统一路径分隔符为 /
-        const normalizedFile = normalize(file);
-        // 获取文件名（去除扩展名）
-        const fileName = basename(normalizedFile).replace(/\.[^.]+$/, '');
-        // 计算相对路径（pathe.relative 返回的已经是正斜杠路径）
-        const relativePath = relative(normalizedDir, normalizedFile).replace(/\.[^/.]+$/, '');
-        if (ignoreUnderline) {
-            // 检查文件名是否以下划线开头
-            if (fileName.startsWith('_'))
-                continue;
-            // 检查路径中是否包含下划线开头的目录
-            if (relativePath.split('/').some((part) => part.startsWith('_')))
-                continue;
-        }
-        results.push({
-            filePath: normalizedFile,
-            relativePath,
-            fileName
-        });
-    }
-    return results;
-}

package/dist/scanViews.js

@@ -1,48 +0,0 @@
-import { readdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-/**
- * 扫描项目和所有 @befly-addon 包的 views 目录
- * 用于 unplugin-vue-router 的 routesFolder 配置
- * 注意:此函数只能在 vite.config.js 中使用(Node.js 环境),不能在浏览器中使用
- * @returns 路由文件夹配置数组
- */
-export function scanViews() {
-    // 使用绝对路径：基于项目根目录（process.cwd()）
-    const projectRoot = process.cwd();
-    const addonBasePath = join(projectRoot, 'node_modules', '@befly-addon');
-    const routesFolders = [];
-    // 1. 先添加项目自己的 views 目录
-    const projectViewsPath = join(projectRoot, 'src', 'views');
-    if (existsSync(projectViewsPath)) {
-        routesFolders.push({
-            src: projectViewsPath,
-            path: '',
-            exclude: ['**/components/**']
-        });
-    }
-    // 2. 扫描 @befly-addon 包的 views 目录
-    if (!existsSync(addonBasePath)) {
-        return routesFolders;
-    }
-    try {
-        const addonDirs = readdirSync(addonBasePath);
-        for (const addonName of addonDirs) {
-            const addonPath = join(addonBasePath, addonName);
-            // 检查是否为目录（包括符号链接）
-            if (!existsSync(addonPath))
-                continue;
-            const viewsPath = join(addonPath, 'views');
-            if (existsSync(viewsPath)) {
-                routesFolders.push({
-                    src: viewsPath,
-                    path: `addon/${addonName}/`,
-                    exclude: ['**/components/**']
-                });
-            }
-        }
-    }
-    catch (error) {
-        console.error('扫描 @befly-addon 目录失败:', error);
-    }
-    return routesFolders;
-}

package/dist/withDefaultColumns.js

@@ -1,32 +0,0 @@
-/**
- * 为表格列添加默认配置
- * @param columns - 列配置数组
- * @param customConfig - 自定义特殊列配置，可覆盖默认的 specialColumnConfig
- * @returns 添加默认配置后的列数组
- */
-export function withDefaultColumns(columns, customConfig = {}) {
-    /**
-     * 特殊列配置映射
-     */
-    const specialColumnConfig = {
-        operation: { width: 100, align: 'center', fixed: 'right' },
-        state: { width: 100, align: 'center' },
-        id: { width: 200, align: 'center' },
-        ...customConfig
-    };
-    return columns.map((col) => {
-        const colKey = col.colKey;
-        // 特殊列配置
-        let specialConfig = specialColumnConfig[colKey];
-        // 以 At 或 At2 结尾的列（时间字段）
-        if (!specialConfig && colKey && (colKey.endsWith('At') || colKey.endsWith('At2'))) {
-            specialConfig = { align: 'center' };
-        }
-        return {
-            width: 200,
-            ellipsis: true,
-            ...specialConfig,
-            ...col
-        };
-    });
-}

package/src/addonHelper.ts

@@ -1,88 +0,0 @@
-import fs from 'node:fs';
-import { join } from 'pathe';
-import { statSync, existsSync } from 'node:fs';
-
-/**
- * 扫描所有可用的 addon
- * 优先从本地 addons/ 目录加载，其次从 node_modules/@befly-addon/ 加载
- * @param cwd - 项目根目录，默认为 process.cwd()
- * @returns addon 名称数组
- */
-export const scanAddons = (cwd: string = process.cwd()): string[] => {
-    const addons = new Set<string>();
-    // const projectAddonsDir = join(cwd, 'addons');
-
-    // 1. 扫描本地 addons 目录（优先级高）
-    // if (existsSync(projectAddonsDir)) {
-    //     try {
-    //         const localAddons = fs.readdirSync(projectAddonsDir).filter((name) => {
-    //             const fullPath = join(projectAddonsDir, name);
-    //             try {
-    //                 const stat = statSync(fullPath);
-    //                 return stat.isDirectory() && !name.startsWith('_');
-    //             } catch {
-    //                 return false;
-    //             }
-    //         });
-    //         localAddons.forEach((name) => addons.add(name));
-    //     } catch (err) {
-    //         // 忽略本地目录读取错误
-    //     }
-    // }
-
-    // 2. 扫描 node_modules/@befly-addon 目录
-    const beflyDir = join(cwd, 'node_modules', '@befly-addon');
-    if (existsSync(beflyDir)) {
-        try {
-            const npmAddons = fs.readdirSync(beflyDir).filter((name) => {
-                // 如果本地已存在，跳过 npm 包版本
-                if (addons.has(name)) return false;
-
-                const fullPath = join(beflyDir, name);
-                try {
-                    const stat = statSync(fullPath);
-                    return stat.isDirectory();
-                } catch {
-                    return false;
-                }
-            });
-            npmAddons.forEach((name) => addons.add(name));
-        } catch {
-            // 忽略 npm 目录读取错误
-        }
-    }
-
-    return Array.from(addons).sort();
-};
-
-/**
- * 获取 addon 的指定子目录路径
- * 优先返回本地 addons 目录，其次返回 node_modules 目录
- * @param name - addon 名称
- * @param subDir - 子目录名称
- * @param cwd - 项目根目录，默认为 process.cwd()
- * @returns 完整路径
- */
-export const getAddonDir = (name: string, subDir: string, cwd: string = process.cwd()): string => {
-    // 优先使用本地 addons 目录
-    // const projectAddonsDir = join(cwd, 'addons');
-    // const localPath = join(projectAddonsDir, name, subDir);
-    // if (existsSync(localPath)) {
-    //     return localPath;
-    // }
-
-    // 降级使用 node_modules 目录
-    return join(cwd, 'node_modules', '@befly-addon', name, subDir);
-};
-
-/**
- * 检查 addon 子目录是否存在
- * @param name - addon 名称
- * @param subDir - 子目录名称
- * @param cwd - 项目根目录，默认为 process.cwd()
- * @returns 是否存在
- */
-export const addonDirExists = (name: string, subDir: string, cwd: string = process.cwd()): boolean => {
-    const dir = getAddonDir(name, subDir, cwd);
-    return existsSync(dir) && statSync(dir).isDirectory();
-};

package/src/arrayKeysToCamel.ts

@@ -1,18 +0,0 @@
-import { keysToCamel } from './keysToCamel.js';
-
-/**
- * 数组对象字段名批量转小驼峰
- * @param arr - 源数组
- * @returns 字段名转为小驼峰格式的新数组
- *
- * @example
- * arrayKeysToCamel([
- *   { user_id: 1, user_name: 'John' },
- *   { user_id: 2, user_name: 'Jane' }
- * ])
- * // [{ userId: 1, userName: 'John' }, { userId: 2, userName: 'Jane' }]
- */
-export const arrayKeysToCamel = <T = any>(arr: Record<string, any>[]): T[] => {
-    if (!arr || !Array.isArray(arr)) return arr as T[];
-    return arr.map((item) => keysToCamel<T>(item));
-};

package/src/arrayToTree.ts

@@ -1,31 +0,0 @@
-// arrayToTree 工具函数实现
-
-export interface ArrayToTreeOptions<T = any> {
-    idField?: string; // 节点 id 字段名，默认 'id'
-    pidField?: string; // 父节点 id 字段名，默认 'pid'
-    childrenField?: string; // 子节点字段名，默认 'children'
-    rootPid?: any; // 根节点的父 id，默认 0
-    mapFn?: (node: T) => T; // 节点转换函数
-}
-
-export function arrayToTree<T = any>(items: T[], options: ArrayToTreeOptions<T> = {}): T[] {
-    const { idField = 'id', pidField = 'pid', childrenField = 'children', rootPid = 0, mapFn } = options;
-    const tree: T[] = [];
-    for (const item of items) {
-        const pid = (item as any)[pidField];
-        // 用 Object.is 判断，兼容 null/undefined/0
-        if (Object.is(pid, rootPid)) {
-            let node = { ...item };
-            if (mapFn) node = mapFn(node);
-            const children = arrayToTree(items, {
-                ...options,
-                rootPid: (node as any)[idField]
-            });
-            if (children.length > 0) {
-                (node as any)[childrenField] = children;
-            }
-            tree.push(node);
-        }
-    }
-    return tree;
-}

package/src/calcPerfTime.ts

@@ -1,13 +0,0 @@
-/**
- * 计算性能时间差
- */
-export const calcPerfTime = (startTime: number, endTime: number = Bun.nanoseconds()): string => {
-    const elapsedMs = (endTime - startTime) / 1_000_000;
-
-    if (elapsedMs < 1000) {
-        return `${elapsedMs.toFixed(2)} 毫秒`;
-    } else {
-        const elapsedSeconds = elapsedMs / 1000;
-        return `${elapsedSeconds.toFixed(2)} 秒`;
-    }
-};

package/src/configTypes.ts

@@ -1,29 +0,0 @@
-/**
- * 加载配置选项
- */
-export interface LoadConfigOptions {
-    /** 当前工作目录，默认 process.cwd() */
-    cwd?: string;
-    /** 目录数组：要搜索的目录路径（相对于 cwd） */
-    dirs: string[];
-    /** 文件数组：要匹配的文件名 */
-    files: string[];
-    /** 文件扩展名，默认 ['.js', '.ts', '.json'] */
-    extensions?: string[];
-    /** 加载模式：'first' = 返回第一个找到的配置（默认），'merge' = 合并所有配置 */
-    mode?: 'merge' | 'first';
-    /** 指定要提取的字段路径数组，如 ['menus', 'database.host']，为空则返回完整对象 */
-    paths?: string[];
-    /** 默认配置，会与找到的配置合并（优先级最低） */
-    defaults?: Record<string, any>;
-}
-
-/**
- * Addon 配置合并选项（已废弃，仅用于向后兼容）
- */
-export interface MergeConfigOptions {
-    /** 合并策略（已废弃，始终使用 deep） */
-    strategy?: 'deep' | 'shallow' | 'override';
-    /** 是否克隆数据（已废弃） */
-    clone?: boolean;
-}

package/src/constants.ts

@@ -1,60 +0,0 @@
-/**
- * Befly 共享常量定义
- * 运行时使用的常量（非纯类型）
- */
-
-// ============================================
-// API 响应码常量
-// ============================================
-
-/**
- * API 响应码
- */
-export const ApiCode = {
-    /** 成功 */
-    SUCCESS: 0,
-    /** 通用失败 */
-    FAIL: 1,
-    /** 未授权 */
-    UNAUTHORIZED: 401,
-    /** 禁止访问 */
-    FORBIDDEN: 403,
-    /** 未找到 */
-    NOT_FOUND: 404,
-    /** 服务器错误 */
-    SERVER_ERROR: 500
-} as const;
-
-/**
- * API 响应码类型
- */
-export type ApiCodeType = (typeof ApiCode)[keyof typeof ApiCode];
-
-// ============================================
-// 错误消息常量
-// ============================================
-
-/**
- * 通用错误消息
- */
-export const ErrorMessages = {
-    /** 未授权 */
-    UNAUTHORIZED: '请先登录',
-    /** 禁止访问 */
-    FORBIDDEN: '无访问权限',
-    /** 未找到 */
-    NOT_FOUND: '资源不存在',
-    /** 服务器错误 */
-    SERVER_ERROR: '服务器错误',
-    /** 参数错误 */
-    INVALID_PARAMS: '参数错误',
-    /** Token 过期 */
-    TOKEN_EXPIRED: 'Token 已过期',
-    /** Token 无效 */
-    TOKEN_INVALID: 'Token 无效'
-} as const;
-
-/**
- * 错误消息类型
- */
-export type ErrorMessageType = (typeof ErrorMessages)[keyof typeof ErrorMessages];

package/src/deepTransformKeys.ts

@@ -1,172 +0,0 @@
-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[];
-}
-
-/**
- * 深度递归遍历数据结构，转换所有键名
- * 支持嵌套对象和数组，自动防止循环引用和栈溢出
- *
- * @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 = <T = any>(data: any, transformer: KeyTransformer | PresetTransform, options: TransformOptions = {}): T => {
-    const { maxDepth = 100, excludeKeys = [] } = options;
-
-    // 获取实际的转换函数
-    let transformFn: KeyTransformer;
-    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: string) => key.toUpperCase();
-    } else {
-        transformFn = (key: string) => key.toLowerCase();
-    }
-
-    // 用于检测循环引用的 WeakSet
-    const visited = new WeakSet();
-
-    // 创建排除键名集合，提升查找性能
-    const excludeSet = new Set(excludeKeys);
-
-    // 递归转换函数
-    const transform = (value: any, depth: number): any => {
-        // 处理 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: any) => 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: any = {};
-            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) as T;
-};