@yorozu/utils 0.3.1 → 0.5.1

package/arrays/u8/misc.d.ts

@@ -1,3 +1,3 @@
-export declare const empty: Uint8Array;
+export declare const empty: Uint8Array<ArrayBuffer>;
 export declare function clone(buf: Uint8Array): Uint8Array;
 export declare function readNthBit(byte: number, bit: number): number;

package/async/async-queue.d.ts

@@ -1,9 +1,15 @@
 import { Deque } from '../structures';
 import { Deferred } from './deferred';
+type WaitResult<T> = {
+    done: true;
+} | {
+    done: false;
+    value: T;
+};
 export declare class AsyncQueue<T> {
     readonly queue: Deque<T>;
     readonly maxSize: number | undefined;
-    protected _consumerWaiters: Deque<Deferred<T | undefined>>;
+    protected _consumerWaiters: Deque<Deferred<WaitResult<T>>>;
     protected _producerWaiters: Deque<Deferred<void>>;
     protected _ended: boolean;
     constructor(from?: ArrayLike<T> | Deque<T>, maxSize?: number);
@@ -18,5 +24,7 @@ export declare class AsyncQueue<T> {
     next(): T | undefined;
     nextOrWait(): Promise<T | undefined>;
     [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+    protected _waitForItem(): Promise<WaitResult<T>>;
     protected _wakeProducerIfNeeded(): void;
 }
+export {};

package/async/index.d.ts

@@ -7,5 +7,6 @@ export * from './condition-variable';
 export * from './deferred';
 export * from './emitter';
 export * from './pool';
+export * from './priority-work-queue';
 export * from './sleep';
 export { timers };

package/async/priority-work-queue.d.ts

@@ -0,0 +1,25 @@
+export type WorkPri = "visible" | "preload" | "background";
+export type PriorityWorkJob = {
+    id: string;
+    pri: WorkPri;
+    run: (ctx: {
+        signal: AbortSignal;
+    }) => Promise<void>;
+};
+export type PriorityWorkQueueStats = {
+    active: number;
+    queued: number;
+    maxActive: number;
+};
+export type PriorityWorkQueueOptions = {
+    concurrency?: number;
+    onError?: (error: Error, id: string) => void;
+};
+export type PriorityWorkQueue = {
+    enqueue(job: PriorityWorkJob): boolean;
+    cancel(id: string): boolean;
+    cancelAll(): void;
+    isBusy(id: string): boolean;
+    get stats(): PriorityWorkQueueStats;
+};
+export declare function createPriorityWorkQueue(opts?: PriorityWorkQueueOptions): PriorityWorkQueue;

package/compress/tables.d.ts

@@ -0,0 +1,10 @@
+export declare const fixedLengthExtraBits: Uint8Array;
+export declare const fixedDistanceExtraBits: Uint8Array;
+export declare const codeLengthOrder: Uint8Array;
+export declare const lengthBase: Uint16Array;
+export declare const lengthReverse: Int32Array;
+export declare const distanceBase: Uint16Array;
+export declare const distanceReverse: Int32Array;
+export declare const reverseBits15: Uint16Array;
+export declare const fixedLiteralLengths: Uint8Array;
+export declare const fixedDistanceLengths: Uint8Array;

package/index.js

@@ -44,9 +44,14 @@ function lastIndexOf(haystack, needle, start = haystack.length - 1) {
 	return -1;
 }
 function indexOfArray(haystack, needle, start = 0) {
+	let length = haystack.length;
+	if (start < 0) {
+		start += length;
+		if (start < 0) start = 0;
+	}
 	if (needle.length === 0) return start;
 	if (needle.length === 1) return indexOf(haystack, needle[0], start);
-	let max = haystack.length - needle.length;
+	let max = length - needle.length;
 	for (let i = start; i <= max; i++) if (haystack[i] === needle[0]) {
 		let j = 1;
 		for (; j < needle.length; j++) if (haystack[i + j] !== needle[j]) break;
@@ -55,9 +60,14 @@ function indexOfArray(haystack, needle, start = 0) {
 	return -1;
 }
 function lastIndexOfArray(haystack, needle, start = haystack.length - 1) {
+	let length = haystack.length;
+	if (start < 0) {
+		start += length;
+		if (start < 0) return -1;
+	} else if (start >= length) start = length - 1;
 	if (needle.length === 0) return start;
 	if (needle.length === 1) return lastIndexOf(haystack, needle[0], start);
-	let maxStart = haystack.length - needle.length;
+	let maxStart = length - needle.length;
 	let effectiveStart = start > maxStart ? maxStart : start;
 	for (let i = effectiveStart; i >= 0; i--) {
 		let j = 0;
@@ -1354,16 +1364,16 @@ var LruSet = class {
 var AsyncLock = class {
 	_queue = new Deque();
 	async acquire() {
-		let info;
-		while (info = this._queue.peekFront()) await info[0];
 		let unlock;
-		const promise = new Promise((resolve) => {
+		let promise = new Promise((resolve) => {
 			unlock = resolve;
 		});
+		let prev = this._queue.peekBack();
 		this._queue.pushBack([promise, unlock]);
+		if (prev) await prev[0];
 	}
 	release() {
-		const front = this._queue.popFront();
+		let front = this._queue.popFront();
 		if (!front) throw new Error("Nothing to release.", { cause: this._queue });
 		front[1]();
 	}
@@ -1458,7 +1468,10 @@ var AsyncQueue = class {
 		if (this._ended) throw new Error("Cannot enqueue after .end() has been called");
 		while (true) {
 			if (this._consumerWaiters.length > 0) {
-				this._consumerWaiters.popFront().resolve(item);
+				this._consumerWaiters.popFront().resolve({
+					done: false,
+					value: item
+				});
 				return;
 			}
 			if (!this.isFull) {
@@ -1474,7 +1487,10 @@ var AsyncQueue = class {
 	tryEnqueue(item) {
 		if (this._ended || this.isFull) return false;
 		if (this._consumerWaiters.length > 0) {
-			this._consumerWaiters.popFront().resolve(item);
+			this._consumerWaiters.popFront().resolve({
+				done: false,
+				value: item
+			});
 			return true;
 		}
 		this.queue.pushBack(item);
@@ -1483,7 +1499,7 @@ var AsyncQueue = class {
 	end() {
 		if (this._ended) throw new Error(".end() has already been called.");
 		this._ended = true;
-		for (let waiter of this._consumerWaiters) waiter.resolve(void 0);
+		for (let waiter of this._consumerWaiters) waiter.resolve({ done: true });
 		this._consumerWaiters.clear();
 		let err = /* @__PURE__ */ new Error("Queue has been ended.");
 		for (let waiter of this._producerWaiters) waiter.reject(err);
@@ -1505,27 +1521,40 @@ var AsyncQueue = class {
 			return item;
 		}
 		if (this._ended) return;
-		let waiter = new Deferred();
-		this._consumerWaiters.pushBack(waiter);
-		return waiter.promise;
+		let result = await this._waitForItem();
+		if (result.done) return void 0;
+		return result.value;
 	}
 	[Symbol.asyncIterator]() {
 		let iterator = {
 			[Symbol.asyncIterator]: () => iterator,
 			next: async () => {
-				let item = await this.nextOrWait();
-				if (item === void 0) return {
+				if (this.queue.length > 0) return {
+					value: this.next(),
+					done: false
+				};
+				if (this._ended) return {
+					done: true,
+					value: void 0
+				};
+				let result = await this._waitForItem();
+				if (result.done) return {
 					done: true,
 					value: void 0
 				};
 				return {
-					value: item,
+					value: result.value,
 					done: false
 				};
 			}
 		};
 		return iterator;
 	}
+	_waitForItem() {
+		let waiter = new Deferred();
+		this._consumerWaiters.pushBack(waiter);
+		return waiter.promise;
+	}
 	_wakeProducerIfNeeded() {
 		if (this._producerWaiters.length > 0 && !this.isFull) this._producerWaiters.popFront().resolve();
 	}
@@ -1774,26 +1803,6 @@ async function parallelMap(iterable, executor, options = {}) {
 	return result;
 }
 //#endregion
-//#region src/async/sleep.ts
-function sleep(ms, signal) {
-	if (ms < 0) throw new RangeError("sleep: ms must be a non-negative number");
-	return new Promise((resolve, reject) => {
-		if (signal?.aborted) {
-			reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
-			return;
-		}
-		let onAbort = () => {
-			clearTimeout(timeoutId);
-			reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
-		};
-		let timeoutId = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-//#endregion
 //#region src/types/error.ts
 function unknownToError(err) {
 	if (err instanceof Error) return err;
@@ -1816,6 +1825,144 @@ function throwUnreachable() {
 	throw new Error("Unreachable");
 }
 //#endregion
+//#region src/async/priority-work-queue.ts
+var PRI_ORDER = [
+	"visible",
+	"preload",
+	"background"
+];
+function isAbortError(err) {
+	return err instanceof Error && err.name === "AbortError";
+}
+function emptyLanes() {
+	return {
+		visible: [],
+		preload: [],
+		background: []
+	};
+}
+function resolveConcurrency(value) {
+	if (value === void 0) return 3;
+	let n = Math.floor(value);
+	if (!Number.isFinite(n) || n < 1) return 1;
+	return n;
+}
+function createPriorityWorkQueue(opts) {
+	let concurrency = resolveConcurrency(opts?.concurrency);
+	let lanes = emptyLanes();
+	let queuedPri = /* @__PURE__ */ new Map();
+	let active = /* @__PURE__ */ new Map();
+	let maxActive = 0;
+	function queuedCount() {
+		return queuedPri.size;
+	}
+	function removeQueued(id) {
+		let pri = queuedPri.get(id);
+		if (pri === void 0) return void 0;
+		let lane = lanes[pri];
+		let idx = lane.findIndex((job) => job.id === id);
+		queuedPri.delete(id);
+		if (idx < 0) return void 0;
+		return lane.splice(idx, 1)[0];
+	}
+	function pickNext() {
+		for (let pri of PRI_ORDER) {
+			let lane = lanes[pri];
+			while (lane.length > 0) {
+				let job = lane.shift();
+				queuedPri.delete(job.id);
+				if (active.has(job.id)) continue;
+				return job;
+			}
+		}
+	}
+	function pump() {
+		while (active.size < concurrency) {
+			let job = pickNext();
+			if (!job) return;
+			startJob(job);
+		}
+	}
+	function startJob(job) {
+		let controller = new AbortController();
+		active.set(job.id, {
+			id: job.id,
+			controller
+		});
+		if (active.size > maxActive) maxActive = active.size;
+		(async () => {
+			let reported;
+			try {
+				await job.run({ signal: controller.signal });
+			} catch (err) {
+				if (!isAbortError(err)) reported = unknownToError(err);
+			} finally {
+				active.delete(job.id);
+			}
+			if (reported) try {
+				opts?.onError?.(reported, job.id);
+			} catch {}
+			pump();
+		})();
+	}
+	return {
+		enqueue(job) {
+			if (active.has(job.id)) return false;
+			removeQueued(job.id);
+			lanes[job.pri].push({
+				id: job.id,
+				pri: job.pri,
+				run: job.run
+			});
+			queuedPri.set(job.id, job.pri);
+			pump();
+			return true;
+		},
+		cancel(id) {
+			if (removeQueued(id)) return true;
+			let running = active.get(id);
+			if (!running) return false;
+			running.controller.abort();
+			return true;
+		},
+		cancelAll() {
+			lanes = emptyLanes();
+			queuedPri.clear();
+			for (let running of active.values()) running.controller.abort();
+		},
+		isBusy(id) {
+			return active.has(id) || queuedPri.has(id);
+		},
+		get stats() {
+			return {
+				active: active.size,
+				queued: queuedCount(),
+				maxActive
+			};
+		}
+	};
+}
+//#endregion
+//#region src/async/sleep.ts
+function sleep(ms, signal) {
+	if (ms < 0) throw new RangeError("sleep: ms must be a non-negative number");
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+			return;
+		}
+		let onAbort = () => {
+			clearTimeout(timeoutId);
+			reject(signal?.reason ?? new DOMException("The operation was aborted.", "AbortError"));
+		};
+		let timeoutId = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
 //#region src/compress/checksum.ts
 var crcTable = new Int32Array(256);
 for (let i = 0; i < 256; i++) {
@@ -3151,4 +3298,4 @@ var decompress_exports = /* @__PURE__ */ __exportAll({
 	zlib: () => decompress$1
 });
 //#endregion
-export { Adler32, AggregateError, AsyncInterval, AsyncLock, AsyncQueue, AsyncResource, ChecksumMismatchError, ConditionVariable, Crc32, CustomMap, CustomSet, Deferred, DeferredTracked, Deque, Emitter, FlateError, InvalidBlockTypeError, InvalidDistanceError, InvalidHeaderError, InvalidLengthLiteralError, LruMap, LruSet, NotImplementedError, StreamFinishedError, UnexpectedEofError, abs, adler32, asNonNull, assert, assertEndsWith, assertEndsWith as assertsEndsWith, assertHashKey, assertMatches, assertNotNull, assertStartsWith, asyncPool, base64_exports as base64, bitLength, clearUndefinedInPlace, composeMiddlewares, compress_exports as compress, crc32, decompress_exports as decompress, deepMerge, enumerate, euclideanGcd, fromBytes, hex_exports as hex, isBigInt, isBoolean, isFalsy, isFunction, isNotNull, isNotUndefined, isNumber, isObject, isString, isSymbol, isTruthy, max, max2, min, min2, modInv, modPowBinary, noop, objectEntries, objectKeys, parallelMap, sleep, splitOnce, throwNotImplemented, throwUnreachable, timers_exports as timers, toBytes, twoMultiplicity, typed_exports as typed, u8_exports as u8, unknownToError, unsafeCastType, utf8_exports as utf8 };
+export { Adler32, AggregateError, AsyncInterval, AsyncLock, AsyncQueue, AsyncResource, ChecksumMismatchError, ConditionVariable, Crc32, CustomMap, CustomSet, Deferred, DeferredTracked, Deque, Emitter, FlateError, InvalidBlockTypeError, InvalidDistanceError, InvalidHeaderError, InvalidLengthLiteralError, LruMap, LruSet, NotImplementedError, StreamFinishedError, UnexpectedEofError, abs, adler32, asNonNull, assert, assertEndsWith, assertEndsWith as assertsEndsWith, assertHashKey, assertMatches, assertNotNull, assertStartsWith, asyncPool, base64_exports as base64, bitLength, clearUndefinedInPlace, composeMiddlewares, compress_exports as compress, crc32, createPriorityWorkQueue, decompress_exports as decompress, deepMerge, enumerate, euclideanGcd, fromBytes, hex_exports as hex, isBigInt, isBoolean, isFalsy, isFunction, isNotNull, isNotUndefined, isNumber, isObject, isString, isSymbol, isTruthy, max, max2, min, min2, modInv, modPowBinary, noop, objectEntries, objectKeys, parallelMap, sleep, splitOnce, throwNotImplemented, throwUnreachable, timers_exports as timers, toBytes, twoMultiplicity, typed_exports as typed, u8_exports as u8, unknownToError, unsafeCastType, utf8_exports as utf8 };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@yorozu/utils",
     "type": "module",
-    "version": "0.3.1",
+    "version": "0.5.1",
     "description": "quality of life",
     "license": "MIT",
     "exports": {