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

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@logtape/file",
-  "version": "1.0.0-dev.241+13810dcf",
+  "version": "1.0.0-dev.246+c7630de7",
   "license": "MIT",
   "exports": "./mod.ts",
   "imports": {

package/dist/filesink.base.cjs

@@ -3,303 +3,59 @@ const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/log
 
 //#region filesink.base.ts
 /**
-* Adaptive flush strategy that dynamically adjusts buffer thresholds
-* based on recent flush patterns for optimal performance.
+* Get a platform-independent file sink.
+*
+* @typeParam TFile The type of the file descriptor.
+* @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.
 */
-var AdaptiveFlushStrategy = class {
-	recentFlushSizes = [];
-	recentFlushTimes = [];
-	avgFlushSize;
-	avgFlushInterval;
-	maxHistorySize = 10;
-	baseThreshold;
-	constructor(baseThreshold, baseInterval) {
-		this.baseThreshold = baseThreshold;
-		this.avgFlushSize = baseThreshold;
-		this.avgFlushInterval = baseInterval;
-	}
-	/**
-	* Record a flush event for pattern analysis.
-	* @param size The size of data flushed in bytes.
-	* @param timeSinceLastFlush Time since last flush in milliseconds.
-	*/
-	recordFlush(size, timeSinceLastFlush) {
-		this.recentFlushSizes.push(size);
-		this.recentFlushTimes.push(timeSinceLastFlush);
-		if (this.recentFlushSizes.length > this.maxHistorySize) {
-			this.recentFlushSizes.shift();
-			this.recentFlushTimes.shift();
-		}
-		this.updateAverages();
-	}
-	/**
-	* Determine if buffer should be flushed based on adaptive strategy.
-	* @param currentSize Current buffer size in bytes.
-	* @param timeSinceLastFlush Time since last flush in milliseconds.
-	* @returns True if buffer should be flushed.
-	*/
-	shouldFlush(currentSize, timeSinceLastFlush) {
-		const adaptiveThreshold = this.calculateAdaptiveThreshold();
-		const adaptiveInterval = this.calculateAdaptiveInterval();
-		return currentSize >= adaptiveThreshold || adaptiveInterval > 0 && timeSinceLastFlush >= adaptiveInterval;
-	}
-	updateAverages() {
-		if (this.recentFlushSizes.length === 0) return;
-		this.avgFlushSize = this.recentFlushSizes.reduce((sum, size) => sum + size, 0) / this.recentFlushSizes.length;
-		this.avgFlushInterval = this.recentFlushTimes.reduce((sum, time) => sum + time, 0) / this.recentFlushTimes.length;
-	}
-	calculateAdaptiveThreshold() {
-		const adaptiveFactor = Math.min(2, Math.max(.5, this.avgFlushSize / this.baseThreshold));
-		return Math.max(Math.min(4096, this.baseThreshold / 2), Math.min(64 * 1024, this.baseThreshold * adaptiveFactor));
-	}
-	calculateAdaptiveInterval() {
-		if (this.avgFlushInterval <= 0) return 0;
-		if (this.recentFlushTimes.length < 3) return this.avgFlushInterval;
-		const variance = this.calculateVariance(this.recentFlushTimes);
-		const stabilityFactor = Math.min(2, Math.max(.5, 1e3 / variance));
-		return Math.max(1e3, Math.min(1e4, this.avgFlushInterval * stabilityFactor));
-	}
-	calculateVariance(values) {
-		if (values.length < 2) return 1e3;
-		const mean = values.reduce((sum, val) => sum + val, 0) / values.length;
-		const squaredDiffs = values.map((val) => Math.pow(val - mean, 2));
-		return squaredDiffs.reduce((sum, diff) => sum + diff, 0) / values.length;
-	}
-};
-/**
-* Memory pool for reusing Uint8Array buffers to minimize GC pressure.
-* Maintains a pool of pre-allocated buffers for efficient reuse.
-*/
-var BufferPool = class {
-	pool = [];
-	maxPoolSize = 50;
-	maxBufferSize = 64 * 1024;
-	/**
-	* Acquire a buffer from the pool or create a new one.
-	* @param size The minimum size needed for the buffer.
-	* @returns A Uint8Array that can be used for encoding.
-	*/
-	acquire(size) {
-		if (size > this.maxBufferSize) return new Uint8Array(size);
-		for (let i = this.pool.length - 1; i >= 0; i--) {
-			const buffer = this.pool[i];
-			if (buffer.length >= size) {
-				this.pool.splice(i, 1);
-				return buffer.subarray(0, size);
-			}
-		}
-		const actualSize = Math.max(size, 1024);
-		return new Uint8Array(actualSize);
-	}
-	/**
-	* Return a buffer to the pool for future reuse.
-	* @param buffer The buffer to return to the pool.
-	*/
-	release(buffer) {
-		if (this.pool.length >= this.maxPoolSize || buffer.length > this.maxBufferSize) return;
-		if (buffer.length < 256) return;
-		this.pool.push(buffer);
-	}
-	/**
-	* Clear the pool to free memory. Useful for cleanup.
-	*/
-	clear() {
-		this.pool.length = 0;
-	}
-	/**
-	* Get current pool statistics for monitoring.
-	* @returns Object with pool size and buffer count.
-	*/
-	getStats() {
-		return {
-			poolSize: this.pool.reduce((sum, buf) => sum + buf.length, 0),
-			totalBuffers: this.pool.length
-		};
-	}
-};
-/**
-* High-performance byte buffer for batching log records.
-* Eliminates string concatenation overhead by storing pre-encoded bytes.
-* Uses memory pooling to reduce GC pressure.
-*/
-var ByteRingBuffer = class {
-	buffers = [];
-	totalSize = 0;
-	bufferPool;
-	constructor(bufferPool) {
-		this.bufferPool = bufferPool;
-	}
-	/**
-	* Append pre-encoded log record bytes to the buffer.
-	* @param data The encoded log record as bytes.
-	*/
-	append(data) {
-		this.buffers.push(data);
-		this.totalSize += data.length;
-	}
-	/**
-	* Get the current total size of buffered data in bytes.
-	* @returns The total size in bytes.
-	*/
-	size() {
-		return this.totalSize;
-	}
-	/**
-	* Get the number of buffered records.
-	* @returns The number of records in the buffer.
-	*/
-	count() {
-		return this.buffers.length;
-	}
-	/**
-	* Flush all buffered data and return it as an array of byte arrays.
-	* This clears the internal buffer and returns used buffers to the pool.
-	* @returns Array of buffered byte arrays ready for writev() operations.
-	*/
-	flush() {
-		const result = [...this.buffers];
-		this.clear();
-		return result;
-	}
-	/**
-	* Clear the buffer without returning data.
-	* Returns buffers to the pool for reuse.
-	*/
-	clear() {
-		for (const buffer of this.buffers) this.bufferPool.release(buffer);
-		this.buffers.length = 0;
-		this.totalSize = 0;
-	}
-	/**
-	* Check if the buffer is empty.
-	* @returns True if the buffer contains no data.
-	*/
-	isEmpty() {
-		return this.buffers.length === 0;
-	}
-};
 function getBaseFileSink(path, options) {
 	const formatter = options.formatter ?? __logtape_logtape.defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
 	const bufferSize = options.bufferSize ?? 1024 * 8;
 	const flushInterval = options.flushInterval ?? 5e3;
 	let fd = options.lazy ? null : options.openSync(path);
-	const bufferPool = new BufferPool();
-	const byteBuffer = new ByteRingBuffer(bufferPool);
-	const adaptiveStrategy = new AdaptiveFlushStrategy(bufferSize, flushInterval);
+	let buffer = "";
 	let lastFlushTimestamp = Date.now();
-	if (!options.nonBlocking) {
-		function flushBuffer$1() {
-			if (fd == null || byteBuffer.isEmpty()) return;
-			const flushSize = byteBuffer.size();
-			const currentTime = Date.now();
-			const timeSinceLastFlush = currentTime - lastFlushTimestamp;
-			const chunks = byteBuffer.flush();
-			if (options.writeManySync && chunks.length > 1) options.writeManySync(fd, chunks);
-			else for (const chunk of chunks) options.writeSync(fd, chunk);
+	function flushBuffer() {
+		if (fd == null) return;
+		if (buffer.length > 0) {
+			options.writeSync(fd, encoder.encode(buffer));
+			buffer = "";
 			options.flushSync(fd);
-			adaptiveStrategy.recordFlush(flushSize, timeSinceLastFlush);
-			lastFlushTimestamp = currentTime;
+			lastFlushTimestamp = Date.now();
 		}
-		const sink = (record) => {
-			if (fd == null) fd = options.openSync(path);
-			if (byteBuffer.isEmpty() && bufferSize === 8192) {
-				const formattedRecord$1 = formatter(record);
-				const encodedRecord$1 = encoder.encode(formattedRecord$1);
-				if (encodedRecord$1.length < 200) {
-					options.writeSync(fd, encodedRecord$1);
-					options.flushSync(fd);
-					lastFlushTimestamp = Date.now();
-					return;
-				}
-			}
-			const formattedRecord = formatter(record);
-			const encodedRecord = encoder.encode(formattedRecord);
-			byteBuffer.append(encodedRecord);
-			if (bufferSize <= 0) flushBuffer$1();
-			else {
-				const timeSinceLastFlush = record.timestamp - lastFlushTimestamp;
-				const shouldFlush = adaptiveStrategy.shouldFlush(byteBuffer.size(), timeSinceLastFlush);
-				if (shouldFlush) flushBuffer$1();
-			}
-		};
-		sink[Symbol.dispose] = () => {
-			if (fd !== null) {
-				flushBuffer$1();
-				options.closeSync(fd);
-			}
-			bufferPool.clear();
-		};
-		return sink;
-	}
-	const asyncOptions = options;
-	let disposed = false;
-	let activeFlush = null;
-	let flushTimer = null;
-	async function flushBuffer() {
-		if (fd == null || byteBuffer.isEmpty()) return;
-		const flushSize = byteBuffer.size();
-		const currentTime = Date.now();
-		const timeSinceLastFlush = currentTime - lastFlushTimestamp;
-		const chunks = byteBuffer.flush();
-		try {
-			if (asyncOptions.writeMany && chunks.length > 1) await asyncOptions.writeMany(fd, chunks);
-			else for (const chunk of chunks) asyncOptions.writeSync(fd, chunk);
-			await asyncOptions.flush(fd);
-			adaptiveStrategy.recordFlush(flushSize, timeSinceLastFlush);
-			lastFlushTimestamp = currentTime;
-		} catch {}
 	}
-	function scheduleFlush() {
-		if (activeFlush || disposed) return;
-		activeFlush = flushBuffer().finally(() => {
-			activeFlush = null;
-		});
-	}
-	function startFlushTimer() {
-		if (flushTimer !== null || disposed) return;
-		flushTimer = setInterval(() => {
-			scheduleFlush();
-		}, flushInterval);
-	}
-	const nonBlockingSink = (record) => {
-		if (disposed) return;
-		if (fd == null) fd = asyncOptions.openSync(path);
-		if (byteBuffer.isEmpty() && !activeFlush && bufferSize === 8192) {
-			const formattedRecord$1 = formatter(record);
-			const encodedRecord$1 = encoder.encode(formattedRecord$1);
-			if (encodedRecord$1.length < 200) {
-				asyncOptions.writeSync(fd, encodedRecord$1);
-				scheduleFlush();
-				lastFlushTimestamp = Date.now();
-				return;
-			}
-		}
-		const formattedRecord = formatter(record);
-		const encodedRecord = encoder.encode(formattedRecord);
-		byteBuffer.append(encodedRecord);
-		if (bufferSize <= 0) scheduleFlush();
-		else {
-			const timeSinceLastFlush = record.timestamp - lastFlushTimestamp;
-			const shouldFlush = adaptiveStrategy.shouldFlush(byteBuffer.size(), timeSinceLastFlush);
-			if (shouldFlush) scheduleFlush();
-			else if (flushTimer === null && flushInterval > 0) startFlushTimer();
-		}
+	const sink = (record) => {
+		if (fd == null) fd = options.openSync(path);
+		buffer += formatter(record);
+		const shouldFlushBySize = buffer.length >= bufferSize;
+		const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
+		if (shouldFlushBySize || shouldFlushByTime) flushBuffer();
 	};
-	nonBlockingSink[Symbol.asyncDispose] = async () => {
-		disposed = true;
-		if (flushTimer !== null) {
-			clearInterval(flushTimer);
-			flushTimer = null;
+	sink[Symbol.dispose] = () => {
+		if (fd !== null) {
+			flushBuffer();
+			options.closeSync(fd);
 		}
-		await flushBuffer();
-		if (fd !== null) try {
-			await asyncOptions.close(fd);
-		} catch {}
-		bufferPool.clear();
 	};
-	return nonBlockingSink;
+	return sink;
 }
+/**
+* Get a platform-independent rotating file sink.
+*
+* This sink writes log records to a file, and rotates the file when it reaches
+* the `maxSize`.  The rotated files are named with the original file name
+* followed by a dot and a number, starting from 1.  The number is incremented
+* for each rotation, and the maximum number of files to keep is `maxFiles`.
+*
+* @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.
+*/
 function getBaseRotatingFileSink(path, options) {
 	const formatter = options.formatter ?? __logtape_logtape.defaultTextFormatter;
 	const encoder = options.encoder ?? new TextEncoder();
@@ -314,7 +70,6 @@ function getBaseRotatingFileSink(path, options) {
 	} catch {}
 	let fd = options.openSync(path);
 	let lastFlushTimestamp = Date.now();
-	let buffer = "";
 	function shouldRollover(bytes) {
 		return offset + bytes.length > maxSize;
 	}
@@ -331,79 +86,29 @@ function getBaseRotatingFileSink(path, options) {
 		offset = 0;
 		fd = options.openSync(path);
 	}
-	if (!options.nonBlocking) {
-		function flushBuffer$1() {
-			if (buffer.length > 0) {
-				const bytes = encoder.encode(buffer);
-				buffer = "";
-				if (shouldRollover(bytes)) performRollover();
-				options.writeSync(fd, bytes);
-				options.flushSync(fd);
-				offset += bytes.length;
-				lastFlushTimestamp = Date.now();
-			}
-		}
-		const sink = (record) => {
-			buffer += formatter(record);
-			const shouldFlushBySize = buffer.length >= bufferSize;
-			const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
-			if (shouldFlushBySize || shouldFlushByTime) flushBuffer$1();
-		};
-		sink[Symbol.dispose] = () => {
-			flushBuffer$1();
-			options.closeSync(fd);
-		};
-		return sink;
-	}
-	const asyncOptions = options;
-	let disposed = false;
-	let activeFlush = null;
-	let flushTimer = null;
-	async function flushBuffer() {
-		if (buffer.length === 0) return;
-		const data = buffer;
-		buffer = "";
-		try {
-			const bytes = encoder.encode(data);
+	function flushBuffer() {
+		if (buffer.length > 0) {
+			const bytes = encoder.encode(buffer);
+			buffer = "";
 			if (shouldRollover(bytes)) performRollover();
-			asyncOptions.writeSync(fd, bytes);
-			await asyncOptions.flush(fd);
+			options.writeSync(fd, bytes);
+			options.flushSync(fd);
 			offset += bytes.length;
 			lastFlushTimestamp = Date.now();
-		} catch {}
-	}
-	function scheduleFlush() {
-		if (activeFlush || disposed) return;
-		activeFlush = flushBuffer().finally(() => {
-			activeFlush = null;
-		});
-	}
-	function startFlushTimer() {
-		if (flushTimer !== null || disposed) return;
-		flushTimer = setInterval(() => {
-			scheduleFlush();
-		}, flushInterval);
+		}
 	}
-	const nonBlockingSink = (record) => {
-		if (disposed) return;
+	let buffer = "";
+	const sink = (record) => {
 		buffer += formatter(record);
 		const shouldFlushBySize = buffer.length >= bufferSize;
 		const shouldFlushByTime = flushInterval > 0 && record.timestamp - lastFlushTimestamp >= flushInterval;
-		if (shouldFlushBySize || shouldFlushByTime) scheduleFlush();
-		else if (flushTimer === null && flushInterval > 0) startFlushTimer();
+		if (shouldFlushBySize || shouldFlushByTime) flushBuffer();
 	};
-	nonBlockingSink[Symbol.asyncDispose] = async () => {
-		disposed = true;
-		if (flushTimer !== null) {
-			clearInterval(flushTimer);
-			flushTimer = null;
-		}
-		await flushBuffer();
-		try {
-			await asyncOptions.close(fd);
-		} catch {}
+	sink[Symbol.dispose] = () => {
+		flushBuffer();
+		options.closeSync(fd);
 	};
-	return nonBlockingSink;
+	return sink;
 }
 
 //#endregion

package/dist/filesink.base.d.cts

@@ -26,15 +26,6 @@ type FileSinkOptions = StreamSinkOptions & {
    * @since 0.12.0
    */
   flushInterval?: number;
-  /**
-   * Enable non-blocking mode with background flushing.
-   * When enabled, flush operations are performed asynchronously to prevent
-   * blocking the main thread during file I/O operations.
-   *
-   * @default `false`
-   * @since 1.0.0
-   */
-  nonBlocking?: boolean;
 };
 /**
  * A platform-specific file sink driver.
@@ -52,13 +43,6 @@ interface FileSinkDriver<TFile> {
    * @param chunk The data to write.
    */
   writeSync(fd: TFile, chunk: Uint8Array): void;
-  /**
-   * Write multiple chunks of data to the file in a single operation.
-   * This is optional - if not implemented, falls back to multiple writeSync calls.
-   * @param fd The file descriptor.
-   * @param chunks Array of data chunks to write.
-   */
-  writeManySync?(fd: TFile, chunks: Uint8Array[]): void;
   /**
    * Flush the file to ensure that all data is written to the disk.
    * @param fd The file descriptor.
@@ -70,30 +54,6 @@ interface FileSinkDriver<TFile> {
    */
   closeSync(fd: TFile): void;
 }
-/**
- * A platform-specific async file sink driver.
- * @typeParam TFile The type of the file descriptor.
- * @since 1.0.0
- */
-interface AsyncFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
-  /**
-   * Asynchronously write multiple chunks of data to the file in a single operation.
-   * This is optional - if not implemented, falls back to multiple writeSync calls.
-   * @param fd The file descriptor.
-   * @param chunks Array of data chunks to write.
-   */
-  writeMany?(fd: TFile, chunks: Uint8Array[]): Promise<void>;
-  /**
-   * Asynchronously flush the file to ensure that all data is written to the disk.
-   * @param fd The file descriptor.
-   */
-  flush(fd: TFile): Promise<void>;
-  /**
-   * Asynchronously close the file.
-   * @param fd The file descriptor.
-   */
-  close(fd: TFile): Promise<void>;
-}
 /**
  * Get a platform-independent file sink.
  *
@@ -101,8 +61,7 @@ interface AsyncFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
  * @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.
  */
 
 /**
@@ -137,26 +96,6 @@ interface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
    */
   renameSync(oldPath: string, newPath: string): void;
 }
-/**
- * A platform-specific async rotating file sink driver.
- * @since 1.0.0
- */
-interface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<TFile> {
-  /**
-   * Get the size of the file.
-   * @param path A path to the file.
-   * @returns The `size` of the file in bytes, in an object.
-   */
-  statSync(path: string): {
-    size: number;
-  };
-  /**
-   * Rename a file.
-   * @param oldPath A path to the file to rename.
-   * @param newPath A path to be renamed to.
-   */
-  renameSync(oldPath: string, newPath: string): void;
-}
 /**
  * Get a platform-independent rotating file sink.
  *
@@ -168,9 +107,8 @@ interface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<TFile>
  * @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.
  */
 //#endregion
-export { AsyncRotatingFileSinkDriver, FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };
+export { FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };
 //# sourceMappingURL=filesink.base.d.cts.map

package/dist/filesink.base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.d.cts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAqQA;AAuCiB,KAvCL,eAAA,GAAkB,iBAuCC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;;;AAoBnB;AAQrB;;EAAoC,UAA+B,CAAA,EAAA,MAAA;EAAK;;;;;;;EAmB7C,aAnByB,CAAA,EAAA,MAAA;EAAc;AAgQlE;;;;AAAqD;AAerD;;EAAuC,WAA+B,CAAA,EAAA,OAAA;CAAK;AAAN;AAoBrE;;;AACU,UA5UO,cA4UP,CAAA,KAAA,CAAA,CAAA;EAAmB;;;;0BAvUH;;;;;;gBAOV,cAAc;;;;;;;qBAQT,eAAe;;;;;gBAMpB;;;;;gBAMA;;;;;;;UAQC,mCAAmC,eAAe;;;;;;;iBAOlD,eAAe,eAAe;;;;;YAMnC,QAAQ;;;;;YAMR,QAAQ;;;;;;;;;;;;;;;;UA6OH,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe;;;;;;;;;;;;;;;;;;;;UAoBrD,2CACP,oBAAoB"}
+{"version":3,"file":"filesink.base.d.cts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AA6BiB,KA7BL,eAAA,GAAkB,iBA6BC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;AAYnB;AA0DrB;;;;EAAqD,UAAA,CAAA,EAAA,MAAA;EAepC;;;;AAAoD;;;;;;;;;UAjGpD;;;;;0BAKS;;;;;;gBAOV,cAAc;;;;;gBAMd;;;;;gBAMA;;;;;;;;;;;;;;;UA0DC,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe"}

package/dist/filesink.base.d.ts

@@ -26,15 +26,6 @@ type FileSinkOptions = StreamSinkOptions & {
    * @since 0.12.0
    */
   flushInterval?: number;
-  /**
-   * Enable non-blocking mode with background flushing.
-   * When enabled, flush operations are performed asynchronously to prevent
-   * blocking the main thread during file I/O operations.
-   *
-   * @default `false`
-   * @since 1.0.0
-   */
-  nonBlocking?: boolean;
 };
 /**
  * A platform-specific file sink driver.
@@ -52,13 +43,6 @@ interface FileSinkDriver<TFile> {
    * @param chunk The data to write.
    */
   writeSync(fd: TFile, chunk: Uint8Array): void;
-  /**
-   * Write multiple chunks of data to the file in a single operation.
-   * This is optional - if not implemented, falls back to multiple writeSync calls.
-   * @param fd The file descriptor.
-   * @param chunks Array of data chunks to write.
-   */
-  writeManySync?(fd: TFile, chunks: Uint8Array[]): void;
   /**
    * Flush the file to ensure that all data is written to the disk.
    * @param fd The file descriptor.
@@ -70,30 +54,6 @@ interface FileSinkDriver<TFile> {
    */
   closeSync(fd: TFile): void;
 }
-/**
- * A platform-specific async file sink driver.
- * @typeParam TFile The type of the file descriptor.
- * @since 1.0.0
- */
-interface AsyncFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
-  /**
-   * Asynchronously write multiple chunks of data to the file in a single operation.
-   * This is optional - if not implemented, falls back to multiple writeSync calls.
-   * @param fd The file descriptor.
-   * @param chunks Array of data chunks to write.
-   */
-  writeMany?(fd: TFile, chunks: Uint8Array[]): Promise<void>;
-  /**
-   * Asynchronously flush the file to ensure that all data is written to the disk.
-   * @param fd The file descriptor.
-   */
-  flush(fd: TFile): Promise<void>;
-  /**
-   * Asynchronously close the file.
-   * @param fd The file descriptor.
-   */
-  close(fd: TFile): Promise<void>;
-}
 /**
  * Get a platform-independent file sink.
  *
@@ -101,8 +61,7 @@ interface AsyncFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
  * @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.
  */
 
 /**
@@ -137,26 +96,6 @@ interface RotatingFileSinkDriver<TFile> extends FileSinkDriver<TFile> {
    */
   renameSync(oldPath: string, newPath: string): void;
 }
-/**
- * A platform-specific async rotating file sink driver.
- * @since 1.0.0
- */
-interface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<TFile> {
-  /**
-   * Get the size of the file.
-   * @param path A path to the file.
-   * @returns The `size` of the file in bytes, in an object.
-   */
-  statSync(path: string): {
-    size: number;
-  };
-  /**
-   * Rename a file.
-   * @param oldPath A path to the file to rename.
-   * @param newPath A path to be renamed to.
-   */
-  renameSync(oldPath: string, newPath: string): void;
-}
 /**
  * Get a platform-independent rotating file sink.
  *
@@ -168,9 +107,8 @@ interface AsyncRotatingFileSinkDriver<TFile> extends AsyncFileSinkDriver<TFile>
  * @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.
  */
 //#endregion
-export { AsyncRotatingFileSinkDriver, FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };
+export { FileSinkDriver, FileSinkOptions, RotatingFileSinkDriver, RotatingFileSinkOptions };
 //# sourceMappingURL=filesink.base.d.ts.map

package/dist/filesink.base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filesink.base.d.ts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAqQA;AAuCiB,KAvCL,eAAA,GAAkB,iBAuCC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;;;AAoBnB;AAQrB;;EAAoC,UAA+B,CAAA,EAAA,MAAA;EAAK;;;;;;;EAmB7C,aAnByB,CAAA,EAAA,MAAA;EAAc;AAgQlE;;;;AAAqD;AAerD;;EAAuC,WAA+B,CAAA,EAAA,OAAA;CAAK;AAAN;AAoBrE;;;AACU,UA5UO,cA4UP,CAAA,KAAA,CAAA,CAAA;EAAmB;;;;0BAvUH;;;;;;gBAOV,cAAc;;;;;;;qBAQT,eAAe;;;;;gBAMpB;;;;;gBAMA;;;;;;;UAQC,mCAAmC,eAAe;;;;;;;iBAOlD,eAAe,eAAe;;;;;YAMnC,QAAQ;;;;;YAMR,QAAQ;;;;;;;;;;;;;;;;UA6OH,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe;;;;;;;;;;;;;;;;;;;;UAoBrD,2CACP,oBAAoB"}
+{"version":3,"file":"filesink.base.d.ts","names":[],"sources":["../filesink.base.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;AA6BiB,KA7BL,eAAA,GAAkB,iBA6BC,GAAA;EAAA;;;EAYV,IAAS,CAAA,EAAA,OAAA;EAAU;;AAYnB;AA0DrB;;;;EAAqD,UAAA,CAAA,EAAA,MAAA;EAepC;;;;AAAoD;;;;;;;;;UAjGpD;;;;;0BAKS;;;;;;gBAOV,cAAc;;;;;gBAMd;;;;;gBAMA;;;;;;;;;;;;;;;UA0DC,uBAAA,SAAgC,KAAK;;;;;;;;;;;;;UAerC,sCAAsC,eAAe"}