@done-coding/output-node 0.1.0 → 0.1.1

package/README.md

@@ -16,7 +16,8 @@ Node.js 环境下的同构输出工具包，基于 @done-coding/output-core 核
 - ⚡ **高性能** - 异步日志写入，可配置缓冲区大小
 - 🔧 **完整的错误处理** - 输入验证、配置验证、文件权限检查
 - 📦 **完整类型支持** - 100% TypeScript 类型定义和类型推导
-- 🎯 **输出模式切换** - 支持控制台和日志文件之间的智能切换
+- 🔇 **动态静默控制** - 支持运行时动态控制输出静默，基于类型的条件静默
+- 🎯 **智能切换同步** - 支持控制台和日志文件之间的智能切换和同步
 - 📋 **TABLE 类型特殊处理** - 智能表格数据展示和 JSON 序列化
 
 ## 快速开始
@@ -76,6 +77,22 @@ logger.error("发生错误");
 5. **框架兼容** - 与现代框架（NestJS、Express 等）完美兼容
 6. **极简 API** - 最少化的配置参数，易于使用
 
+### 内置实现
+
+#### 控制台输出驱动
+
+- **基础实现**: `console.log` + `chalk` 颜色支持
+- **颜色配置**: 支持自定义颜色映射和禁用颜色
+- **TABLE 类型**: 自动调用 `console.table` 进行表格展示
+- **错误处理**: 颜色格式化失败时自动降级到无颜色输出
+
+#### 日志文件输出驱动
+
+- **基础实现**: `pino` + `sonic-boom` 高性能日志写入
+- **缓冲机制**: 可配置缓冲区大小，支持同步/异步写入
+- **临终保护**: 使用 `signal-exit` 实现非侵入式进程退出监听
+- **内置控制台**: 自动提供 `outputConsoleFn`，基于 pino 输出到控制台
+
 ## API 文档
 
 ### createOutputConsole
