befly 3.10.18 → 3.11.1

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

@@ -1,26 +1,5 @@
-import { camelCase } from "es-toolkit/string";
-
-import { Logger } from "../lib/logger.ts";
-
-export type SortModulesByDepsOptions<T> = {
-    /**
-     * 用于日志的模块标签（如："插件"、"钩子"）
-     */
-    moduleLabel?: string;
-
-    /**
-     * 生成模块名（用于 deps 解析与排序 key）。
-     * 默认：camelCase(item.fileName)
-     */
-    getName?: (item: T) => string;
-
-    /**
-     * 获取 deps。
-     * 默认：item.deps
-     */
-    getDeps?: (item: T) => string[];
-};
-
+import { Logger } from "../lib/logger";
+import { camelCase } from "./util";
 /**
  * 按 deps 拓扑排序 scanSources 扫描得到的插件/钩子。
  *
@@ -29,109 +8,90 @@ export type SortModulesByDepsOptions<T> = {
  * - deps 里的字符串会与 getName(item) 的结果匹配。
  * - 若出现：重复 name、缺失依赖、循环依赖，则返回 false。
  */
-export function sortModules<T extends { fileName: string; deps?: any }>(items: T[], options: SortModulesByDepsOptions<T> = {}): T[] | false {
+export function sortModules(items, options = {}) {
     const moduleLabel = options.moduleLabel || "模块";
-    const getName =
-        options.getName ||
-        ((item: T) => {
-            const moduleName = (item as any).moduleName;
+    const getName = options.getName ||
+        ((item) => {
+            const moduleName = item.moduleName;
             if (typeof moduleName === "string" && moduleName.trim() !== "") {
                 return moduleName;
             }
             return camelCase(item.fileName);
         });
-    const getDeps = options.getDeps || ((item: T) => (item as any).deps);
-
-    const result: T[] = [];
-    const visited = new Set<string>();
-    const visiting = new Set<string>();
-
-    const nameToItem: Record<string, T> = {};
+    const getDeps = options.getDeps || ((item) => item.deps);
+    const result = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const nameToItem = {};
     let isPass = true;
-
     // 1) 建表 + 重名检查
     for (const item of items) {
         const name = getName(item);
-
         if (typeof name !== "string" || name.trim() === "") {
             Logger.error({ item: item }, `${moduleLabel} 名称解析失败（getName 返回空字符串）`);
             isPass = false;
             continue;
         }
-
         if (nameToItem[name]) {
-            Logger.error(
-                {
-                    name: name,
-                    first: nameToItem[name],
-                    second: item
-                },
-                `${moduleLabel} 名称重复，无法根据 deps 唯一定位`
-            );
+            Logger.error({
+                name: name,
+                first: nameToItem[name],
+                second: item
+            }, `${moduleLabel} 名称重复，无法根据 deps 唯一定位`);
             isPass = false;
             continue;
         }
-
         nameToItem[name] = item;
     }
-
-    if (!isPass) return false;
-
+    if (!isPass)
+        return false;
     // 2) 依赖存在性检查 + deps 类型检查
     for (const item of items) {
         const name = getName(item);
         const deps = getDeps(item);
-
         if (!Array.isArray(deps)) {
             Logger.error({ module: name, item: item }, `${moduleLabel} 的 deps 必须是数组`);
             isPass = false;
             continue;
         }
-
         for (const dep of deps) {
             if (typeof dep !== "string") {
                 Logger.error({ module: name, dependency: dep, item: item }, `${moduleLabel} 的 deps 必须是字符串数组`);
                 isPass = false;
                 continue;
             }
-
             if (!nameToItem[dep]) {
                 Logger.error({ module: name, dependency: dep }, `${moduleLabel} 依赖未找到`);
                 isPass = false;
             }
         }
     }
-
-    if (!isPass) return false;
-
+    if (!isPass)
+        return false;
     // 3) 拓扑排序（DFS）
-    const visit = (name: string): void => {
-        if (visited.has(name)) return;
+    const visit = (name) => {
+        if (visited.has(name))
+            return;
         if (visiting.has(name)) {
             Logger.error({ module: name }, `${moduleLabel} 循环依赖`);
             isPass = false;
             return;
         }
-
         const item = nameToItem[name];
-        if (!item) return;
-
-        const deps = getDeps(item) as string[];
-
+        if (!item)
+            return;
+        const deps = getDeps(item);
         visiting.add(name);
         for (const dep of deps) {
             visit(dep);
         }
         visiting.delete(name);
-
         visited.add(name);
         result.push(item);
     };
-
     for (const item of items) {
         const name = getName(item);
         visit(name);
     }
-
     return isPass ? result : false;
 }

package/dist/utils/util.d.ts

@@ -0,0 +1,84 @@
+/**
+ * 注意：本文件用于集中维护 core 内部通用 utils。
+ * - 按项目规范：避免零散小文件噪音；实现集中在本文件，而不是做 re-export 聚合。
+ * - 仅在 packages/core 内部使用；core 对外不承诺这些路径导出。
+ */
+export declare function isPlainObject(value: unknown): value is Record<string, any>;
+/**
+ * 激进空值判断（项目约定）：
+ * - null/undefined => empty
+ * - "" / 全空白字符串 => empty
+ * - 0 / NaN => empty
+ * - false => empty
+ * - Array => length === 0
+ * - Map/Set => size === 0
+ * - plain object => 无自有 key
+ * - 其他类型 => false
+ */
+export declare function isEmpty(value: unknown): boolean;
+export declare function forOwn(obj: unknown, iteratee: (value: any, key: string) => void): void;
+/**
+ * 把字符串转为小驼峰。
+ * - 主要用于文件名/目录名（例如 my_plugin / my-plugin / my plugin）。
+ */
+export declare function camelCase(input: string): string;
+/**
+ * 把字符串转为 snake_case。
+ * - 主要用于表名/字段名（例如 userId -> user_id）。
+ */
+export declare function snakeCase(input: string): string;
+/**
+ * 对象字段名转小驼峰
+ * @param obj - 源对象
+ * @returns 字段名转为小驼峰格式的新对象
+ *
+ * @example
+ * keysToCamel({ user_id: 123, user_name: 'John' }) // { userId: 123, userName: 'John' }
+ * keysToCamel({ created_at: 1697452800000 }) // { createdAt: 1697452800000 }
+ */
+export declare const keysToCamel: <T = any>(obj: Record<string, any>) => T;
+/**
+ * 对象字段名转下划线
+ * @param obj - 源对象
+ * @returns 字段名转为下划线格式的新对象
+ *
+ * @example
+ * keysToSnake({ userId: 123, userName: 'John' }) // { user_id: 123, user_name: 'John' }
+ * keysToSnake({ createdAt: 1697452800000 }) // { created_at: 1697452800000 }
+ */
+export declare const keysToSnake: <T = any>(obj: Record<string, any>) => T;
+/**
+ * 数组对象字段名批量转小驼峰
+ * @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 declare const arrayKeysToCamel: <T = any>(arr: Record<string, any>[]) => T[];
+export declare function getByPath(obj: unknown, path: string): unknown;
+export declare function setByPath(target: Record<string, any>, path: string, value: unknown): void;
+/**
+ * 返回一个移除指定 key 的浅拷贝。
+ * - 仅处理 plain object；其他类型返回空对象，避免日志场景抛错。
+ */
+export declare function omit<T extends Record<string, any>>(obj: unknown, keys: string[]): Partial<T>;
+/**
+ * 挑选指定字段
+ */
+export declare const pickFields: <T extends Record<string, any>>(obj: T, keys: string[]) => Partial<T>;
+export declare function keyBy<T>(items: T[], getKey: (item: T) => string): Record<string, T>;
+/**
+ * 生成短 ID
+ * 由时间戳（base36）+ 随机字符组成，约 13 位
+ * - 前 8 位：时间戳（可排序）
+ * - 后 5 位：随机字符（防冲突）
+ * @returns 短 ID 字符串
+ * @example
+ * genShortId() // "lxyz1a2b3c4"
+ */
+export declare function genShortId(): string;

package/dist/utils/util.js

@@ -0,0 +1,262 @@
+/**
+ * 注意：本文件用于集中维护 core 内部通用 utils。
+ * - 按项目规范：避免零散小文件噪音；实现集中在本文件，而不是做 re-export 聚合。
+ * - 仅在 packages/core 内部使用；core 对外不承诺这些路径导出。
+ */
+export function isPlainObject(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * 激进空值判断（项目约定）：
+ * - null/undefined => empty
+ * - "" / 全空白字符串 => empty
+ * - 0 / NaN => empty
+ * - false => empty
+ * - Array => length === 0
+ * - Map/Set => size === 0
+ * - plain object => 无自有 key
+ * - 其他类型 => false
+ */
+export function isEmpty(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value === "string") {
+        return value.trim().length === 0;
+    }
+    if (typeof value === "number") {
+        return value === 0 || Number.isNaN(value);
+    }
+    if (typeof value === "boolean") {
+        return value === false;
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (value instanceof Map || value instanceof Set) {
+        return value.size === 0;
+    }
+    if (isPlainObject(value)) {
+        return Object.keys(value).length === 0;
+    }
+    return false;
+}
+export function forOwn(obj, iteratee) {
+    if (typeof iteratee !== "function") {
+        return;
+    }
+    if (!isPlainObject(obj)) {
+        return;
+    }
+    for (const key of Object.keys(obj)) {
+        iteratee(obj[key], key);
+    }
+}
+function toWordParts(input) {
+    const normalized = String(input)
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[^a-zA-Z0-9]+/g, " ")
+        .trim();
+    if (normalized.length === 0) {
+        return [];
+    }
+    return normalized.split(/\s+/).filter((p) => p.length > 0);
+}
+function upperFirst(s) {
+    if (s.length === 0) {
+        return s;
+    }
+    return s[0].toUpperCase() + s.slice(1);
+}
+/**
+ * 把字符串转为小驼峰。
+ * - 主要用于文件名/目录名（例如 my_plugin / my-plugin / my plugin）。
+ */
+export function camelCase(input) {
+    const parts = toWordParts(input);
+    if (parts.length === 0) {
+        return "";
+    }
+    const first = parts[0].toLowerCase();
+    const rest = parts.slice(1).map((p) => upperFirst(p.toLowerCase()));
+    return [first, ...rest].join("");
+}
+function normalizeToWords(input) {
+    return String(input)
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[^a-zA-Z0-9]+/g, " ")
+        .trim();
+}
+/**
+ * 把字符串转为 snake_case。
+ * - 主要用于表名/字段名（例如 userId -> user_id）。
+ */
+export function snakeCase(input) {
+    const normalized = normalizeToWords(input);
+    if (normalized.length === 0) {
+        return "";
+    }
+    return normalized
+        .split(/\s+/)
+        .filter((p) => p.length > 0)
+        .map((p) => p.toLowerCase())
+        .join("_");
+}
+/**
+ * 对象字段名转小驼峰
+ * @param obj - 源对象
+ * @returns 字段名转为小驼峰格式的新对象
+ *
+ * @example
+ * keysToCamel({ user_id: 123, user_name: 'John' }) // { userId: 123, userName: 'John' }
+ * keysToCamel({ created_at: 1697452800000 }) // { createdAt: 1697452800000 }
+ */
+export const keysToCamel = (obj) => {
+    if (!obj || !isPlainObject(obj))
+        return obj;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const camelKey = camelCase(key);
+        result[camelKey] = value;
+    }
+    return result;
+};
+/**
+ * 对象字段名转下划线
+ * @param obj - 源对象
+ * @returns 字段名转为下划线格式的新对象
+ *
+ * @example
+ * keysToSnake({ userId: 123, userName: 'John' }) // { user_id: 123, user_name: 'John' }
+ * keysToSnake({ createdAt: 1697452800000 }) // { created_at: 1697452800000 }
+ */
+export const keysToSnake = (obj) => {
+    if (!obj || !isPlainObject(obj))
+        return obj;
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const snakeKey = snakeCase(key);
+        result[snakeKey] = value;
+    }
+    return result;
+};
+/**
+ * 数组对象字段名批量转小驼峰
+ * @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 = (arr) => {
+    if (!arr || !Array.isArray(arr))
+        return arr;
+    return arr.map((item) => keysToCamel(item));
+};
+export function getByPath(obj, path) {
+    if (!path) {
+        return obj;
+    }
+    const parts = path.split(".");
+    let cur = obj;
+    for (const part of parts) {
+        if (cur === null || cur === undefined) {
+            return undefined;
+        }
+        if (typeof cur !== "object") {
+            return undefined;
+        }
+        cur = cur[part];
+    }
+    return cur;
+}
+export function setByPath(target, path, value) {
+    const parts = path.split(".");
+    // 避免无效 path（如 a..b）导致部分写入
+    for (const part of parts) {
+        if (!part) {
+            return;
+        }
+    }
+    let cur = target;
+    for (let i = 0; i < parts.length; i++) {
+        const key = parts[i];
+        const isLast = i === parts.length - 1;
+        if (isLast) {
+            cur[key] = value;
+            return;
+        }
+        const nextVal = cur[key];
+        if (!isPlainObject(nextVal)) {
+            cur[key] = {};
+        }
+        cur = cur[key];
+    }
+}
+/**
+ * 返回一个移除指定 key 的浅拷贝。
+ * - 仅处理 plain object；其他类型返回空对象，避免日志场景抛错。
+ */
+export function omit(obj, keys) {
+    if (!isPlainObject(obj)) {
+        return {};
+    }
+    const keySet = new Set(Array.isArray(keys) ? keys : []);
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (keySet.has(k)) {
+            continue;
+        }
+        out[k] = v;
+    }
+    return out;
+}
+/**
+ * 挑选指定字段
+ */
+export const pickFields = (obj, keys) => {
+    if (!obj || (!isPlainObject(obj) && !Array.isArray(obj))) {
+        return {};
+    }
+    const result = {};
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+};
+export function keyBy(items, getKey) {
+    const out = {};
+    if (!Array.isArray(items) || typeof getKey !== "function") {
+        return out;
+    }
+    for (const item of items) {
+        const key = getKey(item);
+        if (typeof key !== "string" || key === "") {
+            continue;
+        }
+        out[key] = item;
+    }
+    return out;
+}
+/**
+ * 生成短 ID
+ * 由时间戳（base36）+ 随机字符组成，约 13 位
+ * - 前 8 位：时间戳（可排序）
+ * - 后 5 位：随机字符（防冲突）
+ * @returns 短 ID 字符串
+ * @example
+ * genShortId() // "lxyz1a2b3c4"
+ */
+export function genShortId() {
+    return Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "befly",
-    "version": "3.10.18",
-    "gitHead": "1fb1ccce3a69fb6a57f42a1e269c307ed159ae9a",
+    "version": "3.11.1",
+    "gitHead": "b566edda48fcd5e8e7c66d001fefedc68520036a",
     "private": false,
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "keywords": [
@@ -20,57 +20,49 @@
     "license": "Apache-2.0",
     "author": "chensuiyi <bimostyle@qq.com>",
     "files": [
-        ".gitignore",
-        "befly.config.ts",
-        "bunfig.toml",
         "LICENSE",
-        "main.ts",
-        "package.json",
-        "paths.ts",
         "README.md",
-        "tsconfig.json",
-        "checks/",
-        "configs/",
-        "docs/",
-        "hooks/",
-        "lib/",
-        "loader/",
-        "plugins/",
-        "router/",
-        "sync/",
-        "types/",
-        "utils/"
+        "dist/"
     ],
     "type": "module",
-    "main": "main.ts",
-    "types": "main.ts",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
     "exports": {
         ".": {
-            "types": "./main.ts",
-            "default": "./main.ts"
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
         },
-        "./lib/*": "./lib/*.ts",
-        "./types/*": "./types/*.d.ts",
-        "./utils/*": "./utils/*.ts"
+        "./all": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/befly.js",
+            "default": "./dist/befly.js"
+        },
+        "./min": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/befly.min.js",
+            "default": "./dist/befly.min.js"
+        },
+        "./types/*": {
+            "types": "./dist/types/*.d.ts"
+        }
     },
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org"
     },
     "scripts": {
+        "clean": "rimraf dist",
         "test": "bun test",
+        "bundle": "bun build ./index.ts --outfile ./dist/befly.js --target bun --format esm --packages bundle",
+        "bundle:min": "bun build ./index.ts --outdir ./dist --entry-naming befly.min.js --target bun --format esm --packages bundle --minify",
+        "build": "rimraf dist && bunx tsgo -p tsconfig.build.json && bun run bundle && bun run bundle:min",
+        "prepack": "bun run build && bun run ./scripts/ensureDist.ts",
         "typecheck": "bunx tsgo -p tsconfig.json --noEmit"
     },
     "dependencies": {
-        "befly-shared": "^1.3.10",
-        "chalk": "^5.6.2",
-        "es-toolkit": "^1.43.0",
         "fast-jwt": "^6.1.0",
         "fast-xml-parser": "^5.3.3",
-        "merge-anything": "^6.0.6",
-        "pathe": "^2.0.3",
-        "pino": "^10.1.0",
-        "pino-roll": "^4.0.0"
+        "pathe": "^2.0.3"
     },
     "engines": {
         "bun": ">=1.3.0"

package/bunfig.toml

@@ -1,3 +0,0 @@
-env = false
-[install]
-linker = "isolated"

package/checks/checkHook.ts

@@ -1,48 +0,0 @@
-import { isPlainObject } from "es-toolkit/compat";
-import { omit } from "es-toolkit/object";
-
-import { Logger } from "../lib/logger.ts";
-
-export async function checkHook(hooks: any[]): Promise<void> {
-    let hasError = false;
-
-    for (const hook of hooks) {
-        try {
-            if (!isPlainObject(hook)) {
-                Logger.warn(omit(hook, ["handler"]), "钩子导出必须是对象（export default { deps, handler }）");
-                hasError = true;
-                continue;
-            }
-
-            if (!Array.isArray((hook as any).deps)) {
-                Logger.warn(omit(hook, ["handler"]), "钩子的 deps 属性必须是字符串数组");
-                hasError = true;
-                continue;
-            }
-
-            if ((hook as any).deps.some((depItem: any) => typeof depItem !== "string")) {
-                Logger.warn(omit(hook, ["handler"]), "钩子的 deps 属性必须是字符串数组");
-                hasError = true;
-            }
-
-            if (typeof (hook as any).handler !== "function") {
-                Logger.warn(omit(hook, ["handler"]), "钩子的 handler 属性必须是函数");
-                hasError = true;
-                continue;
-            }
-        } catch (error: any) {
-            Logger.error(
-                {
-                    err: error,
-                    item: hook
-                },
-                "钩子解析失败"
-            );
-            hasError = true;
-        }
-    }
-
-    if (hasError) {
-        throw new Error("钩子结构检查失败");
-    }
-}