@logtape/file 1.0.0-dev.241 → 1.0.0-dev.246

package/filesink.deno.ts

@@ -1,6 +1,5 @@
 import type { Sink } from "@logtape/logtape";
 import {
-  type AsyncRotatingFileSinkDriver,
   type FileSinkOptions,
   getBaseFileSink,
   getBaseRotatingFileSink,
@@ -18,13 +17,6 @@ export const denoDriver: RotatingFileSinkDriver<Deno.FsFile> = {
   writeSync(fd, chunk) {
     fd.writeSync(chunk);
   },
-  writeManySync(fd: Deno.FsFile, chunks: Uint8Array[]): void {
-    // Deno doesn't have writev, but we can optimize by writing all chunks
-    // then doing a single sync operation
-    for (const chunk of chunks) {
-      fd.writeSync(chunk);
-    }
-  },
   flushSync(fd) {
     fd.syncSync();
   },
@@ -35,27 +27,6 @@ export const denoDriver: RotatingFileSinkDriver<Deno.FsFile> = {
   renameSync: globalThis?.Deno.renameSync,
 };
 
-/**
- * A Deno-specific async file sink driver.
- * @since 1.0.0
- */
-export const denoAsyncDriver: AsyncRotatingFileSinkDriver<Deno.FsFile> = {
-  ...denoDriver,
-  async writeMany(fd: Deno.FsFile, chunks: Uint8Array[]): Promise<void> {
-    // Deno doesn't have async writev, but we can write all chunks
-    // then do a single async sync
-    for (const chunk of chunks) {
-      await fd.write(chunk);
-    }
-  },
-  async flush(fd) {
-    await fd.sync();
-  },
-  close(fd) {
-    return Promise.resolve(fd.close());
-  },
-};
-
 /**
  * Get a file sink.
  *
@@ -64,24 +35,12 @@ export const denoAsyncDriver: AsyncRotatingFileSinkDriver<Deno.FsFile> = {
  * @param path A path to the file to write to.
  * @param options The options for the sink.
  * @returns A sink that writes to the file.  The sink is also a disposable
- *          object that closes the file when disposed. If `nonBlocking` is enabled,
- *          returns a sink that also implements {@link AsyncDisposable}.
+ *          object that closes the file when disposed.
  */
-export function getFileSink(
-  path: string,
-  options?: FileSinkOptions,
-): Sink & Disposable;
-export function getFileSink(
-  path: string,
-  options: FileSinkOptions & { nonBlocking: true },
-): Sink & AsyncDisposable;
 export function getFileSink(
   path: string,
   options: FileSinkOptions = {},
-): Sink & (Disposable | AsyncDisposable) {
-  if (options.nonBlocking) {
-    return getBaseFileSink(path, { ...options, ...denoAsyncDriver });
-  }
+): Sink & Disposable {
   return getBaseFileSink(path, { ...options, ...denoDriver });
 }
 
@@ -98,24 +57,12 @@ export function getFileSink(
  * @param path A path to the file to write to.
  * @param options The options for the sink and the file driver.
  * @returns A sink that writes to the file.  The sink is also a disposable
- *          object that closes the file when disposed. If `nonBlocking` is enabled,
- *          returns a sink that also implements {@link AsyncDisposable}.
+ *          object that closes the file when disposed.
  */
-export function getRotatingFileSink(
-  path: string,
-  options?: RotatingFileSinkOptions,
-): Sink & Disposable;
-export function getRotatingFileSink(
-  path: string,
-  options: RotatingFileSinkOptions & { nonBlocking: true },
-): Sink & AsyncDisposable;
 export function getRotatingFileSink(
   path: string,
   options: RotatingFileSinkOptions = {},
-): Sink & (Disposable | AsyncDisposable) {
-  if (options.nonBlocking) {
-    return getBaseRotatingFileSink(path, { ...options, ...denoAsyncDriver });
-  }
+): Sink & Disposable {
   return getBaseRotatingFileSink(path, { ...options, ...denoDriver });
 }
 

package/filesink.jsr.ts

@@ -4,10 +4,7 @@ import type {
   RotatingFileSinkOptions,
 } from "./filesink.base.ts";
 
-const filesink: Omit<
-  typeof import("./filesink.deno.ts"),
-  "denoDriver" | "denoAsyncDriver"
-> =
+const filesink: Omit<typeof import("./filesink.deno.ts"), "denoDriver"> =
   // dnt-shim-ignore
   await ("Deno" in globalThis
     ? import("./filesink.deno.ts")
@@ -21,24 +18,13 @@ const filesink: Omit<
  * @param path A path to the file to write to.
  * @param options The options for the sink.
  * @returns A sink that writes to the file.  The sink is also a disposable
- *          object that closes the file when disposed. If `nonBlocking` is enabled,
- *          returns a sink that also implements {@link AsyncDisposable}.
+ *          object that closes the file when disposed.
  */
-export function getFileSink(
-  path: string,
-  options?: FileSinkOptions,
-): Sink & Disposable;
-export function getFileSink(
-  path: string,
-  options: FileSinkOptions & { nonBlocking: true },
-): Sink & AsyncDisposable;
 export function getFileSink(
   path: string,
   options: FileSinkOptions = {},
-): Sink & (Disposable | AsyncDisposable) {
-  return filesink.getFileSink(path, options) as
-    & Sink
-    & (Disposable | AsyncDisposable);
+): Sink & Disposable {
+  return filesink.getFileSink(path, options);
 }
 
 /**
@@ -54,24 +40,13 @@ export function getFileSink(
  * @param path A path to the file to write to.
  * @param options The options for the sink and the file driver.
  * @returns A sink that writes to the file.  The sink is also a disposable
- *          object that closes the file when disposed. If `nonBlocking` is enabled,
- *          returns a sink that also implements {@link AsyncDisposable}.
+ *          object that closes the file when disposed.
  */
-export function getRotatingFileSink(
-  path: string,
-  options?: RotatingFileSinkOptions,
-): Sink & Disposable;
-export function getRotatingFileSink(
-  path: string,
-  options: RotatingFileSinkOptions & { nonBlocking: true },
-): Sink & AsyncDisposable;
 export function getRotatingFileSink(
   path: string,
   options: RotatingFileSinkOptions = {},
-): Sink & (Disposable | AsyncDisposable) {
-  return filesink.getRotatingFileSink(path, options) as
-    & Sink
-    & (Disposable | AsyncDisposable);
+): Sink & Disposable {
+  return filesink.getRotatingFileSink(path, options);
 }
 
 // cSpell: ignore filesink

package/filesink.node.ts

@@ -1,8 +1,6 @@
 import type { Sink } from "@logtape/logtape";
 import fs from "node:fs";
-import { promisify } from "node:util";
 import {
-  type AsyncRotatingFileSinkDriver,
   type FileSinkOptions,
   getBaseFileSink,
   getBaseRotatingFileSink,
@@ -18,40 +16,12 @@ export const nodeDriver: RotatingFileSinkDriver<number | void> = {
     return fs.openSync(path, "a");
   },
   writeSync: fs.writeSync,
-  writeManySync(fd: number, chunks: Uint8Array[]): void {
-    if (chunks.length === 0) return;
-    if (chunks.length === 1) {
-      fs.writeSync(fd, chunks[0]);
-      return;
-    }
-    // Use writev for multiple chunks
-    fs.writevSync(fd, chunks);
-  },
   flushSync: fs.fsyncSync,
   closeSync: fs.closeSync,
   statSync: fs.statSync,
   renameSync: fs.renameSync,
 };
 
-/**
- * A Node.js-specific async file sink driver.
- * @since 1.0.0
- */
-export const nodeAsyncDriver: AsyncRotatingFileSinkDriver<number | void> = {
-  ...nodeDriver,
-  async writeMany(fd: number, chunks: Uint8Array[]): Promise<void> {
-    if (chunks.length === 0) return;
-    if (chunks.length === 1) {
-      await promisify(fs.write)(fd, chunks[0]);
-      return;
-    }
-    // Use async writev for multiple chunks
-    await promisify(fs.writev)(fd, chunks);
-  },
-  flush: promisify(fs.fsync),
-  close: promisify(fs.close),
-};
-
 /**
  * Get a file sink.
  *
@@ -60,24 +30,12 @@ export const nodeAsyncDriver: AsyncRotatingFileSinkDriver<number | void> = {
  * @param path A path to the file to write to.
  * @param options The options for the sink.
  * @returns A sink that writes to the file.  The sink is also a disposable
- *          object that closes the file when disposed. If `nonBlocking` is enabled,
- *          returns a sink that also implements {@link AsyncDisposable}.
+ *          object that closes the file when disposed.
  */
-export function getFileSink(
-  path: string,
-  options?: FileSinkOptions,
-): Sink & Disposable;
-export function getFileSink(
-  path: string,
-  options: FileSinkOptions & { nonBlocking: true },
-): Sink & AsyncDisposable;
 export function getFileSink(
   path: string,
   options: FileSinkOptions = {},
-): Sink & (Disposable | AsyncDisposable) {
-  if (options.nonBlocking) {
-    return getBaseFileSink(path, { ...options, ...nodeAsyncDriver });
-  }
+): Sink & Disposable {
   return getBaseFileSink(path, { ...options, ...nodeDriver });
 }
 
@@ -94,24 +52,12 @@ export function getFileSink(
  * @param path A path to the file to write to.
  * @param options The options for the sink and the file driver.
  * @returns A sink that writes to the file.  The sink is also a disposable
- *          object that closes the file when disposed. If `nonBlocking` is enabled,
- *          returns a sink that also implements {@link AsyncDisposable}.
+ *          object that closes the file when disposed.
  */
-export function getRotatingFileSink(
-  path: string,
-  options?: RotatingFileSinkOptions,
-): Sink & Disposable;
-export function getRotatingFileSink(
-  path: string,
-  options: RotatingFileSinkOptions & { nonBlocking: true },
-): Sink & AsyncDisposable;
 export function getRotatingFileSink(
   path: string,
   options: RotatingFileSinkOptions = {},
-): Sink & (Disposable | AsyncDisposable) {
-  if (options.nonBlocking) {
-    return getBaseRotatingFileSink(path, { ...options, ...nodeAsyncDriver });
-  }
+): Sink & Disposable {
   return getBaseRotatingFileSink(path, { ...options, ...nodeDriver });
 }
 

package/filesink.test.ts

@@ -2,10 +2,8 @@ import { getFileSink, getRotatingFileSink } from "#filesink";
 import { suite } from "@alinea/suite";
 import { isDeno } from "@david/which-runtime";
 import type { Sink } from "@logtape/logtape";
-import { assert } from "@std/assert/assert";
 import { assertEquals } from "@std/assert/equals";
 import { assertThrows } from "@std/assert/throws";
-import { delay } from "@std/async/delay";
 import { join } from "@std/path/join";
 import fs from "node:fs";
 import { tmpdir } from "node:os";
@@ -693,122 +691,4 @@ test("getBaseFileSink() with flushInterval disabled", () => {
   assertEquals(content.includes("Hello, 123 & 456!"), true);
 });
 
-test("getFileSink() with nonBlocking mode", async () => {
-  const path = makeTempFileSync();
-  const sink = getFileSink(path, {
-    nonBlocking: true,
-    bufferSize: 50, // Small buffer to trigger flush by size
-  });
-
-  // Check that it returns AsyncDisposable
-  assert(typeof sink === "function");
-  assert(Symbol.asyncDispose in sink);
-
-  // Add enough records to trigger buffer flush
-  sink(debug);
-  sink(info);
-
-  // Wait for async flush to complete
-  await delay(50);
-  const content = fs.readFileSync(path, { encoding: "utf-8" });
-  assert(content.includes("Hello, 123 & 456!"));
-
-  await (sink as Sink & AsyncDisposable)[Symbol.asyncDispose]();
-});
-
-test("getRotatingFileSink() with nonBlocking mode", async () => {
-  const path = makeTempFileSync();
-  const sink = getRotatingFileSink(path, {
-    maxSize: 200,
-    nonBlocking: true,
-    bufferSize: 1000, // Large buffer to prevent immediate flush
-    flushInterval: 50, // Short interval for testing
-  });
-
-  // Check that it returns AsyncDisposable
-  assert(typeof sink === "function");
-  assert(Symbol.asyncDispose in sink);
-
-  // Add records with current timestamp
-  const record1 = { ...debug, timestamp: Date.now() };
-  const record2 = { ...info, timestamp: Date.now() };
-  sink(record1);
-  sink(record2);
-  assertEquals(fs.readFileSync(path, { encoding: "utf-8" }), ""); // Not written yet
-
-  // Wait for flush interval to pass
-  await delay(100);
-  const content = fs.readFileSync(path, { encoding: "utf-8" });
-  assert(content.includes("Hello, 123 & 456!"));
-
-  await (sink as Sink & AsyncDisposable)[Symbol.asyncDispose]();
-});
-
-test("getFileSink() with nonBlocking high-volume logging", async () => {
-  const path = makeTempFileSync();
-  const sink = getFileSink(path, {
-    nonBlocking: true,
-    bufferSize: 50, // Small buffer to trigger flush
-    flushInterval: 0, // Disable time-based flushing for this test
-  }) as unknown as Sink & AsyncDisposable;
-
-  // Add enough records to trigger buffer flush (50 chars per record roughly)
-  let totalChars = 0;
-  let recordCount = 0;
-  while (totalChars < 100) { // Exceed buffer size
-    sink(debug);
-    totalChars += 67; // Approximate length of each debug record
-    recordCount++;
-  }
-
-  // Wait for async flush to complete
-  await delay(50);
-  const content = fs.readFileSync(path, { encoding: "utf-8" });
-
-  // Should have some records written by now
-  const writtenCount = (content.match(/Hello, 123 & 456!/g) || []).length;
-  assert(
-    writtenCount > 0,
-    `Expected some records to be written, but got ${writtenCount}`,
-  );
-
-  await sink[Symbol.asyncDispose]();
-});
-
-test("getRotatingFileSink() with nonBlocking rotation", async () => {
-  const path = makeTempFileSync();
-  const sink = getRotatingFileSink(path, {
-    maxSize: 150, // Small size to trigger rotation
-    nonBlocking: true,
-    bufferSize: 100,
-    flushInterval: 10,
-  }) as unknown as Sink & AsyncDisposable;
-
-  // Add enough records to trigger rotation
-  sink(debug);
-  sink(info);
-  sink(warning);
-  sink(error);
-
-  // Wait for all flushes and rotation to complete
-  await delay(200);
-
-  // Check that rotation occurred
-  const mainContent = fs.readFileSync(path, { encoding: "utf-8" });
-  let rotatedContent = "";
-  try {
-    rotatedContent = fs.readFileSync(`${path}.1`, { encoding: "utf-8" });
-  } catch {
-    // No rotation occurred
-  }
-
-  const allContent = mainContent + rotatedContent;
-
-  // Should have all 4 records somewhere
-  const recordCount = (allContent.match(/Hello, 123 & 456!/g) || []).length;
-  assertEquals(recordCount, 4);
-
-  await sink[Symbol.asyncDispose]();
-});
-
 // cSpell: ignore filesink

package/mod.ts

@@ -4,6 +4,4 @@ export type {
   RotatingFileSinkDriver,
   RotatingFileSinkOptions,
 } from "./filesink.base.ts";
-export type { StreamFileSinkOptions } from "./streamfilesink.ts";
 export { getFileSink, getRotatingFileSink } from "#filesink";
-export { getStreamFileSink } from "./streamfilesink.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/file",
-  "version": "1.0.0-dev.241+13810dcf",
+  "version": "1.0.0-dev.246+c7630de7",
   "description": "File sink and rotating file sink for LogTape",
   "keywords": [
     "logging",
@@ -34,29 +34,34 @@
   "types": "./dist/mod.d.ts",
   "exports": {
     ".": {
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts"
+      },
       "import": "./dist/mod.js",
-      "require": "./dist/mod.cjs",
-      "types": "./dist/mod.d.ts"
+      "require": "./dist/mod.cjs"
     },
     "./package.json": "./package.json"
   },
   "imports": {
     "#filesink": {
+      "types": {
+        "import": "./dist/filesink.node.d.ts",
+        "require": "./dist/filesink.node.d.cts"
+      },
       "bun": "./dist/filesink.node.js",
       "deno": "./dist/filesink.deno.js",
       "import": "./dist/filesink.node.js",
-      "require": "./dist/filesink.node.cjs",
-      "types": "./dist/filesink.node.d.ts"
+      "require": "./dist/filesink.node.cjs"
     }
   },
   "peerDependencies": {
-    "@logtape/logtape": "1.0.0-dev.241+13810dcf"
+    "@logtape/logtape": "1.0.0-dev.246+c7630de7"
   },
   "devDependencies": {
     "@alinea/suite": "^0.6.3",
     "@david/which-runtime": "npm:@jsr/david__which-runtime@^0.2.1",
     "@std/assert": "npm:@jsr/std__assert@^1.0.13",
-    "@std/async": "npm:@jsr/std__async@^1.0.13",
     "@std/path": "npm:@jsr/std__path@^1.1.0",
     "tsdown": "^0.12.7",
     "typescript": "^5.8.3"

package/tsdown.config.ts

@@ -6,13 +6,13 @@ export default defineConfig({
     sourcemap: true,
   },
   format: ["esm", "cjs"],
-  platform: "node",
+  platform: "neutral",
   unbundle: true,
   inputOptions: {
     onLog(level, log, defaultHandler) {
       if (
         level === "warn" && log.code === "UNRESOLVED_IMPORT" &&
-        log.exporter === "#filesink"
+        ["node:fs", "#filesink"].includes(log.exporter ?? "")
       ) {
         return;
       }

package/dist/streamfilesink.cjs

@@ -1,84 +0,0 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
-const node_fs = require_rolldown_runtime.__toESM(require("node:fs"));
-const node_stream = require_rolldown_runtime.__toESM(require("node:stream"));
-
-//#region streamfilesink.ts
-/**
-* Create a high-performance stream-based file sink that writes log records to a file.
-*
-* This sink uses Node.js PassThrough streams piped to WriteStreams for optimal
-* I/O performance. It leverages the Node.js stream infrastructure to provide
-* automatic backpressure management, efficient buffering, and asynchronous writes
-* without blocking the main thread.
-*
-* ## Performance Characteristics
-*
-* - **High Performance**: Optimized for high-volume logging scenarios
-* - **Non-blocking**: Uses asynchronous I/O that doesn't block the main thread
-* - **Memory Efficient**: Automatic backpressure prevents memory buildup
-* - **Stream-based**: Leverages Node.js native stream optimizations
-*
-* ## When to Use
-*
-* Use this sink when you need:
-* - High-performance file logging for production applications
-* - Non-blocking I/O behavior for real-time applications
-* - Automatic backpressure handling for high-volume scenarios
-* - Simple file output without complex buffering configuration
-*
-* For more control over buffering behavior, consider using {@link getFileSink}
-* instead, which provides options for buffer size, flush intervals, and
-* non-blocking modes.
-*
-* ## Example
-*
-* ```typescript
-* import { configure } from "@logtape/logtape";
-* import { getStreamFileSink } from "@logtape/file";
-*
-* await configure({
-*   sinks: {
-*     file: getStreamFileSink("app.log", {
-*       highWaterMark: 32768  // 32KB buffer for high-volume logging
-*     })
-*   },
-*   loggers: [
-*     { category: ["myapp"], sinks: ["file"] }
-*   ]
-* });
-* ```
-*
-* @param path The path to the file to write logs to. The file will be created
-*             if it doesn't exist, or appended to if it does exist.
-* @param options Configuration options for the stream-based sink.
-* @returns A sink that writes formatted log records to the specified file.
-*          The returned sink implements `Disposable` for proper resource cleanup.
-*
-* @since 1.0.0
-*/
-function getStreamFileSink(path, options = {}) {
-	const highWaterMark = options.highWaterMark ?? 16384;
-	const formatter = options.formatter ?? __logtape_logtape.defaultTextFormatter;
-	const passThrough = new node_stream.PassThrough({
-		highWaterMark,
-		objectMode: false
-	});
-	const writeStream = (0, node_fs.createWriteStream)(path, { flags: "a" });
-	passThrough.pipe(writeStream);
-	let disposed = false;
-	const sink = (record) => {
-		if (disposed) return;
-		passThrough.write(formatter(record));
-	};
-	sink[Symbol.dispose] = () => {
-		if (disposed) return;
-		disposed = true;
-		passThrough.end();
-		writeStream.end();
-	};
-	return sink;
-}
-
-//#endregion
-exports.getStreamFileSink = getStreamFileSink;

package/dist/streamfilesink.d.cts

@@ -1,95 +0,0 @@
-import { Sink, TextFormatter } from "@logtape/logtape";
-
-//#region streamfilesink.d.ts
-
-/**
- * Options for the {@link getStreamFileSink} function.
- *
- * This interface configures the high-performance stream-based file sink that
- * uses Node.js PassThrough streams for optimal I/O performance with automatic
- * backpressure management.
- *
- * @since 1.0.0
- */
-interface StreamFileSinkOptions {
-  /**
-   * High water mark for the PassThrough stream buffer in bytes.
-   *
-   * This controls the internal buffer size of the PassThrough stream.
-   * Higher values can improve performance for high-volume logging but use
-   * more memory. Lower values reduce memory usage but may impact performance.
-   *
-   * @default 16384
-   * @since 1.0.0
-   */
-  readonly highWaterMark?: number;
-  /**
-   * A custom formatter for log records.
-   *
-   * If not specified, the default text formatter will be used, which formats
-   * records in the standard LogTape format with timestamp, level, category,
-   * and message.
-   *
-   * @default defaultTextFormatter
-   * @since 1.0.0
-   */
-  readonly formatter?: TextFormatter;
-}
-/**
- * Create a high-performance stream-based file sink that writes log records to a file.
- *
- * This sink uses Node.js PassThrough streams piped to WriteStreams for optimal
- * I/O performance. It leverages the Node.js stream infrastructure to provide
- * automatic backpressure management, efficient buffering, and asynchronous writes
- * without blocking the main thread.
- *
- * ## Performance Characteristics
- *
- * - **High Performance**: Optimized for high-volume logging scenarios
- * - **Non-blocking**: Uses asynchronous I/O that doesn't block the main thread
- * - **Memory Efficient**: Automatic backpressure prevents memory buildup
- * - **Stream-based**: Leverages Node.js native stream optimizations
- *
- * ## When to Use
- *
- * Use this sink when you need:
- * - High-performance file logging for production applications
- * - Non-blocking I/O behavior for real-time applications
- * - Automatic backpressure handling for high-volume scenarios
- * - Simple file output without complex buffering configuration
- *
- * For more control over buffering behavior, consider using {@link getFileSink}
- * instead, which provides options for buffer size, flush intervals, and
- * non-blocking modes.
- *
- * ## Example
- *
- * ```typescript
- * import { configure } from "@logtape/logtape";
- * import { getStreamFileSink } from "@logtape/file";
- *
- * await configure({
- *   sinks: {
- *     file: getStreamFileSink("app.log", {
- *       highWaterMark: 32768  // 32KB buffer for high-volume logging
- *     })
- *   },
- *   loggers: [
- *     { category: ["myapp"], sinks: ["file"] }
- *   ]
- * });
- * ```
- *
- * @param path The path to the file to write logs to. The file will be created
- *             if it doesn't exist, or appended to if it does exist.
- * @param options Configuration options for the stream-based sink.
- * @returns A sink that writes formatted log records to the specified file.
- *          The returned sink implements `Disposable` for proper resource cleanup.
- *
- * @since 1.0.0
- */
-declare function getStreamFileSink(path: string, options?: StreamFileSinkOptions): Sink & Disposable;
-//# sourceMappingURL=streamfilesink.d.ts.map
-//#endregion
-export { StreamFileSinkOptions, getStreamFileSink };
-//# sourceMappingURL=streamfilesink.d.cts.map

package/dist/streamfilesink.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"streamfilesink.d.cts","names":[],"sources":["../streamfilesink.ts"],"sourcesContent":[],"mappings":";;;;;;AAkBA;AA+EA;;;;;AAGoB;UAlFH,qBAAA;;;;;;;;;;;;;;;;;;;;;;uBAuBM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDP,iBAAA,yBAEL,wBACR,OAAO"}