one/dist/cjs/background/web.cjs

One is a React framework for web, iOS, and Android apps.

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
	for (var name in all) __defProp(target, name, {
		get: all[name],
		enumerable: true
	});
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") {
		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: () => from[key],
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var web_exports = {};
__export(web_exports, { createWorkerExecutor: () => createWorkerExecutor });
module.exports = __toCommonJS(web_exports);
function createWorkerExecutor(createWorker) {
	const worker = createWorker();
	let disposed = false;
	let failure = null;
	let pending = null;
	function fail(error) {
		if (disposed || failure) return;
		failure = error;
		worker.terminate();
		const rejected = pending;
		pending = null;
		rejected?.reject(error);
	}
	worker.onmessage = (event) => {
		const response = event.data;
		const revision = response.ok ? response.result.revision : response.revision;
		if (!pending || revision !== pending.revision) return;
		const accepted = pending;
		pending = null;
		if (response.ok) accepted.resolve(response.result);
		else accepted.reject(new Error(response.error));
	};
	worker.onerror = (event) => {
		event.preventDefault();
		fail(new Error(event.message));
	};
	worker.onmessageerror = () => fail(new Error("background worker response could not be decoded"));
	return {
		execute(request, isCurrent) {
			if (disposed || !isCurrent(request.revision)) return Promise.resolve(null);
			if (failure) return Promise.reject(failure);
			if (pending) throw new Error("background calculations must run serially");
			return new Promise((resolve, reject) => {
				pending = {
					revision: request.revision,
					resolve,
					reject
				};
				try {
					worker.postMessage(request);
				} catch (error) {
					pending = null;
					reject(error instanceof Error ? error : new Error(String(error)));
				}
			});
		},
		dispose() {
			if (disposed) return;
			disposed = true;
			if (!failure) worker.terminate();
			const rejected = pending;
			pending = null;
			rejected?.reject(new Error("background computation disposed"));
		}
	};
}