@done-coding/output-node 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 JustSoSu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,451 @@
+# @done-coding/output-node
+
+Node.js 环境下的同构输出工具包，基于 @done-coding/output-core 核心包构建，提供控制台输出和日志文件输出功能。
+
+## 特性
+
+- 🎨 **丰富的控制台输出** - 支持多种输出类型和颜色配置
+- 📝 **专业的日志文件输出** - 基于 pino 的高性能日志记录
+- 🔄 **混合类型接口** - 支持函数调用和属性链式调用两种方式
+- 🛡️ **临终落盘保护** - 使用 signal-exit 库实现非侵入式进程退出监听
+- 🚨 **信号监听** - 与 NestJS 等现代框架完美兼容
+- ⚡ **高性能** - 异步日志写入，预计算枚举映射
+- 🔧 **完整的错误处理** - 输入验证、配置验证、文件权限检查
+- 📦 **TypeScript 支持** - 完整的类型定义和类型推导
+- 🎯 **输出模式切换** - 支持控制台和日志文件之间的智能切换
+- 📋 **TABLE 类型特殊处理** - 智能表格数据展示和 JSON 序列化
+- 🔧 **常量集中管理** - 所有配置参数的默认值统一管理
+
+## 安装
+
+```bash
+npm install @done-coding/output-node
+# 或
+yarn add @done-coding/output-node
+# 或
+pnpm add @done-coding/output-node
+```
+
+## 快速开始
+
+### 控制台输出
+
+```typescript
+import {
+  createOutputConsole,
+  OutputConsoleTypeEnum,
+} from "@done-coding/output-node";
+
+// 创建控制台输出实例
+const outputConsole = createOutputConsole({
+  enableColor: true, // 启用颜色输出
+  silent: false, // 非静默模式
+});
+
+// 函数调用方式
+outputConsole(OutputConsoleTypeEnum.INFO, "这是一条信息");
+outputConsole(OutputConsoleTypeEnum.SUCCESS, "操作成功！");
+outputConsole(OutputConsoleTypeEnum.ERROR, "发生错误");
+
+// 属性链式调用方式（推荐）
+outputConsole.info("这是一条信息");
+outputConsole.success("操作成功！");
+outputConsole.error("发生错误");
+outputConsole.warn("这是一个警告");
+outputConsole.debug("调试信息");
+outputConsole.stage("当前步骤");
+outputConsole.skip("跳过此步骤");
+
+// TABLE 类型特殊处理
+outputConsole.table({
+  name: "张三",
+  age: 25,
+  city: "北京",
+});
+```
+
+### 日志文件输出
+
+```typescript
+import {
+  createOutputLogFile,
+  OutputLogFileTypeEnum,
+} from "@done-coding/output-node";
+
+// 创建日志文件输出实例
+const logger = createOutputLogFile({
+  logFilePath: "app.log", // 可选，默认自动生成
+  prettyPrint: false, // 是否美化输出
+  silent: false, // 非静默模式
+  sync: false, // 异步写入（推荐）
+  bufferSize: 4096, // 缓冲区大小
+});
+
+// 函数调用方式
+logger(OutputLogFileTypeEnum.INFO, "应用启动");
+logger(OutputLogFileTypeEnum.ERROR, "数据库连接失败");
+
+// 属性链式调用方式（推荐）
+logger.info("应用启动");
+logger.warn("内存使用率较高");
+logger.error("数据库连接失败");
+logger.debug("调试信息");
+logger.trace("详细跟踪信息");
+logger.fatal("致命错误，应用即将退出");
+```
+
+### 输出模式切换
+
+```typescript
+import { outputLogFile } from "@done-coding/output-node";
+
+// 支持输出到控制台
+const logger1 = outputLogFile({
+  outputToConsole: true, // 输出到控制台
+  prettyPrint: true, // 美化输出
+});
+
+// 支持输出到文件
+const logger2 = outputLogFile({
+  outputToConsole: false, // 输出到文件
+  logFilePath: "app.log",
+  sync: true, // 同步写入
+});
+```
+
+### 切换和同步逻辑
+
+```typescript
+import {
+  createOutputConsole,
+  createOutputLogFile,
+  OutputConsoleTypeEnum,
+} from "@done-coding/output-node";
+
+// 创建日志文件输出实例
+const fileLogger = createOutputLogFile({ logFilePath: "error.log" });
+
+// 创建带有切换和同步逻辑的控制台输出
+const outputConsole = createOutputConsole({
+  enableColor: true,
+  // 错误级别切换到日志文件（不在控制台显示）
+  isSwitchLogFile: (type) => type === OutputConsoleTypeEnum.ERROR,
+  // 警告级别同步到日志文件（控制台和文件都显示）
+  isSyncToLogFile: (type) => type === OutputConsoleTypeEnum.WARN,
+  // 指定日志文件输出函数
+  outputFileFn: fileLogger,
+});
+
+outputConsole.info("普通信息"); // 只在控制台显示
+outputConsole.warn("警告信息"); // 控制台和文件都显示
+outputConsole.error("错误信息"); // 只在文件中记录
+```
+
+## API 文档
+
+### createOutputConsole(options?)
+
+创建控制台输出实例。
+
+#### 参数
+
+- `options` (可选) - 配置选项
+  - `silent?: boolean` - 是否静默模式，默认 `false`
+  - `enableColor?: boolean` - 是否启用颜色输出，默认 `true`
+  - `colorMap?: Record<OutputConsoleTypeEnum, string>` - 自定义颜色映射
+  - `isSwitchLogFile?: (type: OutputConsoleTypeEnum) => boolean` - 切换到日志文件的条件函数
+  - `isSyncToLogFile?: (type: OutputConsoleTypeEnum) => boolean` - 同步到日志文件的条件函数
+  - `outputFileFn?: OutputLogFile` - 日志文件输出函数
+
+#### 返回值
+
+返回 `OutputConsole` 混合类型实例，支持：
+
+- 函数调用：`output(type, ...messages)`
+- 属性调用：`output.info(...messages)`、`output.error(...messages)` 等
+
+### createOutputLogFile(options?)
+
+创建日志文件输出实例。
+
+#### 参数
+
+- `options` (可选) - 配置选项
+  - `silent?: boolean` - 是否静默模式，默认 `false`
+  - `logFilePath?: string` - 日志文件路径，默认自动生成
+  - `prettyPrint?: boolean` - 是否启用美化输出，默认 `false`
+  - `sync?: boolean` - 是否同步写入，默认 `false`
+  - `bufferSize?: number` - 缓冲区大小，默认 `4096`
+
+#### 返回值
+
+返回 `OutputLogFile` 混合类型实例，支持：
+
+- 函数调用：`logger(type, ...messages)`
+- 属性调用：`logger.info(...messages)`、`logger.error(...messages)` 等
+
+### outputLogFile(options?)
+
+创建支持输出模式切换的日志实例。
+
+#### 参数
+
+- `options` (可选) - 配置选项
+  - `outputToConsole?: boolean` - 是否输出到控制台，默认 `false`
+  - `prettyPrint?: boolean` - 是否美化输出，默认 `false`
+  - `logFilePath?: string` - 日志文件路径（当 `outputToConsole` 为 `false` 时）
+  - `sync?: boolean` - 是否同步写入，默认 `false`
+  - `bufferSize?: number` - 缓冲区大小，默认 `4096`
+
+### 输出类型枚举
+
+#### OutputConsoleTypeEnum
+
+控制台输出类型枚举：
+
+```typescript
+enum OutputConsoleTypeEnum {
+  DEBUG = 31, // 调试信息
+  SKIP = 32, // 跳过
+  INFO = 33, // 提示信息
+  TABLE = 34, // 表格
+  STAGE = 35, // 步骤
+  SUCCESS = 36, // 成功
+  WARN = 37, // 警告
+  ERROR = 38, // 错误
+}
+```
+
+#### OutputLogFileTypeEnum
+
+日志文件输出类型枚举（对齐 Pino 标准）：
+
+```typescript
+enum OutputLogFileTypeEnum {
+  TRACE = 10, // 跟踪级别
+  DEBUG = 20, // 调试级别
+  INFO = 30, // 信息级别
+  WARN = 40, // 警告级别
+  ERROR = 50, // 错误级别
+  FATAL = 60, // 致命错误级别
+}
+```
+
+## 高级功能
+
+### 临终落盘保护
+
+Node.js 包使用 signal-exit 库实现非侵入式临终落盘保护机制，确保进程退出时日志数据不丢失：
+
+```typescript
+import { createOutputLogFile } from "@done-coding/output-node";
+
+// 创建日志实例会自动注册 signal-exit 监听器
+const logger = createOutputLogFile({ logFilePath: "app.log" });
+
+logger.info("应用启动");
+// 当收到 SIGINT 或 SIGTERM 信号时，会自动刷新日志缓冲区
+// 与 NestJS 等现代框架的关闭钩子完美兼容
+```
+
+### 错误处理
+
+包含完整的错误处理机制：
+
+```typescript
+import {
+  createOutputConsole,
+  DriverInitializationError,
+} from "@done-coding/output-node";
+
+try {
+  const outputConsole = createOutputConsole({
+    bufferSize: -1, // 无效配置会抛出错误
+  });
+} catch (error) {
+  if (error instanceof DriverInitializationError) {
+    console.error("驱动初始化失败:", error.message);
+  }
+}
+```
+
+### 自定义颜色配置
+
+```typescript
+import {
+  createOutputConsole,
+  OutputConsoleTypeEnum,
+} from "@done-coding/output-node";
+
+const outputConsole = createOutputConsole({
+  enableColor: true,
+  colorMap: {
+    [OutputConsoleTypeEnum.INFO]: "blue",
+    [OutputConsoleTypeEnum.SUCCESS]: "greenBright",
+    [OutputConsoleTypeEnum.ERROR]: "redBright",
+    [OutputConsoleTypeEnum.WARN]: "yellow",
+  },
+});
+```
+
+### 缓冲区配置
+
+```typescript
+import { createOutputLogFile } from "@done-coding/output-node";
+
+// 自定义缓冲区大小
+const logger = createOutputLogFile({
+  bufferSize: 8192, // 8KB 缓冲区
+  sync: false, // 异步写入
+});
+
+// 同步写入模式（性能较低但数据安全性更高）
+const syncLogger = createOutputLogFile({
+  sync: true, // 同步写入
+  bufferSize: 1024, // 较小的缓冲区
+});
+```
+
+### 工具函数
+
+```typescript
+import {
+  generateDefaultNodeLogFileName,
+  getConsoleTypeName,
+  getLogFileTypeName,
+} from "@done-coding/output-node";
+
+// 生成默认日志文件名
+const fileName = generateDefaultNodeLogFileName();
+console.log(fileName); // 20240131_235959-12345.log
+
+// 获取类型名称
+console.log(getConsoleTypeName(OutputConsoleTypeEnum.INFO)); // "INFO"
+console.log(getLogFileTypeName(OutputLogFileTypeEnum.ERROR)); // "ERROR"
+```
+
+## 最佳实践
+
+### 1. 使用属性调用方式
+
+```typescript
+// ✅ 推荐：属性调用方式
+outputConsole.info("用户登录成功");
+outputConsole.error("数据库连接失败");
+
+// ❌ 不推荐：函数调用方式（虽然也支持）
+outputConsole(OutputConsoleTypeEnum.INFO, "用户登录成功");
+```
+
+### 2. 合理配置日志级别
+
+```typescript
+// 开发环境
+const devLogger = createOutputLogFile({
+  prettyPrint: true, // 美化输出便于调试
+  logFilePath: "dev.log",
+  outputToConsole: true, // 同时输出到控制台
+});
+
+// 生产环境
+const prodLogger = createOutputLogFile({
+  prettyPrint: false, // 标准 JSON 格式
+  logFilePath: `/var/log/app-${process.pid}.log`,
+  sync: false, // 异步写入提高性能
+  bufferSize: 8192, // 较大缓冲区
+});
+```
+
+### 3. 错误处理和降级
+
+```typescript
+import { createOutputLogFile } from "@done-coding/output-node";
+
+try {
+  const logger = createOutputLogFile({
+    logFilePath: "/protected/app.log",
+    bufferSize: 4096,
+  });
+} catch (error) {
+  // 降级到控制台输出
+  console.warn("日志文件创建失败，降级到控制台输出");
+  const fallbackLogger = createOutputLogFile({
+    outputToConsole: true,
+    prettyPrint: true,
+  });
+}
+```
+
+### 4. 性能优化
+
+```typescript
+// 在高频输出场景下使用静默模式进行性能测试
+const outputConsole = createOutputConsole({
+  silent: process.env.NODE_ENV === "test",
+});
+
+// 批量输出时考虑使用异步日志
+const logger = createOutputLogFile({
+  logFilePath: "batch.log",
+  prettyPrint: false, // 禁用美化以提高性能
+  sync: false, // 异步写入
+  bufferSize: 16384, // 更大的缓冲区
+});
+```
+
+### 5. TABLE 类型最佳实践
+
+```typescript
+// ✅ 推荐：结构化数据
+outputConsole.table([
+  { name: "张三", age: 25, city: "北京" },
+  { name: "李四", age: 30, city: "上海" },
+]);
+
+// ✅ 推荐：对象数据
+outputConsole.table({
+  total: 100,
+  success: 95,
+  failed: 5,
+});
+
+// ❌ 避免：非结构化数据
+outputConsole.table("这不是表格数据");
+```
+
+## 依赖
+
+- `@done-coding/output-core` - 核心包
+- `chalk` - 控制台颜色输出
+- `pino` - 高性能日志库
+- `pino-pretty` - 日志美化输出
+- `signal-exit` - 非侵入式进程退出监听
+
+## 测试覆盖率
+
+- **语句覆盖率**: 99.51%
+- **分支覆盖率**: 98.13%
+- **函数覆盖率**: 97.29%
+- **行覆盖率**: 99.51%
+- **测试数量**: 182 个测试，全部通过
+
+## 许可证
+
+MIT
+
+## 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+## 更新日志
+
+### v0.0.0
+
+- 初始版本发布
+- 支持控制台输出和日志文件输出
+- 实现基于 signal-exit 的临终落盘保护机制
+- 完整的错误处理和类型推导支持
+- 输出模式切换功能
+- TABLE 类型特殊处理
+- 常量集中管理
+- 缓冲区大小配置和验证