@@ -94,12 +111,12 @@ function createOutputConsole(
 
 | 参数                    | 类型                                  | 默认值 | 说明                 |
 | ----------------------- | ------------------------------------- | ------ | -------------------- |
-| options.silent          | boolean                               | false  | 是否静默模式         |
+| options.isSilent        | (type) => boolean                     | -      | 动态静默控制函数     |
 | options.enableColor     | boolean                               | true   | 是否启用颜色输出     |
 | options.colorMap        | Record<OutputConsoleTypeEnum, string> | -      | 自定义颜色映射       |
 | options.isSwitchLogFile | (type) => boolean                     | -      | 切换到日志文件的条件 |
 | options.isSyncToLogFile | (type) => boolean                     | -      | 同步到日志文件的条件 |
-| options.outputFileFn    | OutputLogFile                         | -      | 日志文件输出函数     |
+| options.outputFileFn    | OutputConsoleRaw                      | -      | 日志文件输出函数     |
 
 **返回值：** OutputConsole 混合类型实例
 
@@ -108,7 +125,8 @@ function createOutputConsole(
 ```typescript
 const output = createOutputConsole({
   enableColor: true,
-  silent: false,
+  isSilent: (type) =>
+    type === OutputConsoleTypeEnum.DEBUG && !process.env.DEBUG,
 });
 
 output.info("信息");
@@ -133,11 +151,10 @@ function createOutputLogFile(
 | 参数                    | 类型              | 默认值 | 说明                 |
 | ----------------------- | ----------------- | ------ | -------------------- |
 | options.logFilePath     | string            | -      | 日志文件路径（必传） |
-| options.silent          | boolean           | false  | 是否静默模式         |
+| options.isSilent        | (type) => boolean | -      | 动态静默控制函数     |
 | options.sync            | boolean           | false  | 是否同步写入         |
 | options.bufferSize      | number            | 4096   | 缓冲区大小（字节）   |
 | options.isSwitchConsole | (type) => boolean | -      | 切换到控制台的条件   |
-| options.outputConsoleFn | OutputConsole     | -      | 控制台输出函数       |
 
 **返回值：** OutputLogFile 混合类型实例
 
@@ -182,6 +199,33 @@ logger.error("数据库连接失败");
 
 ## 进阶使用
 
+### 动态静默控制
+
+```typescript
+import {
+  createOutputConsole,
+  OutputConsoleTypeEnum,
+} from "@done-coding/output-node";
+
+const output = createOutputConsole({
+  // 动态控制静默：只在调试模式下显示 DEBUG 信息
+  isSilent: (type) => {
+    if (type === OutputConsoleTypeEnum.DEBUG) {
+      return !process.env.DEBUG;
+    }
+    // 生产环境下静默所有 SKIP 类型
+    if (type === OutputConsoleTypeEnum.SKIP) {
+      return process.env.NODE_ENV === "production";
+    }
+    return false;
+  },
+});
+
+output.debug("调试信息"); // 只在 DEBUG=true 时显示
+output.skip("跳过信息"); // 生产环境下不显示
+output.info("普通信息"); // 总是显示
+```
+
 ### 切换和同步逻辑
 
 ```typescript
@@ -201,7 +245,10 @@ const output = createOutputConsole({
   isSwitchLogFile: (type) => type === OutputConsoleTypeEnum.ERROR,
   // 警告级别同步到日志文件（控制台和文件都显示）
   isSyncToLogFile: (type) => type === OutputConsoleTypeEnum.WARN,
-  outputFileFn: fileLogger,
+  outputFileFn: (type, ...messages) => {
+    // 将控制台类型映射到日志文件类型并输出
+    fileLogger(type, ...messages);
+  },
 });
 
 output.info("普通信息"); // 只在控制台显示
@@ -283,11 +330,11 @@ logger.info("应用启动");
 
 ### 测试覆盖率
 
-- **语句覆盖率**: 99.22%
-- **分支覆盖率**: 96.27%
-- **函数覆盖率**: 97.72%
-- **行覆盖率**: 99.22%
-- **测试数量**: 211 个测试，全部通过
+- **语句覆盖率**: 99.35%
+- **分支覆盖率**: 97.63%
+- **函数覆盖率**: 97.5%
+- **行覆盖率**: 99.35%
+- **测试数量**: 181 个测试，全部通过
 
 ### 本地开发
 
@@ -319,6 +366,14 @@ pnpm build
 
 ## 常见问题
 
+**Q: 为什么 Node 包不需要传入 `outputImpl` 参数？**
+
+A: Node 包自动提供了基于 `console.log + chalk` 和 `pino` 的输出实现，用户无需手动创建和传入 `outputImpl`。这是 Node 包相比 Core 包的主要优势。
+
+**Q: 如何在生产环境中优化日志性能？**
+
+A: 使用异步写入模式（`sync: false`），适当增加缓冲区大小（如 8KB 或 16KB），并合理配置 `isSilent` 函数来过滤不必要的日志输出。
+
 **Q: 如何在 NestJS 中使用？**
 
 A: 可以在 NestJS 的 OnModuleInit 和 OnApplicationShutdown 钩子中使用，临终落盘保护会自动处理进程退出时的日志刷新。

package/es/index.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@done-coding/output-node",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "node相关输出",
   "private": false,
   "module": "es/index.mjs",
@@ -43,6 +43,9 @@
     "@types/node": "^18.0.0",
     "@types/signal-exit": "^4.0.0",
     "@vitest/coverage-v8": "^1.6.1",
+    "chalk": "^5.3.0",
+    "pino": "^8.17.2",
+    "signal-exit": "^4.1.0",
     "typescript": "^5.8.3",
     "vite": "^5.0.10",
     "vite-plugin-dts": "^3.7.0",
@@ -54,10 +57,10 @@
     "signal-exit": "^4.1.0"
   },
   "dependencies": {
-    "@done-coding/output-core": "0.1.0"
+    "@done-coding/output-core": "0.1.1"
   },
   "engines": {
     "node": ">=18.0.0"
   },
-  "gitHead": "fe3595bcf072441befe269e1b1e47c807ae7e0e5"
+  "gitHead": "87831fe924a30d5f398a6687e92f5db72d6ea71b"
 }

package/types/index.d.ts

