one/dist/cjs/background/createLatestComputation.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 createLatestComputation_exports = {};
__export(createLatestComputation_exports, { createLatestComputation: () => createLatestComputation });
module.exports = __toCommonJS(createLatestComputation_exports);
function createLatestComputation(definition, changed) {
	const executor = definition.createExecutor();
	let revision = 0;
	let disposed = false;
	let computing = false;
	let waiting = null;
	let result = null;
	const isCurrent = (value) => !disposed && value === revision;
	async function drain() {
		computing = true;
		while (!disposed && waiting) {
			const request = waiting;
			waiting = null;
			try {
				const computed = await executor.execute(request, isCurrent);
				if (computed?.revision === request.revision && isCurrent(request.revision)) {
					result = computed;
					changed({
						phase: "ready",
						result: computed
					});
				}
			} catch (error) {
				if (isCurrent(request.revision)) changed({
					phase: "failed",
					revision: request.revision,
					error: error instanceof Error ? error : new Error(String(error))
				});
			}
		}
		computing = false;
	}
	return {
		update(input) {
			if (disposed) return;
			revision++;
			result = null;
			waiting = {
				revision,
				input
			};
			changed({
				phase: "computing",
				revision
			});
			if (!computing) void drain();
		},
		getCurrent: () => result,
		dispose() {
			if (disposed) return;
			disposed = true;
			result = null;
			waiting = null;
			executor.dispose();
		}
	};
}