readline-pager 0.4.10 → 0.6.2

package/dist/main.mjs

@@ -6,7 +6,7 @@ import { Worker } from "node:worker_threads";
 //#region \0rolldown/runtime.js
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
-//#region src/queue.ts
+//#region src/helper.ts
 function createRingBuffer(capacity) {
 	if (!Number.isFinite(capacity) || capacity <= 0) throw new RangeError("capacity must be a positive number");
 	let buf = new Array(capacity);
@@ -102,115 +102,99 @@ function createBackwardReader(filepath, options) {
 	let buffer = "";
 	let done = false;
 	let closed = false;
+	let flushed = false;
 	let startsWithDelimiter = false;
+	function consumeBuffer() {
+		let idx;
+		while ((idx = buffer.lastIndexOf(delimiter)) !== -1) {
+			const line = buffer.slice(idx + delimiter.length);
+			buffer = buffer.slice(0, idx);
+			local.push(line);
+			while (local.length >= pageSize) pageQueue.push(local.splice(0, pageSize));
+		}
+	}
+	function flushTail() {
+		if (flushed) return;
+		flushed = true;
+		if (buffer.length > 0) local.push(buffer);
+		else if (startsWithDelimiter) local.push("");
+		buffer = "";
+		while (local.length > 0) {
+			const page = local.slice(local.length - Math.min(pageSize, local.length));
+			local.length -= page.length;
+			pageQueue.push(page);
+		}
+		done = true;
+		pageQueue.wake();
+	}
 	fdSync = openSync(filepath, "r");
 	pos = statSync(filepath).size;
 	if (pos === 0) {
-		pageQueue.push([buffer]);
+		pageQueue.push([""]);
 		done = true;
+		flushed = true;
 		pageQueue.wake();
 	}
 	(async () => {
-		try {
-			fd = await open(filepath, "r");
-			pos = (await fd.stat()).size;
-			if (pos === 0) {
-				if (!done) {
-					pageQueue.push([buffer]);
-					done = true;
-				}
-				if (fd) {
-					await fd.close();
-					fd = null;
-				}
-				pageQueue.wake();
-				return;
+		fd = await open(filepath, "r");
+		pos = (await fd.stat()).size;
+		if (pos === 0) {
+			if (!done) {
+				pageQueue.push([""]);
+				done = true;
+				flushed = true;
 			}
-			while (!done && !closed) {
-				while (pageQueue.count < prefetch && pos > 0 && !closed) {
-					const readSize = Math.min(chunkSize, pos);
-					pos -= readSize;
-					const buf = Buffer.allocUnsafe(readSize);
-					await fd.read(buf, 0, readSize, pos);
-					buffer = buf.toString("utf8") + buffer;
-					if (pos === 0 && buffer.startsWith(delimiter)) startsWithDelimiter = true;
-					let idx;
-					while ((idx = buffer.lastIndexOf(delimiter)) !== -1) {
-						const line = buffer.slice(idx + delimiter.length);
-						buffer = buffer.slice(0, idx);
-						local.push(line);
-						while (local.length >= pageSize) {
-							const page = local.splice(0, pageSize);
-							pageQueue.push(page);
-						}
-					}
-				}
-				if (pos === 0 && !done) {
-					if (buffer.length > 0) local.push(buffer);
-					else if (startsWithDelimiter) local.push("");
-					buffer = "";
-					while (local.length > 0 && !closed) {
-						const page = local.slice(local.length - Math.min(pageSize, local.length));
-						local.length -= page.length;
-						pageQueue.push(page);
-					}
-					done = true;
-					if (fd) {
-						await fd.close();
-						fd = null;
-					}
-					pageQueue.wake();
-					break;
-				}
-				if (!done && !closed) await new Promise((r) => setImmediate(r));
+			if (fd) {
+				try {
+					await fd.close();
+				} catch {}
+				fd = null;
 			}
-		} catch {
-			done = true;
 			pageQueue.wake();
-			try {
+			return;
+		}
+		while (!done && !closed) {
+			while (pageQueue.count < prefetch && pos > 0 && !closed) {
+				const readSize = Math.min(chunkSize, pos);
+				pos -= readSize;
+				const buf = Buffer.allocUnsafe(readSize);
+				const { bytesRead } = await fd.read(buf, 0, readSize, pos);
+				buffer = buf.toString("utf8", 0, bytesRead) + buffer;
+				if (pos === 0 && buffer.startsWith(delimiter)) startsWithDelimiter = true;
+				consumeBuffer();
+			}
+			if (pos === 0 && !flushed) {
+				flushTail();
 				if (fd) {
-					await fd.close();
+					try {
+						await fd.close();
+					} catch {}
 					fd = null;
 				}
-			} catch {}
+				break;
+			}
+			if (!done && !closed) await new Promise((r) => setImmediate(r));
 		}
 	})();
 	function fillSync() {
-		if (done || closed) return;
-		if (fdSync === null) return;
+		if (done || closed || !fdSync) return;
 		while (pageQueue.count < prefetch && pos > 0 && !closed) {
 			const readSize = Math.min(chunkSize, pos);
 			pos -= readSize;
 			const buf = Buffer.allocUnsafe(readSize);
-			readSync(fdSync, buf, 0, readSize, pos);
-			buffer = buf.toString("utf8") + buffer;
+			const bytesRead = readSync(fdSync, buf, 0, readSize, pos);
+			buffer = buf.toString("utf8", 0, bytesRead) + buffer;
 			if (pos === 0 && buffer.startsWith(delimiter)) startsWithDelimiter = true;
-			let idx;
-			while ((idx = buffer.lastIndexOf(delimiter)) !== -1) {
-				const line = buffer.slice(idx + delimiter.length);
-				buffer = buffer.slice(0, idx);
-				local.push(line);
-				while (local.length >= pageSize) {
-					const page = local.splice(0, pageSize);
-					pageQueue.push(page);
-				}
-			}
+			consumeBuffer();
 		}
-		if (pos === 0 && !done) {
-			if (buffer.length > 0) local.push(buffer);
-			else if (startsWithDelimiter) local.push("");
-			buffer = "";
-			while (local.length > 0) {
-				const page = local.slice(local.length - Math.min(pageSize, local.length));
-				local.length -= page.length;
-				pageQueue.push(page);
-			}
-			done = true;
-			if (fdSync !== null) {
-				closeSync(fdSync);
+		if (pos === 0 && !flushed) {
+			flushTail();
+			if (fdSync) {
+				try {
+					closeSync(fdSync);
+				} catch {}
 				fdSync = null;
 			}
-			pageQueue.wake();
 		}
 	}
 	async function next() {
@@ -223,20 +207,21 @@ function createBackwardReader(filepath, options) {
 		return pageQueue.shiftSync();
 	}
 	async function close() {
+		if (closed) return;
 		closed = true;
 		done = true;
 		pageQueue.clear();
-		if (fd) {
+		if (fdSync) {
 			try {
-				await fd.close();
+				closeSync(fdSync);
 			} catch {}
-			fd = null;
+			fdSync = null;
 		}
-		if (fdSync !== null) {
+		if (fd) {
 			try {
-				closeSync(fdSync);
+				await fd.close();
 			} catch {}
-			fdSync = null;
+			fd = null;
 		}
 	}
 	return {
@@ -265,14 +250,18 @@ function createBackwardReader(filepath, options) {
 				closed = true;
 				done = true;
 				pageQueue.clear();
-				try {
-					if (fdSync) closeSync(fdSync);
-				} catch {}
-				fdSync = null;
-				try {
-					if (fd?.fd) closeSync(fd.fd);
-				} catch {}
-				fd = null;
+				if (fdSync) {
+					try {
+						closeSync(fdSync);
+					} catch {}
+					fdSync = null;
+				}
+				if (fd?.fd) {
+					try {
+						closeSync(fd.fd);
+					} catch {}
+					fd = null;
+				}
 			}
 		}
 	};
@@ -291,106 +280,90 @@ function createForwardReader(filepath, options) {
 	let done = false;
 	let closed = false;
 	let flushed = false;
+	function consumeBuffer() {
+		let idx;
+		while ((idx = buffer.indexOf(delimiter)) !== -1) {
+			const line = buffer.slice(0, idx);
+			buffer = buffer.slice(idx + delimiter.length);
+			local.push(line);
+			while (local.length >= pageSize) pageQueue.push(local.splice(0, pageSize));
+		}
+	}
+	function flushTail() {
+		if (flushed) return;
+		flushed = true;
+		local.push(buffer.length > 0 ? buffer : "");
+		buffer = "";
+		while (local.length > 0) pageQueue.push(local.splice(0, pageSize));
+		done = true;
+		pageQueue.wake();
+	}
 	fdSync = openSync(filepath, "r");
 	size = statSync(filepath).size;
 	if (size === 0) {
-		pageQueue.push([buffer]);
+		pageQueue.push([""]);
 		done = true;
+		flushed = true;
 		pageQueue.wake();
 	}
 	(async () => {
-		try {
-			fd = await open(filepath, "r");
-			size = (await fd.stat()).size;
-			if (size === 0) {
-				if (!done) {
-					pageQueue.push([buffer]);
-					done = true;
-				}
-				if (fd) {
-					await fd.close();
-					fd = null;
-				}
-				pageQueue.wake();
-				return;
+		fd = await open(filepath, "r");
+		size = (await fd.stat()).size;
+		if (size === 0) {
+			if (!done) {
+				pageQueue.push([""]);
+				done = true;
+				flushed = true;
 			}
-			while (!done && !closed) {
-				while (pageQueue.count < prefetch && pos < size && !closed) {
-					const readSize = Math.min(chunkSize, size - pos);
-					const buf = Buffer.allocUnsafe(readSize);
-					const { bytesRead } = await fd.read(buf, 0, readSize, pos);
-					pos += bytesRead;
-					buffer = buffer + buf.toString("utf8", 0, bytesRead);
-					let idx;
-					while ((idx = buffer.indexOf(delimiter)) !== -1) {
-						const line = buffer.slice(0, idx);
-						buffer = buffer.slice(idx + delimiter.length);
-						local.push(line);
-						while (local.length >= pageSize) pageQueue.push(local.splice(0, pageSize));
-					}
-				}
-				if (pos >= size && !flushed) {
-					flushed = true;
-					local.push(buffer.length > 0 ? buffer : "");
-					buffer = "";
-					while (local.length > 0 && !closed) {
-						const page = local.slice(0, pageSize);
-						local.length -= page.length;
-						pageQueue.push(page);
-					}
-					done = true;
-					if (fd) {
-						await fd.close();
-						fd = null;
-					}
-					pageQueue.wake();
-					break;
-				}
-				if (!done && !closed) await new Promise((r) => setImmediate(r));
+			if (fd) {
+				try {
+					await fd.close();
+				} catch {}
+				fd = null;
 			}
-		} catch {
-			done = true;
 			pageQueue.wake();
-			try {
+			return;
+		}
+		while (!done && !closed) {
+			while (pageQueue.count < prefetch && pos < size && !closed) {
+				const readSize = Math.min(chunkSize, size - pos);
+				const buf = Buffer.allocUnsafe(readSize);
+				const { bytesRead } = await fd.read(buf, 0, readSize, pos);
+				pos += bytesRead;
+				buffer = buffer + buf.toString("utf8", 0, bytesRead);
+				consumeBuffer();
+			}
+			if (pos >= size && !flushed) {
+				flushTail();
 				if (fd) {
-					await fd.close();
+					try {
+						await fd.close();
+					} catch {}
 					fd = null;
 				}
-			} catch {}
+				break;
+			}
+			if (!done && !closed) await new Promise((r) => setImmediate(r));
 		}
 	})();
 	function fillSync() {
-		if (done || closed) return;
-		if (fdSync === null) return;
+		if (done || closed || !fdSync) return;
 		while (pageQueue.count < prefetch && pos < size && !closed) {
 			const readSize = Math.min(chunkSize, size - pos);
 			const buf = Buffer.allocUnsafe(readSize);
 			const bytesRead = readSync(fdSync, buf, 0, readSize, pos);
 			pos += bytesRead;
 			buffer = buffer + buf.toString("utf8", 0, bytesRead);
-			let idx;
-			while ((idx = buffer.indexOf(delimiter)) !== -1) {
-				const line = buffer.slice(0, idx);
-				buffer = buffer.slice(idx + delimiter.length);
-				local.push(line);
-				while (local.length >= pageSize) pageQueue.push(local.splice(0, pageSize));
-			}
+			consumeBuffer();
 		}
 		if (pos >= size && !flushed) {
-			flushed = true;
-			local.push(buffer.length > 0 ? buffer : "");
-			buffer = "";
-			while (local.length > 0) {
-				const page = local.slice(0, pageSize);
-				local.length -= page.length;
-				pageQueue.push(page);
-			}
-			done = true;
-			if (fdSync !== null) {
-				closeSync(fdSync);
+			flushTail();
+			if (fdSync) {
+				try {
+					closeSync(fdSync);
+				} catch {}
 				fdSync = null;
 			}
-			pageQueue.wake();
 		}
 	}
 	async function next() {
@@ -403,20 +376,21 @@ function createForwardReader(filepath, options) {
 		return pageQueue.shiftSync();
 	}
 	async function close() {
+		if (closed) return;
 		closed = true;
 		done = true;
 		pageQueue.clear();
-		if (fd) {
+		if (fdSync) {
 			try {
-				await fd.close();
+				closeSync(fdSync);
 			} catch {}
-			fd = null;
+			fdSync = null;
 		}
-		if (fdSync !== null) {
+		if (fd) {
 			try {
-				closeSync(fdSync);
+				await fd.close();
 			} catch {}
-			fdSync = null;
+			fd = null;
 		}
 	}
 	return {
@@ -445,14 +419,18 @@ function createForwardReader(filepath, options) {
 				closed = true;
 				done = true;
 				pageQueue.clear();
-				try {
-					if (fdSync !== null) closeSync(fdSync);
-				} catch {}
-				fdSync = null;
-				try {
-					if (fd?.fd) closeSync(fd.fd);
-				} catch {}
-				fd = null;
+				if (fdSync) {
+					try {
+						closeSync(fdSync);
+					} catch {}
+					fdSync = null;
+				}
+				if (fd?.fd) {
+					try {
+						closeSync(fd.fd);
+					} catch {}
+					fd = null;
+				}
 			}
 		}
 	};
@@ -462,18 +440,23 @@ function createForwardReader(filepath, options) {
 const workerFile = typeof import.meta !== "undefined" ? new URL("./worker.mjs", import.meta.url) : __require.resolve("./worker.cjs");
 function createWorkerReader(filepath, options) {
 	const { prefetch } = options;
-	const pageQueue = createRingBuffer(Math.max(2, prefetch + 1));
 	let done = false;
 	let closed = false;
+	const pageQueue = createRingBuffer(Math.max(2, prefetch + 1));
 	const worker = new Worker(new URL(workerFile, import.meta.url), { workerData: {
 		filepath,
 		options
 	} });
 	worker.on("message", (msg) => {
-		if (msg.type === "page") pageQueue.push(msg.data);
-		if (msg.type === "done") {
-			done = true;
-			pageQueue.wake();
+		switch (msg.type) {
+			case "page":
+				pageQueue.push(msg.data);
+				break;
+			case "done":
+			case "error":
+				done = true;
+				pageQueue.wake();
+				break;
 		}
 	});
 	worker.on("error", () => {
@@ -493,10 +476,13 @@ function createWorkerReader(filepath, options) {
 		return pageQueue.shiftSync();
 	}
 	async function close() {
+		if (closed) return;
 		closed = true;
 		done = true;
 		pageQueue.clear();
-		await worker.terminate();
+		try {
+			await worker.terminate();
+		} catch {}
 	}
 	function tryClose() {
 		close().catch(() => {});
@@ -532,18 +518,35 @@ function createWorkerReader(filepath, options) {
 //#endregion
 //#region src/main.ts
 function createPager(filepath, options = {}) {
-	const { chunkSize = 64 * 1024, pageSize = 1e3, delimiter = "\n", prefetch = 8, backward = false, useWorker = false } = options;
+	const { chunkSize = 64 * 1024, pageSize = 1e3, delimiter = "\n", prefetch = 8, backward = false, useWorker = false, tryNative = true } = options;
 	if (!filepath) throw new Error("filepath required");
 	if (pageSize < 1) throw new RangeError("pageSize must be >= 1");
 	if (prefetch < 1) throw new RangeError("prefetch must be >= 1");
-	if (backward && useWorker) throw new Error("backward not supported with useWorker");
+	if (useWorker) {
+		if (backward) throw new Error("backward not supported with useWorker");
+		if (tryNative) throw new Error("tryNative not supported with useWorker");
+	}
+	if (tryNative) {
+		if (delimiter.length !== 1) throw new RangeError("native reader only supports single-character delimiters");
+	}
 	const _options = {
 		chunkSize,
 		pageSize,
 		prefetch,
 		delimiter
 	};
-	const reader = useWorker ? createWorkerReader(filepath, _options) : backward ? createBackwardReader(filepath, _options) : createForwardReader(filepath, _options);
+	let nativeReader;
+	if (tryNative) {
+		const _nativeOptions = {
+			pageSize,
+			delimiter,
+			backward
+		};
+		try {
+			nativeReader = createNativePager(filepath, _nativeOptions);
+		} catch {}
+	}
+	const reader = tryNative && nativeReader ? nativeReader : useWorker ? createWorkerReader(filepath, _options) : backward ? createBackwardReader(filepath, _options) : createForwardReader(filepath, _options);
 	if (process.env.TEST_CLEANUPS) {
 		globalThis.__test_cleanups__ ??= [];
 		globalThis.__test_cleanups__.push(reader.close);

package/dist/native-DGzYrMHK.d.mts

@@ -0,0 +1,46 @@
+//#region src/types.d.ts
+interface ReaderOptions {
+  chunkSize: number;
+  pageSize: number;
+  delimiter: string;
+  prefetch: number;
+}
+interface PagerOptions extends Partial<ReaderOptions> {
+  backward?: boolean;
+  useWorker?: boolean;
+  tryNative?: boolean;
+}
+interface NativeReaderOptions {
+  pageSize: number;
+  delimiter: string;
+  backward: boolean;
+}
+type WorkerMessage = {
+  type: "page";
+  data: string[];
+} | {
+  type: "error";
+  error: unknown;
+} | {
+  type: "done";
+};
+type AddonFD = object | null;
+type AddonData = Buffer | null;
+interface NativeAddon {
+  open: (filepath: string, pageSize: number, delimiter: string, backward: boolean) => AddonFD;
+  next: (fd: AddonFD) => Promise<AddonData>;
+  nextSync: (fd: AddonFD) => AddonData;
+  close: (fd: AddonFD) => Promise<void>;
+}
+interface Pager {
+  next(): Promise<string[] | null>;
+  nextSync(): string[] | null;
+  close(): Promise<void>;
+  [Symbol.asyncIterator](): AsyncIterator<string[]>;
+  [Symbol.iterator](): Iterator<string[]>;
+}
+//#endregion
+//#region src/native.d.ts
+declare function createNativePager(filepath: string, options?: Partial<NativeReaderOptions>): Pager;
+//#endregion
+export { PagerOptions as a, Pager as i, NativeAddon as n, ReaderOptions as o, NativeReaderOptions as r, WorkerMessage as s, createNativePager as t };

package/dist/native-_NmVYcF6.d.cts

@@ -0,0 +1,46 @@
+//#region src/types.d.ts
+interface ReaderOptions {
+  chunkSize: number;
+  pageSize: number;
+  delimiter: string;
+  prefetch: number;
+}
+interface PagerOptions extends Partial<ReaderOptions> {
+  backward?: boolean;
+  useWorker?: boolean;
+  tryNative?: boolean;
+}
+interface NativeReaderOptions {
+  pageSize: number;
+  delimiter: string;
+  backward: boolean;
+}
+type WorkerMessage = {
+  type: "page";
+  data: string[];
+} | {
+  type: "error";
+  error: unknown;
+} | {
+  type: "done";
+};
+type AddonFD = object | null;
+type AddonData = Buffer | null;
+interface NativeAddon {
+  open: (filepath: string, pageSize: number, delimiter: string, backward: boolean) => AddonFD;
+  next: (fd: AddonFD) => Promise<AddonData>;
+  nextSync: (fd: AddonFD) => AddonData;
+  close: (fd: AddonFD) => Promise<void>;
+}
+interface Pager {
+  next(): Promise<string[] | null>;
+  nextSync(): string[] | null;
+  close(): Promise<void>;
+  [Symbol.asyncIterator](): AsyncIterator<string[]>;
+  [Symbol.iterator](): Iterator<string[]>;
+}
+//#endregion
+//#region src/native.d.ts
+declare function createNativePager(filepath: string, options?: Partial<NativeReaderOptions>): Pager;
+//#endregion
+export { PagerOptions as a, Pager as i, NativeAddon as n, ReaderOptions as o, NativeReaderOptions as r, WorkerMessage as s, createNativePager as t };

package/dist/native.cjs

@@ -29,36 +29,39 @@ function loadNativeAddon() {
 		throw new Error(UNAVAILABLE);
 	}
 }
-function createNativePager(filepath, { pageSize = 1e3, delimiter = "\n" } = {}) {
-	const pagerNative = loadNativeAddon();
-	let fd = null;
+function createNativePager(filepath, options) {
+	const { pageSize = 1e3, delimiter = "\n", backward = false } = options ?? {};
+	if (!filepath) throw new Error("filepath required");
+	if (pageSize < 1) throw new RangeError("pageSize must be >= 1");
+	if (delimiter.length !== 1) throw new RangeError("native reader only supports single-character delimiters");
+	const nativePager = loadNativeAddon();
+	let fd = nativePager.open(filepath, pageSize, delimiter, backward);
 	let closed = false;
-	const init = () => {
-		fd = pagerNative.open(filepath, pageSize, delimiter);
-	};
 	const next = async () => {
 		if (closed || !fd) return null;
-		const data = await pagerNative.next(fd);
+		const data = await nativePager.next(fd);
 		if (!data) return null;
 		return data.toString("utf8").split(delimiter);
 	};
 	const nextSync = () => {
 		if (closed || !fd) return null;
-		const data = pagerNative.nextSync(fd);
+		const data = nativePager.nextSync(fd);
 		if (!data) return null;
 		return data.toString("utf8").split(delimiter);
 	};
 	const close = async () => {
-		if (!closed || fd) {
-			closed = true;
-			await pagerNative.close(fd);
+		if (closed) return;
+		closed = true;
+		if (fd) {
+			try {
+				await nativePager.close(fd);
+			} catch {}
 			fd = null;
 		}
 	};
 	function tryClose() {
 		close().catch(() => {});
 	}
-	init();
 	return {
 		next,
 		nextSync,

package/dist/native.d.cts

@@ -1,2 +1,2 @@
-import { t as createNativePager } from "./native-BNwCco1j.cjs";
+import { t as createNativePager } from "./native-_NmVYcF6.cjs";
 export { createNativePager };