@@ -32,12 +32,9 @@ export declare function createOutputConsole(options?: CreateOutputConsoleOptions
 
 /**
  * Node.js 环境下的控制台输出选项
- * 继承核心包选项，但不需要手动传入 outputImpl，并且 silent 是可选的
+ * 继承核心包选项，但不需要手动传入 outputImpl
  */
-export declare interface CreateOutputConsoleOptions extends Omit<CreateOutputConsoleOptions_2, "outputFileFn"> {
-    /** 日志文件输出函数 */
-    outputFileFn?: OutputConsoleRaw;
-}
+export declare type CreateOutputConsoleOptions = Omit<CreateOutputConsoleOptions_2, "outputImpl">;
 
 /**
  * 创建日志文件输出实例 (Node.js 适配版本)
@@ -50,31 +47,18 @@ export declare function createOutputLogFile(options: CreateOutputLogFileOptions)
 
 /**
  * Node.js 环境下的日志文件输出选项
- * 继承核心包选项，但不需要手动传入 outputImpl，并且 silent 是可选的
+ * 继承核心包选项，但不需要手动传入 outputImpl，并且增加 Node.js 特定参数
  * logFilePath 为必传参数，必须提供绝对路径
  */
-export declare interface CreateOutputLogFileOptions extends Omit<CreateOutputLogFileOptions_2, "logFilePath" | "outputConsoleFn">, Pick<LogFileOutputImplOptions, "sync" | "bufferSize"> {
+export declare interface CreateOutputLogFileOptions extends Omit<CreateOutputLogFileOptions_2, "outputImpl" | "logFilePath" | "outputConsoleFn"> {
+    /** 日志文件是否同步写入 (默认: false，异步写入) */
+    sync?: boolean;
+    /** 异步写入是的缓冲区大小 (字节，默认: 4096) */
+    bufferSize?: number;
     /** 日志文件绝对路径 (必传) */
     logFilePath: string;
-    /** 输出到控制台对应的方法 */
-    outputConsoleFn?: OutputLogFileRaw;
 }
 
-/**
- * 创建基于 pino 的控制台输出实现
- * 用于 outputLogFile 切换到控制台输出时使用
- *
- * @param options 配置选项
- * @returns 控制台输出函数（保持日志级别类型）
- */
-export declare function createPinoConsoleOutput(): OutputLogFileRaw;
-
-/**
- * 创建控制台输出实现（基于 pino）
- * @returns 日志文件输出函数（输出到控制台）
- */
-export declare function createPinoConsoleOutputImpl(): OutputLogFileRaw;
-
 /**
  * 默认控制台输出颜色映射
  * 根据需求 4.2 定义的颜色方案
@@ -85,8 +69,6 @@ export declare const DEFAULT_CONSOLE_COLOR_MAP: Record<OutputConsoleTypeEnum, st
  * 控制台输出实现默认配置
  */
 export declare const DEFAULT_CONSOLE_OUTPUT_IMPL_OPTIONS: {
-    /** 默认静默模式：关闭 */
-    readonly silent: false;
     /** 默认启用颜色输出：是 */
     readonly enableColor: true;
 };
@@ -107,8 +89,6 @@ export declare const DEFAULT_ERROR_HANDLING_CONFIG: {
  * 日志文件输出实现默认配置
  */
 export declare const DEFAULT_LOG_FILE_OUTPUT_IMPL_OPTIONS: {
-    /** 默认静默模式：关闭 */
-    readonly silent: false;
     /** 默认同步写入：关闭（异步写入） */
     readonly sync: false;
     /** 默认缓冲区大小：4KB */
@@ -119,8 +99,6 @@ export declare const DEFAULT_LOG_FILE_OUTPUT_IMPL_OPTIONS: {
  * Node.js 控制台输出创建函数默认配置
  */
 export declare const DEFAULT_NODE_CREATE_OUTPUT_CONSOLE_OPTIONS: {
-    /** 默认静默模式：关闭 */
-    readonly silent: false;
     /** 默认启用颜色输出：是 */
     readonly enableColor: true;
 };
@@ -129,8 +107,6 @@ export declare const DEFAULT_NODE_CREATE_OUTPUT_CONSOLE_OPTIONS: {
  * Node.js 日志文件输出创建函数默认配置
  */
 export declare const DEFAULT_NODE_CREATE_OUTPUT_LOG_FILE_OPTIONS: {
-    /** 默认静默模式：关闭 */
-    readonly silent: false;
     /** 默认同步写入：关闭（异步写入） */
     readonly sync: false;
     /** 默认缓冲区大小：4KB */
@@ -194,20 +170,6 @@ 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 }