@logtape/adaptor-winston 1.3.1 → 1.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/adaptor-winston",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "winston adapter for LogTape logging library",
   "keywords": [
     "logging",
@@ -55,9 +55,12 @@
   "sideEffects": [
     "./dist/install.*"
   ],
+  "files": [
+    "dist/"
+  ],
   "peerDependencies": {
     "winston": "^3.17.0",
-    "@logtape/logtape": "^1.3.1"
+    "@logtape/logtape": "^1.3.2"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",

package/deno.json

@@ -1,40 +0,0 @@
-{
-  "name": "@logtape/adaptor-winston",
-  "version": "1.3.1",
-  "license": "MIT",
-  "exports": {
-    ".": "./src/mod.ts",
-    "./install": "./src/install.ts"
-  },
-  "imports": {
-    "winston": "npm:winston@^3.17.0"
-  },
-  "exclude": [
-    "coverage/",
-    "npm/",
-    ".dnt-import-map.json"
-  ],
-  "tasks": {
-    "build": "pnpm build",
-    "test": "deno test --allow-env",
-    "test:node": {
-      "dependencies": [
-        "build"
-      ],
-      "command": "node --experimental-transform-types --test"
-    },
-    "test:bun": {
-      "dependencies": [
-        "build"
-      ],
-      "command": "bun test"
-    },
-    "test-all": {
-      "dependencies": [
-        "test",
-        "test:node",
-        "test:bun"
-      ]
-    }
-  }
-}

package/src/install.ts

@@ -1,87 +0,0 @@
-/**
- * Auto-installation module for @logtape/adaptor-winston.
- *
- * This module automatically configures LogTape to route all log records
- * to winston's default logger when imported. This provides the simplest
- * possible integration - just import this module and all LogTape-enabled
- * libraries will immediately start logging through winston.
- *
- * @example Automatic installation via import
- * ```typescript
- * // Simply import this module to automatically set up winston adapter
- * import "@logtape/adaptor-winston/install";
- *
- * // Now all LogTape logs will be routed to winston's default logger
- * import { getLogger } from "@logtape/logtape";
- * const logger = getLogger("my-app");
- * logger.info("This will be logged through winston");
- * ```
- *
- * @example Usage in package.json scripts
- * ```json
- * {
- *   "scripts": {
- *     "start": "node -r @logtape/adaptor-winston/install app.js"
- *   }
- * }
- * ```
- *
- * @example Usage with module bundlers
- * ```typescript
- * // webpack.config.js or similar
- * module.exports = {
- *   entry: [
- *     '@logtape/adaptor-winston/install',
- *     './src/index.js'
- *   ]
- * };
- * ```
- *
- * > [!NOTE]
- * > This module uses winston's default logger with default configuration.
- * > If you need a custom winston logger or configuration options (category
- * > formatting, level mapping, etc.), use the `install()` function from the
- * > main module instead:
- *
- * @example Custom winston logger
- * ```typescript
- * import winston from "winston";
- * import { install } from "@logtape/adaptor-winston";
- *
- * const customLogger = winston.createLogger({
- *   transports: [new winston.transports.File({ filename: "app.log" })]
- * });
- *
- * install(customLogger);
- * ```
- *
- * @example Custom configuration options
- * ```typescript
- * import { install } from "@logtape/adaptor-winston";
- *
- * install({
- *   category: { position: "start", decorator: "[]" }
- * });
- * ```
- *
- * @example Custom logger with custom options
- * ```typescript
- * import winston from "winston";
- * import { install } from "@logtape/adaptor-winston";
- *
- * const customLogger = winston.createLogger({
- *   transports: [new winston.transports.Console()]
- * });
- *
- * install(customLogger, {
- *   category: { position: "start", decorator: "[]" }
- * });
- * ```
- *
- * @module
- * @since 1.0.0
- */
-
-import { install } from "./mod.ts";
-
-install();

package/src/mod.test.ts

@@ -1,415 +0,0 @@
-import { suite } from "@alinea/suite";
-import { assertEquals } from "@std/assert/equals";
-import winston from "winston";
-import WinstonTransport from "winston-transport";
-import { getWinstonSink, type Logger } from "./mod.ts";
-
-const test = suite(import.meta);
-
-interface LogEvent extends Record<string, unknown> {
-  level: keyof Logger;
-  message: string;
-}
-
-class BufferTransport extends WinstonTransport {
-  readonly logs: LogEvent[];
-
-  // deno-lint-ignore no-explicit-any
-  constructor(ops?: any) {
-    super(ops);
-    this.logs = [];
-  }
-
-  override log(info: LogEvent, callback: () => void) {
-    this.logs.push(info);
-    if (callback) callback();
-  }
-}
-
-test("getWinstonSink(): basic scenario", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    level: "silly",
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger);
-  sink({
-    category: ["test", "category"],
-    level: "info",
-    message: ["Test log: ", { foo: 123 }, ""],
-    properties: { value: { foo: 123 } },
-    rawMessage: "Test log: {value}",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  const log = buffer.logs[0];
-  assertEquals(log.level, "info");
-  assertEquals(log.message, "Test log: { foo: 123 }");
-  assertEquals(log.value, { foo: 123 });
-});
-
-test("getWinstonSink(): default level mapping", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    level: "silly",
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger);
-
-  const testCases = [
-    { logTapeLevel: "trace", expectedWinstonLevel: "silly" },
-    { logTapeLevel: "debug", expectedWinstonLevel: "debug" },
-    { logTapeLevel: "info", expectedWinstonLevel: "info" },
-    { logTapeLevel: "warning", expectedWinstonLevel: "warn" },
-    { logTapeLevel: "error", expectedWinstonLevel: "error" },
-    { logTapeLevel: "fatal", expectedWinstonLevel: "error" },
-  ] as const;
-
-  for (const { logTapeLevel, expectedWinstonLevel } of testCases) {
-    buffer.logs.length = 0; // Clear buffer
-    sink({
-      category: [],
-      level: logTapeLevel,
-      message: [`${logTapeLevel} message`],
-      properties: {},
-      rawMessage: `${logTapeLevel} message`,
-      timestamp: Date.now(),
-    });
-    assertEquals(buffer.logs.length, 1);
-    assertEquals(buffer.logs[0].level, expectedWinstonLevel);
-  }
-});
-
-test("getWinstonSink(): custom level mapping", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    level: "silly",
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger, {
-    levelsMap: {
-      "trace": "debug",
-      "debug": "debug",
-      "info": "info",
-      "warning": "warn",
-      "error": "error",
-      "fatal": "error",
-    },
-  });
-
-  sink({
-    category: [],
-    level: "trace",
-    message: ["trace message"],
-    properties: {},
-    rawMessage: "trace message",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(buffer.logs[0].level, "debug");
-});
-
-test("getWinstonSink(): category disabled", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger, {
-    category: false,
-  });
-
-  sink({
-    category: ["app", "database"],
-    level: "info",
-    message: ["Database connected"],
-    properties: {},
-    rawMessage: "Database connected",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(buffer.logs[0].message, "Database connected");
-});
-
-test("getWinstonSink(): category with default formatting", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger, {
-    category: true,
-  });
-
-  sink({
-    category: ["app", "database"],
-    level: "info",
-    message: ["Database connected"],
-    properties: {},
-    rawMessage: "Database connected",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(buffer.logs[0].message, "app·database: Database connected");
-});
-
-test("getWinstonSink(): category with custom separator", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger, {
-    category: {
-      separator: ".",
-    },
-  });
-
-  sink({
-    category: ["app", "database", "connection"],
-    level: "info",
-    message: ["Database connected"],
-    properties: {},
-    rawMessage: "Database connected",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(
-    buffer.logs[0].message,
-    "app.database.connection: Database connected",
-  );
-});
-
-test("getWinstonSink(): category with different decorators", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-
-  const decorators = [
-    { decorator: "[]", expected: "[app·db] Message" },
-    { decorator: "()", expected: "(app·db) Message" },
-    { decorator: "<>", expected: "<app·db> Message" },
-    { decorator: "{}", expected: "{app·db} Message" },
-    { decorator: ":", expected: "app·db: Message" },
-    { decorator: "-", expected: "app·db - Message" },
-    { decorator: "|", expected: "app·db | Message" },
-    { decorator: "/", expected: "app·db / Message" },
-    { decorator: "", expected: "app·db Message" },
-  ] as const;
-
-  for (const { decorator, expected } of decorators) {
-    buffer.logs.length = 0; // Clear buffer
-    const sink = getWinstonSink(logger, {
-      category: { decorator },
-    });
-
-    sink({
-      category: ["app", "db"],
-      level: "info",
-      message: ["Message"],
-      properties: {},
-      rawMessage: "Message",
-      timestamp: Date.now(),
-    });
-    assertEquals(buffer.logs.length, 1);
-    assertEquals(buffer.logs[0].message, expected);
-  }
-});
-
-test("getWinstonSink(): category at end position", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger, {
-    category: {
-      position: "end",
-    },
-  });
-
-  sink({
-    category: ["app", "db"],
-    level: "info",
-    message: ["Database connected"],
-    properties: {},
-    rawMessage: "Database connected",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(buffer.logs[0].message, "Database connected: app·db");
-});
-
-test("getWinstonSink(): category at end with different decorators", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-
-  const decorators = [
-    { decorator: "[]", expected: "Message [app·db]" },
-    { decorator: "()", expected: "Message (app·db)" },
-    { decorator: "<>", expected: "Message <app·db>" },
-    { decorator: "{}", expected: "Message {app·db}" },
-    { decorator: ":", expected: "Message: app·db" },
-    { decorator: "-", expected: "Message - app·db" },
-    { decorator: "|", expected: "Message | app·db" },
-    { decorator: "/", expected: "Message / app·db" },
-    { decorator: "", expected: "Message app·db" },
-  ] as const;
-
-  for (const { decorator, expected } of decorators) {
-    buffer.logs.length = 0; // Clear buffer
-    const sink = getWinstonSink(logger, {
-      category: {
-        position: "end",
-        decorator,
-      },
-    });
-
-    sink({
-      category: ["app", "db"],
-      level: "info",
-      message: ["Message"],
-      properties: {},
-      rawMessage: "Message",
-      timestamp: Date.now(),
-    });
-    assertEquals(buffer.logs.length, 1);
-    assertEquals(buffer.logs[0].message, expected);
-  }
-});
-
-test("getWinstonSink(): empty category", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger, {
-    category: true,
-  });
-
-  sink({
-    category: [],
-    level: "info",
-    message: ["Message without category"],
-    properties: {},
-    rawMessage: "Message without category",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(buffer.logs[0].message, "Message without category");
-});
-
-test("getWinstonSink(): custom value formatter", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger, {
-    valueFormatter: (value) => `CUSTOM:${JSON.stringify(value)}`,
-  });
-
-  sink({
-    category: [],
-    level: "info",
-    message: ["User: ", { name: "John", age: 30 }, ""],
-    properties: { user: { name: "John", age: 30 } },
-    rawMessage: "User: {user}",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(buffer.logs[0].message, 'User: CUSTOM:{"name":"John","age":30}');
-});
-
-test("getWinstonSink(): message interpolation", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger);
-
-  sink({
-    category: [],
-    level: "info",
-    message: ["Hello ", "world", ", count: ", 42, "!"],
-    properties: { name: "world", count: 42 },
-    rawMessage: "Hello {name}, count: {count}!",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(buffer.logs[0].message, "Hello 'world', count: 42!");
-});
-
-test("getWinstonSink(): properties are passed to winston", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger);
-
-  const properties = {
-    userId: 123,
-    requestId: "abc-def-ghi",
-    metadata: { version: "1.0.0" },
-  };
-
-  sink({
-    category: [],
-    level: "info",
-    message: ["User action performed"],
-    properties,
-    rawMessage: "User action performed",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(buffer.logs[0].userId, 123);
-  assertEquals(buffer.logs[0].requestId, "abc-def-ghi");
-  assertEquals(buffer.logs[0].metadata, { version: "1.0.0" });
-});
-
-test("getWinstonSink(): single category", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger, {
-    category: true,
-  });
-
-  sink({
-    category: ["app"],
-    level: "info",
-    message: ["Single category message"],
-    properties: {},
-    rawMessage: "Single category message",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(buffer.logs[0].message, "app: Single category message");
-});
-
-test("getWinstonSink(): complex category with custom options", () => {
-  const buffer = new BufferTransport({});
-  const logger = winston.createLogger({
-    transports: [buffer],
-  });
-  const sink = getWinstonSink(logger, {
-    category: {
-      separator: "/",
-      position: "end",
-      decorator: "[]",
-    },
-  });
-
-  sink({
-    category: ["myapp", "api", "auth", "login"],
-    level: "info",
-    message: ["User logged in successfully"],
-    properties: {},
-    rawMessage: "User logged in successfully",
-    timestamp: Date.now(),
-  });
-  assertEquals(buffer.logs.length, 1);
-  assertEquals(
-    buffer.logs[0].message,
-    "User logged in successfully [myapp/api/auth/login]",
-  );
-});