package/es/index.mjs

@@ -0,0 +1,413 @@
+#!/usr/bin/env node
+import { OutputConsoleTypeEnum as c, OutputLogFileTypeEnum as E, handleTableTypeConsole as Z, generateTimestamp as x, createOutputConsole as z, createOutputLogFile as G } from "@done-coding/output-core";
+import { OutputConsoleTypeEnum as pe, OutputLogFileTypeEnum as Ee, OutputTargetModeEnum as ye } from "@done-coding/output-core";
+import p from "chalk";
+import h from "pino";
+import F from "node:fs";
+import { onExit as j } from "signal-exit";
+class N extends Error {
+  constructor(t, r) {
+    super(`无效的输出类型: ${t}。有效的类型包括: ${r.join(", ")}`), this.name = "InvalidOutputTypeError";
+  }
+}
+class S extends Error {
+  constructor(t) {
+    super(`配置错误: ${t}`), this.name = "InvalidConfigurationError";
+  }
+}
+class le extends Error {
+  constructor(t, r) {
+    super(`文件权限不足: 无法${r}文件 "${t}"`), this.name = "FilePermissionError";
+  }
+}
+class _ extends Error {
+  constructor(t, r) {
+    super(`驱动初始化失败: ${t}${r ? ` - ${r.message}` : ""}`), this.name = "DriverInitializationError", r && (this.cause = r);
+  }
+}
+function C(e) {
+  const t = Object.values(c).filter(
+    (r) => typeof r == "number"
+  );
+  if (typeof e != "number" || !t.includes(e)) {
+    const r = Object.keys(c).filter(
+      (i) => isNaN(Number(i))
+    );
+    throw new N(e, r);
+  }
+}
+function w(e) {
+  const t = Object.values(E).filter(
+    (r) => typeof r == "number"
+  );
+  if (typeof e != "number" || !t.includes(e)) {
+    const r = Object.keys(E).filter(
+      (i) => isNaN(Number(i))
+    );
+    throw new N(e, r);
+  }
+}
+function m(e, t) {
+  for (const r of t)
+    if (!(r in e) || e[r] === void 0)
+      throw new S(`缺少必需字段: ${r}`);
+}
+function b(e) {
+  if (typeof e != "string" || e.trim() === "")
+    throw new S("文件路径必须是非空字符串");
+  if (/[<>:"|?*]/.test(e))
+    throw new S(`文件路径包含非法字符: ${e}`);
+}
+function a(e, t) {
+  try {
+    return e();
+  } catch (r) {
+    return t ? t(r) : void 0;
+  }
+}
+const I = {
+  /** 默认静默模式：关闭 */
+  silent: !1,
+  /** 默认启用颜色输出：是 */
+  enableColor: !0
+}, B = {
+  [c.DEBUG]: "gray",
+  [c.SKIP]: "dim",
+  [c.INFO]: "white",
+  [c.TABLE]: "cyan",
+  [c.STAGE]: "blue",
+  [c.SUCCESS]: "greenBright",
+  [c.WARN]: "yellow",
+  [c.ERROR]: "redBright"
+}, k = {
+  /** 默认颜色格式化失败时的回退颜色 */
+  fallbackColor: "white"
+}, g = {
+  /** 默认静默模式：关闭 */
+  silent: !1,
+  /** 默认同步写入：关闭（异步写入） */
+  sync: !1,
+  /** 默认缓冲区大小：4KB */
+  bufferSize: 4096
+}, v = {
+  /** 默认日志级别：trace */
+  level: "trace",
+  /** 默认时间格式：yyyy-mm-dd HH:MM:ss */
+  timeFormat: "yyyy-mm-dd HH:MM:ss",
+  /** 默认忽略字段：pid,hostname */
+  ignoreFields: "pid,hostname",
+  /** 默认消息格式：{msg} */
+  messageFormat: "{msg}",
+  /** 默认文件输出颜色：关闭 */
+  colorize: !1
+}, d = {
+  /** 最小缓冲区大小：1KB */
+  MIN_SIZE: 1024,
+  /** 默认缓冲区大小：4KB */
+  DEFAULT_SIZE: 4096,
+  /** 推荐缓冲区大小：8KB */
+  RECOMMENDED_SIZE: 8192,
+  /** 最大缓冲区大小：64KB */
+  MAX_SIZE: 65536
+}, L = {
+  /** 默认静默模式：关闭 */
+  silent: !1,
+  /** 默认启用颜色输出：是 */
+  enableColor: !0
+}, O = {
+  /** 默认静默模式：关闭 */
+  silent: !1,
+  /** 默认同步写入：关闭（异步写入） */
+  sync: !1,
+  /** 默认缓冲区大小：4KB */
+  bufferSize: 4096
+}, se = {
+  /** 默认静默模式：是（避免控制台输出） */
+  silentMode: !0,
+  /** 默认最大重试次数：3次 */
+  maxRetries: 3,
+  /** 默认重试间隔：100ms */
+  retryInterval: 100
+}, ue = {
+  /** 默认错误处理模式：静默处理 */
+  silentMode: !0,
+  /** 默认错误重试次数：2次 */
+  maxRetries: 2,
+  /** 默认错误重试延迟：50ms */
+  retryDelay: 50
+};
+function X(e) {
+  const {
+    silent: t = I.silent,
+    enableColor: r = I.enableColor,
+    colorMap: i
+  } = e, o = { ...B, ...i };
+  try {
+    if (m(e, []), i) {
+      for (const [s, l] of Object.entries(i))
+        if (C(Number(s)), typeof l != "string")
+          throw new Error(`颜色值必须是字符串: ${l}`);
+    }
+  } catch (s) {
+    throw new _("控制台驱动", s);
+  }
+  return (s, ...l) => {
+    if (a(() => C(s)), t)
+      return;
+    if (s === c.TABLE) {
+      a(() => Z(...l));
+      return;
+    }
+    const f = o[s] || k.fallbackColor, n = l.map((u) => typeof u == "string" && r ? a(
+      () => f in p && typeof p[f] == "function" ? p[f](u) : p.white(u),
+      () => u
+    ) : u);
+    a(() => console.log(...n));
+  };
+}
+const R = /* @__PURE__ */ new Set();
+let T = !1;
+function H() {
+  for (const { logger: e, destination: t } of R)
+    try {
+      e.info("进程退出，日志刷新完成"), V(t);
+    } catch {
+    }
+  q();
+}
+function V(e) {
+  if (M(e))
+    try {
+      e.flushSync(), W(e);
+    } catch (t) {
+      if (t instanceof Error && t.message.includes("sonic boom is not ready yet"))
+        return;
+    }
+}
+function W(e) {
+  const t = e.fd;
+  if (typeof t == "number" && t > 0)
+    try {
+      F.fsyncSync(t);
+    } catch {
+    }
+}
+function M(e) {
+  if (!e || !("flushSync" in e) || typeof e.flushSync != "function")
+    return !1;
+  const t = e;
+  if (t.constructor && t.constructor.name === "SonicBoom")
+    return K(t);
+  const r = t.fd;
+  return typeof r == "number" ? r > 0 || r === 1 || r === 2 : !(t.destroyed || t.closed || t.writable === !1);
+}
+function K(e) {
+  return !(!e.fd || e.fd === null || e.fd === void 0 || e.fd < 0 || e._writing === !0 || e.destroyed === !0 || e._reopening === !0 || e._ending === !0 || e._asyncDrainScheduled === !0 || e._buf && e._buf.length > 0 && e._writing);
+}
+function q() {
+  try {
+    process.stdout.fd !== void 0 && typeof process.stdout.fd == "number" && F.fsyncSync(process.stdout.fd);
+  } catch {
+  }
+  try {
+    process.stderr.fd !== void 0 && typeof process.stderr.fd == "number" && F.fsyncSync(process.stderr.fd);
+  } catch {
+  }
+}
+function J() {
+  T || (j(() => {
+    H();
+  }), T = !0);
+}
+function P(e, t) {
+  R.add({ logger: e, destination: t }), J();
+}
+function Q(e) {
+  const {
+    silent: t = g.silent,
+    logFilePath: r,
+    sync: i = g.sync,
+    bufferSize: o = g.bufferSize
+  } = e;
+  try {
+    if (m(e, []), r !== void 0 && b(r), o <= 0)
+      throw new Error(`缓冲区大小必须大于0: ${o}`);
+    if (o < d.MIN_SIZE || o > d.MAX_SIZE)
+      throw new Error(
+        `缓冲区大小必须在 ${d.MIN_SIZE} - ${d.MAX_SIZE} 字节范围内: ${o}`
+      );
+  } catch (n) {
+    throw new _("日志文件驱动", n);
+  }
+  const s = r || D();
+  let l = null, f = null;
+  if (!t) {
+    const n = $({
+      logFilePath: s,
+      sync: i,
+      bufferSize: o
+    });
+    l = n.logger, f = n.destination, l && f && P(l, f);
+  }
+  return (n, ...u) => {
+    if (a(() => w(n)), t || !l)
+      return;
+    const y = u.length === 1 ? u[0] : u.join(" ");
+    a(() => {
+      const U = (E[n] || "INFO").toLowerCase();
+      l[U](y);
+    });
+  };
+}
+function Y(e) {
+  const {
+    silent: t = g.silent,
+    logFilePath: r,
+    sync: i = g.sync,
+    bufferSize: o = g.bufferSize
+  } = e;
+  try {
+    if (m(e, []), r !== void 0 && b(r), o <= 0)
+      throw new Error(`缓冲区大小必须大于0: ${o}`);
+    if (o < d.MIN_SIZE || o > d.MAX_SIZE)
+      throw new Error(
+        `缓冲区大小必须在 ${d.MIN_SIZE} - ${d.MAX_SIZE} 字节范围内: ${o}`
+      );
+  } catch (n) {
+    throw new _("日志文件驱动", n);
+  }
+  const s = r || D();
+  let l = null, f = null;
+  if (!t) {
+    const n = $({
+      logFilePath: s,
+      sync: i,
+      bufferSize: o
+    });
+    l = n.logger, f = n.destination, l && f && P(l, f);
+  }
+  return (n, ...u) => {
+    if (t || !l)
+      return;
+    const y = u.length === 1 ? u[0] : u.join(" ");
+    a(() => {
+      l.info(y);
+    });
+  };
+}
+function A() {
+  let e = null;
+  return e = ee().logger, (r, ...i) => {
+    if (a(() => w(r)), !e)
+      return;
+    const o = i.length === 1 ? i[0] : i.join(" ");
+    a(() => {
+      const s = (E[r] || "INFO").toLowerCase();
+      e[s](o);
+    });
+  };
+}
+function D() {
+  const e = x(), t = process.pid;
+  return `${e}-${t}.log`;
+}
+function $(e) {
+  const { logFilePath: t, sync: r, bufferSize: i } = e, o = h.destination({
+    dest: t,
+    sync: r,
+    // 使用用户配置的同步/异步模式
+    bufferSize: i,
+    // 使用用户配置的缓冲区大小
+    autoEnd: !1
+    // 始终禁用自动结束，使用我们的防御性退出处理
+  }), s = o.flushSync;
+  return o.flushSync = function() {
+    if (M(o))
+      return s.call(this);
+  }, { logger: h(
+    {
+      level: v.level
+    },
+    o
+  ), destination: o };
+}
+function ee() {
+  return { logger: h({
+    level: v.level
+  }), destination: process.stdout };
+}
+function fe(e = {}) {
+  const {
+    silent: t = L.silent,
+    enableColor: r = L.enableColor,
+    colorMap: i,
+    isSwitchLogFile: o,
+    isSyncToLogFile: s,
+    outputFileFn: l
+  } = e, f = X({
+    silent: t,
+    enableColor: r,
+    colorMap: i
+  });
+  let n = l;
+  return !n && (o || s) && (n = Y({
+    silent: t
+  })), z(f, {
+    silent: t,
+    colorMap: i,
+    enableColor: r,
+    isSwitchLogFile: o,
+    isSyncToLogFile: s,
+    outputFileFn: n
+  });
+}
+function ce(e) {
+  const {
+    silent: t = O.silent,
+    logFilePath: r,
+    // 现在是必传的绝对路径参数
+    sync: i = O.sync,
+    // 默认异步写入
+    bufferSize: o = O.bufferSize,
+    // 默认缓冲区大小 4KB
+    isSwitchConsole: s,
+    outputConsoleFn: l
+  } = e, f = Q({
+    silent: t,
+    logFilePath: r,
+    sync: i,
+    bufferSize: o
+  });
+  let n = l;
+  return !n && s && (n = A()), G(f, {
+    silent: t,
+    logFilePath: r,
+    isSwitchConsole: s,
+    outputConsoleFn: n
+  });
+}
+function ae() {
+  return A();
+}
+export {
+  d as BUFFER_SIZE_CONFIG,
+  B as DEFAULT_CONSOLE_COLOR_MAP,
+  I as DEFAULT_CONSOLE_OUTPUT_IMPL_OPTIONS,
+  ue as DEFAULT_ERROR_HANDLING_CONFIG,
+  g as DEFAULT_LOG_FILE_OUTPUT_IMPL_OPTIONS,
+  L as DEFAULT_NODE_CREATE_OUTPUT_CONSOLE_OPTIONS,
+  O as DEFAULT_NODE_CREATE_OUTPUT_LOG_FILE_OPTIONS,
+  v as DEFAULT_PINO_CONFIG,
+  se as DEFAULT_PROCESS_HANDLER_CONFIG,
+  _ as DriverInitializationError,
+  le as FilePermissionError,
+  S as InvalidConfigurationError,
+  N as InvalidOutputTypeError,
+  pe as OutputConsoleTypeEnum,
+  Ee as OutputLogFileTypeEnum,
+  ye as OutputTargetModeEnum,
+  fe as createOutputConsole,
+  ce as createOutputLogFile,
+  ae as createPinoConsoleOutput,
+  A as createPinoConsoleOutputImpl
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@done-coding/output-node",
+  "version": "0.1.0-alpha.0",
+  "description": "node相关输出",
+  "private": false,
+  "module": "es/index.mjs",
+  "types": "types/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./es/index.mjs",
+      "types": "./types/index.d.ts"
+    }
+  },
+  "files": [
+    "es",
+    "lib",
+    "types"
+  ],
+  "scripts": {
+    "predev": "dc-inject",
+    "dev": "vite build -w -m hotBuild",
+    "prebuild": "dc-inject",
+    "build": "vite build",
+    "prepack": "pnpm build",
+    "test": "vitest",
+    "coverage": "vitest run --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/done-coding/done-coding-output.git",
+    "directory": "packages/node"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "author": "JustSoSu",
+  "license": "MIT",
+  "sideEffects": false,
+  "devDependencies": {
+    "@done-coding/cli-inject": "^0.5.17",
+    "@types/node": "^18.0.0",
+    "@types/signal-exit": "^4.0.0",
+    "@vitest/coverage-v8": "^1.6.1",
+    "typescript": "^5.8.3",
+    "vite": "^5.0.10",
+    "vite-plugin-dts": "^3.7.0",
+    "vitest": "^1.6.1"
+  },
+  "peerDependencies": {
+    "chalk": "^5.3.0",
+    "pino": "^8.17.2",
+    "signal-exit": "^4.1.0"
+  },
+  "dependencies": {
+    "@done-coding/output-core": "0.1.0-alpha.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "gitHead": "4365181831a85aa7dd657faac9af146ad0a5739d"
+}

package/types/index.d.ts

@@ -0,0 +1,226 @@
+import { CreateOutputConsoleOptions as CreateOutputConsoleOptions_2 } from '@done-coding/output-core';
+import { CreateOutputLogFileOptions as CreateOutputLogFileOptions_2 } from '@done-coding/output-core';
+import { OutputConsole } from '@done-coding/output-core';
+import { OutputConsoleRaw } from '@done-coding/output-core';
+import { OutputConsoleTypeEnum } from '@done-coding/output-core';
+import { OutputLogFile } from '@done-coding/output-core';
+import { OutputLogFileRaw } from '@done-coding/output-core';
+import { OutputLogFileTypeEnum } from '@done-coding/output-core';
+import { OutputTargetModeEnum } from '@done-coding/output-core';
+
+/**
+ * 缓冲区大小配置常量
+ */
+export declare const BUFFER_SIZE_CONFIG: {
+    /** 最小缓冲区大小：1KB */
+    readonly MIN_SIZE: 1024;
+    /** 默认缓冲区大小：4KB */
+    readonly DEFAULT_SIZE: 4096;
+    /** 推荐缓冲区大小：8KB */
+    readonly RECOMMENDED_SIZE: 8192;
+    /** 最大缓冲区大小：64KB */
+    readonly MAX_SIZE: 65536;
+};
+
+/**
+ * 创建控制台输出实例 (Node.js 适配版本)
+ * 自动提供 console.log + chalk 的 outputImpl 实现
+ *
+ * @param options 配置选项
+ * @returns 控制台输出实例
+ */
+export declare function createOutputConsole(options?: CreateOutputConsoleOptions): OutputConsole;
+
+/**
+ * Node.js 环境下的控制台输出选项
+ * 继承核心包选项，但不需要手动传入 outputImpl，并且 silent 是可选的
+ */
+export declare interface CreateOutputConsoleOptions extends Omit<CreateOutputConsoleOptions_2, "outputFileFn"> {
+    /** 日志文件输出函数 */
+    outputFileFn?: OutputConsoleRaw;
+}
+
+/**
+ * 创建日志文件输出实例 (Node.js 适配版本)
+ * 自动提供 pino 的 outputImpl 实现
+ *
+ * @param options 配置选项 (logFilePath 为必传绝对路径)
+ * @returns 日志文件输出实例
+ */
+export declare function createOutputLogFile(options: CreateOutputLogFileOptions): OutputLogFile;
+
+/**
+ * Node.js 环境下的日志文件输出选项
+ * 继承核心包选项，但不需要手动传入 outputImpl，并且 silent 是可选的
+ * logFilePath 为必传参数，必须提供绝对路径
+ */
+export declare interface CreateOutputLogFileOptions extends Omit<CreateOutputLogFileOptions_2, "logFilePath" | "outputConsoleFn">, Pick<LogFileOutputImplOptions, "sync" | "bufferSize"> {
+    /** 日志文件绝对路径 (必传) */
+    logFilePath: string;
+    /** 输出到控制台对应的方法 */
+    outputConsoleFn?: OutputLogFileRaw;
+}
+
+/**
+ * 创建基于 pino 的控制台输出实现
+ * 用于 outputLogFile 切换到控制台输出时使用
+ *
+ * @param options 配置选项
+ * @returns 控制台输出函数（保持日志级别类型）
+ */
+export declare function createPinoConsoleOutput(): OutputLogFileRaw;
+
+/**
+ * 创建控制台输出实现（基于 pino）
+ * @returns 日志文件输出函数（输出到控制台）
+ */
+export declare function createPinoConsoleOutputImpl(): OutputLogFileRaw;
+
+/**
+ * 默认控制台输出颜色映射
+ * 根据需求 4.2 定义的颜色方案
+ */
+export declare const DEFAULT_CONSOLE_COLOR_MAP: Record<OutputConsoleTypeEnum, string>;
+
+/**
+ * 控制台输出实现默认配置
+ */
+export declare const DEFAULT_CONSOLE_OUTPUT_IMPL_OPTIONS: {
+    /** 默认静默模式：关闭 */
+    readonly silent: false;
+    /** 默认启用颜色输出：是 */
+    readonly enableColor: true;
+};
+
+/**
+ * 错误处理默认配置
+ */
+export declare const DEFAULT_ERROR_HANDLING_CONFIG: {
+    /** 默认错误处理模式：静默处理 */
+    readonly silentMode: true;
+    /** 默认错误重试次数：2次 */
+    readonly maxRetries: 2;
+    /** 默认错误重试延迟：50ms */
+    readonly retryDelay: 50;
+};
+
+/**
+ * 日志文件输出实现默认配置
+ */
+export declare const DEFAULT_LOG_FILE_OUTPUT_IMPL_OPTIONS: {
+    /** 默认静默模式：关闭 */
+    readonly silent: false;
+    /** 默认同步写入：关闭（异步写入） */
+    readonly sync: false;
+    /** 默认缓冲区大小：4KB */
+    readonly bufferSize: 4096;
+};
+
+/**
+ * Node.js 控制台输出创建函数默认配置
+ */
+export declare const DEFAULT_NODE_CREATE_OUTPUT_CONSOLE_OPTIONS: {
+    /** 默认静默模式：关闭 */
+    readonly silent: false;
+    /** 默认启用颜色输出：是 */
+    readonly enableColor: true;
+};
+
+/**
+ * Node.js 日志文件输出创建函数默认配置
+ */
+export declare const DEFAULT_NODE_CREATE_OUTPUT_LOG_FILE_OPTIONS: {
+    /** 默认静默模式：关闭 */
+    readonly silent: false;
+    /** 默认同步写入：关闭（异步写入） */
+    readonly sync: false;
+    /** 默认缓冲区大小：4KB */
+    readonly bufferSize: 4096;
+};
+
+/**
+ * Pino 日志配置默认值
+ */
+export declare const DEFAULT_PINO_CONFIG: {
+    /** 默认日志级别：trace */
+    readonly level: "trace";
+    /** 默认时间格式：yyyy-mm-dd HH:MM:ss */
+    readonly timeFormat: "yyyy-mm-dd HH:MM:ss";
+    /** 默认忽略字段：pid,hostname */
+    readonly ignoreFields: "pid,hostname";
+    /** 默认消息格式：{msg} */
+    readonly messageFormat: "{msg}";
+    /** 默认文件输出颜色：关闭 */
+    readonly colorize: false;
+};
+
+/**
+ * 进程退出处理默认配置
+ */
+export declare const DEFAULT_PROCESS_HANDLER_CONFIG: {
+    /** 默认静默模式：是（避免控制台输出） */
+    readonly silentMode: true;
+    /** 默认最大重试次数：3次 */
+    readonly maxRetries: 3;
+    /** 默认重试间隔：100ms */
+    readonly retryInterval: 100;
+};
+
+/**
+ * 驱动初始化错误
+ */
+export declare class DriverInitializationError extends Error {
+    cause?: Error;
+    constructor(driverName: string, cause?: Error);
+}
+
+/**
+ * 文件权限错误
+ */
+export declare class FilePermissionError extends Error {
+    constructor(filePath: string, operation: string);
+}
+
+/**
+ * 无效配置错误
+ */
+export declare class InvalidConfigurationError extends Error {
+    constructor(message: string);
+}
+
+/**
+ * 无效输出类型错误
+ */
+export declare class InvalidOutputTypeError extends Error {
+    constructor(type: unknown, validTypes: string[]);
+}
+
+/**
+ * 日志文件输出实现配置选项
+ */
+declare interface LogFileOutputImplOptions {
+    /** 是否静默模式 */
+    silent?: boolean;
+    /** 日志文件路径 (可选，相对路径) */
+    logFilePath?: string;
+    /** 是否同步写入 (默认: false，异步写入) */
+    sync?: boolean;
+    /** 缓冲区大小 (字节，默认: 4096) */
+    bufferSize?: number;
+}
+
+export { OutputConsole }
+
+export { OutputConsoleRaw }
+
+export { OutputConsoleTypeEnum }
+
+export { OutputLogFile }
+
+export { OutputLogFileRaw }
+
+export { OutputLogFileTypeEnum }
+
+export { OutputTargetModeEnum }
+
+export { }