@yorozu/utils 0.5.3 → 1.0.25

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

@@ -0,0 +1,25 @@
+export type BitmapPri = "visible" | "preload";
+export type BitmapWorkJob = {
+    id: string;
+    pri: BitmapPri;
+    source: Blob | ImageBitmapSource;
+    run?: (ctx: {
+        signal: AbortSignal;
+        bitmap: ImageBitmap;
+    }) => Promise<void>;
+};
+export type BitmapWorkQueueStats = {
+    active: number;
+    queued: number;
+};
+export type BitmapWorkQueue = {
+    enqueue(job: BitmapWorkJob): boolean;
+    cancel(id: string): boolean;
+    pause(): void;
+    resume(): void;
+    readonly stats: BitmapWorkQueueStats;
+};
+export declare function createBitmapWorkQueue(opts?: {
+    concurrency?: number;
+    idle?: boolean;
+}): BitmapWorkQueue;

package/async/idle.d.ts

@@ -0,0 +1,10 @@
+export type IdleDeadline = {
+    didTimeout: boolean;
+    timeRemaining(): number;
+};
+export type IdleHandle = {
+    cancel(): void;
+};
+export declare function requestIdle(fn: (deadline: IdleDeadline) => void, opts?: {
+    timeout?: number;
+}): IdleHandle;

package/async/index.d.ts

@@ -6,6 +6,8 @@ export * from './async-resource';
 export * from './condition-variable';
 export * from './deferred';
 export * from './emitter';
+export * from './bitmap-work-queue';
+export * from './idle';
 export * from './pool';
 export * from './priority-work-queue';
 export * from './sleep';

package/index.js

@@ -1737,6 +1737,166 @@ var ConditionVariable = class {
 	}
 };
 //#endregion
+//#region src/async/idle.ts
+function requestIdle(fn, opts) {
+	let g = globalThis;
+	let timeout = opts?.timeout;
+	if (typeof g.requestIdleCallback === "function") {
+		let ricOpts;
+		if (timeout !== void 0) ricOpts = { timeout: timeout > 0 ? timeout : 1 };
+		let id = g.requestIdleCallback(fn, ricOpts);
+		return { cancel() {
+			g.cancelIdleCallback?.(id);
+		} };
+	}
+	let delay = 0;
+	if (typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0) delay = timeout;
+	let timer = setTimeout(() => {
+		fn({
+			didTimeout: true,
+			timeRemaining() {
+				return 0;
+			}
+		});
+	}, delay);
+	return { cancel() {
+		clearTimeout(timer);
+	} };
+}
+//#endregion
+//#region src/async/bitmap-work-queue.ts
+var PRI_ORDER$1 = ["visible", "preload"];
+function resolveConcurrency$1(value) {
+	if (value === void 0) return 1;
+	let n = Math.floor(value);
+	if (!Number.isFinite(n) || n < 1) return 1;
+	return n;
+}
+function emptyLanes$1() {
+	return {
+		visible: [],
+		preload: []
+	};
+}
+function createBitmapWorkQueue(opts) {
+	let concurrency = resolveConcurrency$1(opts?.concurrency);
+	let useIdle = opts?.idle !== false;
+	let lanes = emptyLanes$1();
+	let queuedPri = /* @__PURE__ */ new Map();
+	let active = /* @__PURE__ */ new Map();
+	let paused = false;
+	function cancelIdle(job) {
+		job.idleHandle?.cancel();
+		job.idleHandle = void 0;
+	}
+	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;
+		let job = lane.splice(idx, 1)[0];
+		cancelIdle(job);
+		return job;
+	}
+	function scheduleIdle(job) {
+		cancelIdle(job);
+		job.idleReady = false;
+		job.idleHandle = requestIdle(() => {
+			job.idleHandle = void 0;
+			if (queuedPri.get(job.id) !== job.pri) return;
+			job.idleReady = true;
+			if (!paused) pump();
+		});
+	}
+	function pickNext() {
+		for (let pri of PRI_ORDER$1) {
+			let lane = lanes[pri];
+			for (let i = 0; i < lane.length; i++) {
+				let job = lane[i];
+				if (!job.idleReady) continue;
+				lane.splice(i, 1);
+				queuedPri.delete(job.id);
+				cancelIdle(job);
+				return job;
+			}
+		}
+	}
+	function pump() {
+		if (paused) return;
+		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
+		});
+		(async () => {
+			try {
+				let signal = controller.signal;
+				if (signal.aborted) return;
+				let bitmap = await createImageBitmap(job.source);
+				if (signal.aborted) {
+					bitmap.close();
+					return;
+				}
+				if (job.run) await job.run({
+					signal,
+					bitmap
+				});
+				else bitmap.close();
+			} catch {} finally {
+				active.delete(job.id);
+			}
+			pump();
+		})();
+	}
+	return {
+		enqueue(job) {
+			if (active.has(job.id)) return false;
+			removeQueued(job.id);
+			let queued = {
+				id: job.id,
+				pri: job.pri,
+				source: job.source,
+				run: job.run,
+				idleReady: true
+			};
+			lanes[job.pri].push(queued);
+			queuedPri.set(job.id, job.pri);
+			if (useIdle && job.pri === "preload") scheduleIdle(queued);
+			else pump();
+			return true;
+		},
+		cancel(id) {
+			if (removeQueued(id)) return true;
+			let running = active.get(id);
+			if (!running) return false;
+			running.controller.abort();
+			return true;
+		},
+		pause() {
+			paused = true;
+		},
+		resume() {
+			paused = false;
+			pump();
+		},
+		get stats() {
+			return {
+				active: active.size,
+				queued: queuedPri.size
+			};
+		}
+	};
+}
+//#endregion
 //#region src/async/pool.ts
 var ErrorInfo = class {
 	constructor(item, index, error) {
@@ -3298,4 +3458,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, 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 };
+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, createBitmapWorkQueue, 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, requestIdle, 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.5.3",
+    "version": "1.0.25",
     "description": "quality of life",
     "license": "MIT",
     "exports": {