package/src/mod.ts

@@ -1,458 +0,0 @@
-/**
- * A winston adapter for LogTape logging library.
- *
- * This module provides functionality to integrate LogTape with winston,
- * allowing LogTape logs to be forwarded to winston loggers while maintaining
- * structured logging capabilities and category information.
- *
- * @example
- * ```typescript
- * import { configure } from "@logtape/logtape";
- * import winston from "winston";
- * import { getWinstonSink } from "@logtape/adaptor-winston";
- *
- * const winstonLogger = winston.createLogger({
- *   level: "info",
- *   format: winston.format.json(),
- *   transports: [new winston.transports.Console()]
- * });
- *
- * await configure({
- *   sinks: {
- *     winston: getWinstonSink(winstonLogger)
- *   },
- *   loggers: [
- *     { category: "myapp", sinks: ["winston"] }
- *   ]
- * });
- * ```
- *
- * @module
- * @since 1.0.0
- */
-import {
-  configureSync,
-  type LogLevel,
-  type LogRecord,
-  type Sink,
-} from "@logtape/logtape";
-import winston, { type LeveledLogMethod } from "winston";
-import { inspect } from "node:util";
-
-/**
- * Logger interface for Winston-compatible loggers.
- * @since 1.0.0
- */
-export interface Logger {
-  error: LeveledLogMethod;
-  warn: LeveledLogMethod;
-  info: LeveledLogMethod;
-  http: LeveledLogMethod;
-  verbose: LeveledLogMethod;
-  debug: LeveledLogMethod;
-  silly: LeveledLogMethod;
-}
-
-/**
- * Configuration options for the winston sink.
- *
- * @example Basic usage with default options
- * ```typescript
- * const sink = getWinstonSink(winstonLogger);
- * ```
- *
- * @example Custom level mapping
- * ```typescript
- * const sink = getWinstonSink(winstonLogger, {
- *   levelsMap: {
- *     "trace": "debug",
- *     "debug": "debug",
- *     "info": "info",
- *     "warning": "warn",
- *     "error": "error",
- *     "fatal": "error"
- *   }
- * });
- * ```
- *
- * @example Custom category formatting
- * ```typescript
- * const sink = getWinstonSink(winstonLogger, {
- *   category: {
- *     separator: ".",
- *     position: "start",
- *     decorator: "[]"
- *   }
- * });
- * ```
- *
- * @since 1.0.0
- */
-export interface WinstonSinkOptions {
-  /**
-   * Mapping between LogTape log levels and winston log levels.
-   *
-   * By default, LogTape levels are mapped as follows:
-   *
-   * - `trace` → `silly`
-   * - `debug` → `debug`
-   * - `info` → `info`
-   * - `warning` → `warn`
-   * - `error` → `error`
-   * - `fatal` → `error`
-   */
-  readonly levelsMap?: Readonly<Record<LogLevel, keyof Logger>>;
-
-  /**
-   * Configuration for how LogTape categories are handled in winston logs.
-   *
-   * - `false` or `undefined`: Categories are not included in the log message
-   * - `true`: Categories are included with default formatting (":" decorator at start)
-   * - `CategoryOptions`: Custom category formatting configuration
-   *
-   * @default undefined
-   */
-  readonly category?: boolean | CategoryOptions;
-
-  /**
-   * Custom formatter for interpolated values in log messages.
-   *
-   * This function is used to convert values that are interpolated into
-   * log messages (e.g., the `name` in
-   * `logger.info("Hello, {name}!", { name: "world" })`).
-   *
-   * @param value The value to format
-   * @returns A string representation of the value
-   * @default `inspect` (from `node:util` module)
-   */
-  readonly valueFormatter?: (value: unknown) => string;
-}
-
-/**
- * Configuration options for formatting LogTape categories in winston log messages.
- *
- * Categories in LogTape represent a hierarchical namespace for loggers
- * (e.g., ["myapp", "database", "connection"]). This interface controls
- * how these categories are formatted when included in winston log messages.
- *
- * @example Default formatting
- * ```typescript
- * // With category ["myapp", "db"] and default options:
- * // Output: "myapp·db: User logged in"
- * const options: CategoryOptions = {};
- * ```
- *
- * @example Custom separator and decorator
- * ```typescript
- * // With category ["myapp", "db"] and custom options:
- * // Output: "[myapp.db] User logged in"
- * const options: CategoryOptions = {
- *   separator: ".",
- *   decorator: "[]"
- * };
- * ```
- *
- * @example Category at end
- * ```typescript
- * // With category ["myapp", "db"] and position at end:
- * // Output: "User logged in: myapp·db"
- * const options: CategoryOptions = {
- *   position: "end"
- * };
- * ```
- *
- * @since 1.0.0
- */
-export interface CategoryOptions {
-  /**
-   * The separator used to join category parts when multiple categories exist.
-   * @default "·"
-   */
-  readonly separator?: string;
-
-  /**
-   * Where to position the category in the log message.
-   * - `"start"`: Category appears at the beginning of the message
-   * - `"end"`: Category appears at the end of the message
-   * @default "start"
-   */
-  readonly position?: "start" | "end";
-
-  /**
-   * The decorator used to format the category in the log message.
-   * - `"[]"`: [category] format
-   * - `"()"`: (category) format
-   * - `"<>"`: <category> format
-   * - `"{}"`: {category} format
-   * - `":"`: category: format
-   * - `"-"`: category - format
-   * - `"|"`: category | format
-   * - `"/"`: category / format
-   * - `""`: category format (no decoration)
-   * @default ":"
-   */
-  readonly decorator?: "[]" | "()" | "<>" | "{}" | ":" | "-" | "|" | "/" | "";
-}
-
-const DEFAULT_LEVELS_MAP: Readonly<Record<LogLevel, keyof Logger>> = {
-  "trace": "silly",
-  "debug": "debug",
-  "info": "info",
-  "warning": "warn",
-  "error": "error",
-  "fatal": "error",
-};
-
-/**
- * Creates a LogTape sink that forwards log records to a winston logger.
- *
- * This function creates a sink function that can be used with LogTape's
- * configuration system. The sink will format LogTape log records and
- * forward them to the provided winston logger instance.
- *
- * @example Basic usage
- * ```typescript
- * import winston from "winston";
- * import { configure } from "@logtape/logtape";
- * import { getWinstonSink } from "@logtape/adaptor-winston";
- *
- * const winstonLogger = winston.createLogger({
- *   level: "info",
- *   format: winston.format.combine(
- *     winston.format.timestamp(),
- *     winston.format.json()
- *   ),
- *   transports: [new winston.transports.Console()]
- * });
- *
- * await configure({
- *   sinks: {
- *     winston: getWinstonSink(winstonLogger)
- *   },
- *   loggers: [
- *     { category: ["myapp"], sinks: ["winston"] }
- *   ]
- * });
- * ```
- *
- * @example With custom options
- * ```typescript
- * const sink = getWinstonSink(winstonLogger, {
- *   category: {
- *     separator: ".",
- *     position: "start",
- *     decorator: "[]"
- *   },
- *   levelsMap: {
- *     "trace": "debug",  // Map trace to debug instead of silly
- *     "debug": "debug",
- *     "info": "info",
- *     "warning": "warn",
- *     "error": "error",
- *     "fatal": "error"
- *   }
- * });
- * ```
- *
- * @param logger The winston logger instance to forward logs to. Must implement
- *               the Logger interface with error, warn, info, http, verbose,
- *               debug, and silly methods.
- * @param options Configuration options for the sink behavior.
- * @returns A sink function that can be used with LogTape's configure() function.
- * @since 1.0.0
- */
-export function getWinstonSink(
-  logger: Logger,
-  options: WinstonSinkOptions = {},
-): Sink {
-  const { levelsMap = DEFAULT_LEVELS_MAP, valueFormatter = inspect } = options;
-  const categoryOptions = !options.category
-    ? undefined
-    : typeof options.category === "object"
-    ? options.category
-    : {};
-  const category: Required<CategoryOptions> | undefined =
-    categoryOptions == null ? undefined : {
-      separator: categoryOptions.separator ?? "·",
-      position: categoryOptions.position ?? "start",
-      decorator: categoryOptions.decorator ?? ":",
-    };
-
-  return (record: LogRecord) => {
-    const level = levelsMap[record.level];
-    let message = "";
-    if (category?.position === "start" && record.category.length > 0) {
-      const joinedCategory = record.category.join(category.separator);
-      message += category.decorator === "[]"
-        ? `[${joinedCategory}] `
-        : category.decorator === "()"
-        ? `(${joinedCategory}) `
-        : category.decorator === "<>"
-        ? `<${joinedCategory}> `
-        : category.decorator === "{}"
-        ? `{${joinedCategory}} `
-        : category.decorator === ":"
-        ? `${joinedCategory}: `
-        : category.decorator === "-"
-        ? `${joinedCategory} - `
-        : category.decorator === "|"
-        ? `${joinedCategory} | `
-        : category.decorator === "/"
-        ? `${joinedCategory} / `
-        : `${joinedCategory} `;
-    }
-    for (let i = 0; i < record.message.length; i += 2) {
-      message += record.message[i];
-      if (i + 1 < record.message.length) {
-        message += valueFormatter(record.message[i + 1]);
-      }
-    }
-    if (category?.position === "end" && record.category.length > 0) {
-      const joinedCategory = record.category.join(category.separator);
-      message += category.decorator === "[]"
-        ? ` [${joinedCategory}]`
-        : category.decorator === "()"
-        ? ` (${joinedCategory})`
-        : category.decorator === "<>"
-        ? ` <${joinedCategory}>`
-        : category.decorator === "{}"
-        ? ` {${joinedCategory}}`
-        : category.decorator === ":"
-        ? `: ${joinedCategory}`
-        : category.decorator === "-"
-        ? ` - ${joinedCategory}`
-        : category.decorator === "|"
-        ? ` | ${joinedCategory}`
-        : category.decorator === "/"
-        ? ` / ${joinedCategory}`
-        : ` ${joinedCategory}`;
-    }
-    logger[level](message, record.properties);
-  };
-}
-
-/**
- * Automatically configures LogTape to route all logs to a winston logger.
- *
- * This is a convenience function that automatically sets up LogTape to forward
- * all log records to a winston logger instance. By default, it uses winston's
- * default logger, but you can provide a custom logger as the first parameter.
- *
- * @param logger The winston logger instance to use.
- * @param options Configuration options for the winston sink behavior.
- *
- * @example Basic auto-configuration with default logger
- * ```typescript
- * import { install } from "@logtape/adaptor-winston";
- *
- * // Automatically route all LogTape logs to winston's default logger
- * install();
- *
- * // Now any LogTape-enabled library will log through winston
- * import { getLogger } from "@logtape/logtape";
- * const logger = getLogger("my-app");
- * logger.info("This will be logged through winston");
- * ```
- *
- * @example Auto-configuration with custom winston logger
- * ```typescript
- * import winston from "winston";
- * import { install } from "@logtape/adaptor-winston";
- *
- * const customLogger = winston.createLogger({
- *   level: "info",
- *   format: winston.format.combine(
- *     winston.format.timestamp(),
- *     winston.format.json()
- *   ),
- *   transports: [
- *     new winston.transports.Console(),
- *     new winston.transports.File({ filename: "app.log" })
- *   ]
- * });
- *
- * // Install with custom logger
- * install(customLogger);
- * ```
- *
- * @example Auto-configuration with custom options
- * ```typescript
- * import { install } from "@logtape/adaptor-winston";
- *
- * install(undefined, {
- *   category: {
- *     position: "start",
- *     decorator: "[]",
- *     separator: "."
- *   },
- *   levelsMap: {
- *     "trace": "debug"  // Map LogTape trace to winston debug
- *   }
- * });
- * ```
- *
- * @example Custom logger with custom options
- * ```typescript
- * import winston from "winston";
- * import { install } from "@logtape/adaptor-winston";
- *
- * const customLogger = winston.createLogger({
- *   transports: [new winston.transports.Console()]
- * });
- *
- * install(customLogger, {
- *   category: { position: "start", decorator: "[]" }
- * });
- * ```
- *
- * @since 1.0.0
- */
-export function install(
-  logger: Logger,
-  options?: WinstonSinkOptions,
-): void;
-
-/**
- * Configures LogTape to route all logs to winston's default logger.
- *
- * @param options Optional configuration for the winston sink behavior.
- * @since 1.0.0
- */
-export function install(
-  options?: WinstonSinkOptions,
-): void;
-
-export function install(
-  loggerOrOptions?: Logger | WinstonSinkOptions,
-  options: WinstonSinkOptions = {},
-): void {
-  let logger: Logger;
-  let sinkOptions: WinstonSinkOptions;
-
-  // Handle overloaded parameters
-  if (
-    loggerOrOptions && ("error" in loggerOrOptions || "info" in loggerOrOptions)
-  ) {
-    // First parameter is a Logger
-    logger = loggerOrOptions as Logger;
-    sinkOptions = options;
-  } else {
-    // First parameter is WinstonSinkOptions or undefined
-    logger = winston;
-    sinkOptions = (loggerOrOptions as WinstonSinkOptions) || {};
-  }
-
-  configureSync({
-    sinks: {
-      winston: getWinstonSink(logger, sinkOptions),
-    },
-    loggers: [
-      {
-        category: ["logtape", "meta"],
-        sinks: ["winston"],
-        lowestLevel: "warning",
-      },
-      { category: [], sinks: ["winston"] },
-    ],
-  });
-}

package/tsdown.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export default defineConfig({
-  entry: ["src/mod.ts", "src/install.ts"],
-  dts: {
-    sourcemap: true,
-  },
-  format: ["esm", "cjs"],
-  platform: "node",
-  unbundle: true,
-});