doxum 0.1.19 → 0.1.21

package/dist/advanced-BYZCjNWL.js

@@ -1,680 +0,0 @@
-import { L as profile } from "./issue-DVaGQGeP.js";
-import { i as snapshot } from "./scope-d-L87NeC.js";
-//#region core/src/projection/definition.ts
-const definitions = /* @__PURE__ */ new WeakMap();
-const owners = /* @__PURE__ */ new WeakMap();
-const define = (definition) => {
-	const handle = Object.freeze({});
-	definitions.set(handle, definition);
-	return handle;
-};
-const definitionOf = (projection) => {
-	const definition = definitions.get(projection);
-	if (!definition) throw new TypeError("Unknown projection definition.");
-	return definition;
-};
-const isProjection = (value) => value !== null && typeof value === "object" && definitions.has(value);
-const ownerOf = (projection) => owners.get(projection);
-const ownDefinition = (projection, owner) => {
-	if (!definitions.has(projection) || owners.has(projection)) throw new TypeError("Projection definition already has an owner.");
-	owners.set(projection, owner);
-	return projection;
-};
-const valueInput = (initial, equality = Object.is) => define({
-	kind: "input",
-	initial,
-	isEqual: equality
-});
-const collectionInput = (initial = /* @__PURE__ */ new Map()) => {
-	const entries = /* @__PURE__ */ new Map();
-	for (const [key, value] of initial) {
-		if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-		entries.set(key, value);
-	}
-	return define({
-		kind: "collection-input",
-		initial: entries
-	});
-};
-const input = Object.assign(valueInput, { collection: collectionInput });
-function observe(document, selector) {
-	if (isExternalSource(document)) return document.kind === "collection" ? defineExternalCollection(document) : defineExternalValue(document);
-	if ("current" in document && typeof document.current === "function") return defineReadable(document);
-	return define({
-		kind: "document",
-		document,
-		selector
-	});
-}
-const isExternalSource = (source) => {
-	if (!source || typeof source !== "object") return false;
-	const candidate = source;
-	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
-};
-function derive(dependencies, compute, equality = Object.is) {
-	if (!Array.isArray(dependencies) || dependencies.some((value) => !definitions.has(value))) throw new TypeError("derive dependencies must be projections.");
-	return define({
-		kind: "derive",
-		dependencies: Object.freeze([...dependencies]),
-		compute,
-		isEqual: equality
-	});
-}
-const defineReadable = (readable, equality = Object.is) => define({
-	kind: "readable",
-	readable,
-	isEqual: equality
-});
-const defineExternalValue = (source) => define({
-	kind: "source-value",
-	source
-});
-const defineExternalCollection = (source) => define({
-	kind: "source-collection",
-	source
-});
-const defineIncrementalValue = (definition) => define({
-	kind: "incremental-value",
-	dependencies: definition.dependencies,
-	build: definition.build,
-	isEqual: definition.isEqual,
-	name: definition.name
-});
-const defineIncrementalCollection = (definition) => define({
-	kind: "incremental-collection",
-	dependencies: definition.dependencies,
-	build: definition.build,
-	isEqual: definition.isEqual,
-	name: definition.name
-});
-const defineIncrementalGroup = (definition) => {
-	const group = {
-		dependencies: definition.dependencies,
-		outputs: Object.freeze(definition.outputs.map((output) => Object.freeze({
-			path: Object.freeze([...output.path]),
-			isEqual: output.isEqual
-		}))),
-		build: definition.build,
-		projections: []
-	};
-	const projections = group.outputs.map((_, output) => define({
-		kind: "incremental-group-output",
-		group,
-		output
-	}));
-	group.projections = Object.freeze(projections);
-	return Object.freeze(group);
-};
-//#endregion
-//#region core/src/projection/contract.ts
-var ProjectionError = class extends Error {
-	constructor(phase, identity, revisions, cause) {
-		super(`Projection ${phase} failed: ${identity}`, { cause });
-		this.phase = phase;
-		this.identity = identity;
-		this.revisions = revisions;
-		this.name = "ProjectionError";
-	}
-};
-var ProjectionDisposedError = class extends Error {
-	constructor() {
-		super("Projection has been disposed.");
-		this.name = "ProjectionDisposedError";
-	}
-};
-//#endregion
-//#region core/src/projection/scheduler.ts
-const projectionHandles = /* @__PURE__ */ new WeakSet();
-const createScheduler = (onError) => {
-	let disposed = false;
-	let depth = 0;
-	let batchSequence = 0;
-	let activeBatch;
-	let phase = "idle";
-	let sequence = 0;
-	const records = /* @__PURE__ */ new Map();
-	const nodes = /* @__PURE__ */ new Set();
-	const pending = /* @__PURE__ */ new Set();
-	const heap = [];
-	const queued = /* @__PURE__ */ new Set();
-	const completed = [];
-	const emissions = /* @__PURE__ */ new Set();
-	const errors = [];
-	let reportingFailures = [];
-	const guards = /* @__PURE__ */ new Set();
-	const cleanups = /* @__PURE__ */ new Set();
-	const assertActive = () => {
-		if (disposed) throw new ProjectionDisposedError();
-	};
-	const assertIdle = () => {
-		assertActive();
-		if (phase !== "idle") throw new Error("Projection cannot be re-entered during processing or notification.");
-	};
-	const lock = (value) => guards.forEach((guard) => guard(value));
-	const enqueue = (node) => {
-		if (node.disposed || queued.has(node)) return;
-		queued.add(node);
-		profile.projection("scheduledNodes");
-		let i = heap.length;
-		heap.push(node);
-		while (i > 0) {
-			const p = i - 1 >> 1;
-			if (heap[p].order < node.order) break;
-			heap[i] = heap[p];
-			i = p;
-		}
-		heap[i] = node;
-	};
-	const pop = () => {
-		const first = heap[0];
-		const last = heap.pop();
-		if (heap.length) {
-			let i = 0;
-			while (i * 2 + 1 < heap.length) {
-				let c = i * 2 + 1;
-				if (c + 1 < heap.length && heap[c + 1].order < heap[c].order) c++;
-				if (last.order < heap[c].order) break;
-				heap[i] = heap[c];
-				i = c;
-			}
-			heap[i] = last;
-		}
-		return first;
-	};
-	const errorFor = (node, cause, kind = "processor") => new ProjectionError(kind, node.name, node.sources.map((source) => source.revision()), cause);
-	const capture = (source) => {
-		if (disposed) return;
-		if (phase !== "idle") {
-			source.fault = new ProjectionError("source", "reentrant source", [source.revision()], /* @__PURE__ */ new Error("Source changed while projection was running."));
-			errors.push(source.fault);
-			throw source.fault;
-		}
-		pending.add(source);
-		profile.projection("sourceEvents");
-		if (source.fault) errors.push(source.fault);
-	};
-	const settle = () => {
-		if (disposed || depth || phase !== "idle") return;
-		phase = "compute";
-		lock(true);
-		try {
-			pending.forEach((source) => {
-				if (source.shouldSettle?.() ?? true) source.consumers.forEach(enqueue);
-			});
-			while (heap.length) {
-				const node = pop();
-				if (node.disposed) continue;
-				const wasFaulted = node.fault !== void 0;
-				profile.projection("processedNodes");
-				let changed = false;
-				const blocked = node.sources.find((source) => source.fault || source.disposed);
-				if (blocked) node.fault = errorFor(node, blocked.fault ?? new ProjectionDisposedError(), "blocked");
-				else {
-					const build = wasFaulted || node.sources.some((source) => source.reset());
-					try {
-						changed = node.evaluate(build);
-						const failure = node.sources.find((source) => source.fault)?.fault;
-						if (failure) throw failure;
-						node.fault = void 0;
-					} catch (cause) {
-						const error = errorFor(node, cause);
-						node.fault = error;
-						if (!build) try {
-							changed = node.evaluate(true);
-							const failure = node.sources.find((source) => source.fault)?.fault;
-							if (failure) throw failure;
-							node.fault = void 0;
-							errors.push(error);
-						} catch (cause) {
-							node.fault = errorFor(node, cause);
-							errors.push(node.fault);
-						}
-						else errors.push(error);
-					}
-				}
-				completed.push(node);
-				const outputs = node.changedOutputs?.() ?? (changed ? [node] : []);
-				const affected = node.fault ? node.outputs ?? [node] : outputs.length ? outputs : wasFaulted ? node.outputs ?? [node] : [];
-				if (affected.length) {
-					profile.projection("publishedNodes");
-					node.publish();
-					affected.forEach((output) => {
-						emissions.add(output);
-						output.consumers.forEach(enqueue);
-					});
-				}
-			}
-		} finally {
-			lock(false);
-			phase = "idle";
-		}
-	};
-	const flush = () => {
-		if (disposed || depth) return [];
-		if (pending.size || completed.length) profile.projection("flushes");
-		phase = "notify";
-		lock(true);
-		const reportFailures = [];
-		try {
-			emissions.forEach((output) => output.emit((listener) => {
-				try {
-					listener();
-				} catch (cause) {
-					errors.push(errorFor(output.owner, cause, "listener"));
-				}
-			}));
-			for (const error of errors.slice()) try {
-				onError(error);
-			} catch (cause) {
-				reportFailures.push(cause);
-			}
-			return Object.freeze([...errors.map((error) => Object.freeze({
-				phase: error.phase === "listener" ? "listener" : "processor",
-				error
-			})), ...reportFailures.map((error) => Object.freeze({
-				phase: "listener",
-				error
-			}))]);
-		} finally {
-			pending.forEach((source) => source.clear());
-			completed.forEach((node) => node.clear());
-			pending.clear();
-			queued.clear();
-			completed.length = 0;
-			emissions.clear();
-			errors.length = 0;
-			reportingFailures = reportFailures;
-			lock(false);
-			phase = "idle";
-		}
-	};
-	const run = () => {
-		settle();
-		const result = flush();
-		const failures = reportingFailures;
-		reportingFailures = [];
-		if (failures.length) throw new AggregateError(failures, "Projection error reporter failed.");
-		return result;
-	};
-	const batch = (optionsOrCallback, maybeCallback) => {
-		assertIdle();
-		const options = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-		const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : maybeCallback;
-		if (!callback) throw new TypeError("Projection batch requires a callback.");
-		if (depth === 0) activeBatch = Object.freeze({
-			id: ++batchSequence,
-			...options?.cause === void 0 ? {} : { cause: options.cause }
-		});
-		depth++;
-		let failed = false;
-		try {
-			const value = callback();
-			assertSynchronous(value);
-			return value;
-		} catch (error) {
-			failed = true;
-			throw error;
-		} finally {
-			depth--;
-			if (!depth) try {
-				if (failed) try {
-					run();
-				} catch {}
-				else run();
-			} finally {
-				activeBatch = void 0;
-			}
-		}
-	};
-	return {
-		assertActive,
-		assertIdle,
-		capture,
-		settle,
-		flush,
-		run,
-		records,
-		guards,
-		cleanups,
-		get active() {
-			return !disposed;
-		},
-		register(handle, record) {
-			assertIdle();
-			records.set(handle, record);
-			projectionHandles.add(handle);
-		},
-		unregisterSource(handle) {
-			const record = records.get(handle);
-			if (record) {
-				assertIdle();
-				if (record.consumers.size) throw new Error("Projection source is still used by a node.");
-				record.disposed = true;
-				pending.delete(record);
-				record.clear();
-				records.delete(handle);
-			}
-		},
-		releaseNode(handle) {
-			assertIdle();
-			const record = records.get(handle);
-			const node = record && "owner" in record ? record.owner : record;
-			if (!node || !nodes.has(node)) throw new Error("Unknown projection node.");
-			if ((node.outputs ?? [node]).some((output) => output.consumers.size)) throw new Error("Projection node is still used by another node.");
-			node.disposed = true;
-			node.sources.forEach((source) => source.consumers.delete(node));
-			node.release();
-			node.clear();
-			nodes.delete(node);
-			for (const [registered, value] of records) if (value === node || "owner" in value && value.owner === node) records.delete(registered);
-			pending.delete(node);
-			queued.delete(node);
-			for (const output of node.outputs ?? [node]) emissions.delete(output);
-		},
-		source(handle) {
-			assertActive();
-			const source = records.get(handle);
-			if (!source || source.disposed) throw new Error("Unknown, disposed, or foreign projection source.");
-			return source;
-		},
-		addNode(node) {
-			nodes.add(node);
-			node.sources.forEach((source) => source.consumers.add(node));
-		},
-		order: () => sequence++,
-		initialize(run) {
-			assertIdle();
-			phase = "compute";
-			lock(true);
-			try {
-				return run();
-			} finally {
-				lock(false);
-				phase = "idle";
-			}
-		},
-		batch,
-		batchContext: () => activeBatch,
-		dispose() {
-			if (disposed) return;
-			assertIdle();
-			disposed = true;
-			const failures = [];
-			cleanups.forEach((cleanup) => {
-				try {
-					cleanup();
-				} catch (error) {
-					failures.push(error);
-				}
-			});
-			cleanups.clear();
-			nodes.forEach((node) => {
-				node.disposed = true;
-				node.release();
-				node.consumers.clear();
-			});
-			records.forEach((source) => {
-				source.disposed = true;
-				source.consumers.clear();
-				source.clear();
-			});
-			nodes.clear();
-			records.clear();
-			pending.clear();
-			heap.length = 0;
-			completed.length = 0;
-			queued.clear();
-			emissions.clear();
-			guards.clear();
-			errors.length = 0;
-			reportingFailures = [];
-			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
-		}
-	};
-};
-const assertSynchronous = (value) => {
-	if (value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function") throw new TypeError("Projection callbacks must be synchronous.");
-};
-const assertScope = (active) => {
-	if (!active()) throw new Error("Projection reader or writer is no longer active.");
-};
-//#endregion
-//#region core/src/projection/advanced.ts
-const resetCollectionChange = Object.freeze({ kind: "reset" });
-const isRebuild = (value) => value !== null && typeof value === "object" && value.kind === "rebuild";
-const collectionChange = (source) => {
-	if (!source || typeof source !== "object" || !("kind" in source)) return void 0;
-	if (source.kind !== "collection") return void 0;
-	return source.change;
-};
-const sourceCause = (sources) => {
-	for (const source of Object.values(sources)) if (source && typeof source === "object" && "kind" in source) {
-		const cause = source.cause;
-		if (cause !== void 0) return cause;
-	}
-};
-const collectionView = (read) => {
-	const entries = function* () {
-		for (const key of read.ids()) yield [key, read.get(key)];
-	};
-	const values = function* () {
-		for (const key of read.ids()) yield read.get(key);
-	};
-	const view = {
-		get: (key) => read.get(key),
-		has: (key) => read.has(key),
-		get size() {
-			return read.ids().length;
-		},
-		keys: () => read.ids()[Symbol.iterator](),
-		values,
-		entries,
-		forEach: (callback, thisArg) => {
-			for (const key of read.ids()) callback.call(thisArg, read.get(key), key, view);
-		},
-		[Symbol.iterator]: entries
-	};
-	return Object.freeze(view);
-};
-const publicSource = (source) => {
-	if (!source || typeof source !== "object") return source;
-	if (!("kind" in source)) return source;
-	if (source.kind === "value") return source.value;
-	if (source.kind === "document") return snapshot(source.read);
-	if (source.kind === "collection") {
-		const read = source.read;
-		return collectionView(read);
-	}
-	return source;
-};
-const publicInputs = (sources, initial = false) => {
-	const values = [];
-	const changes = [];
-	for (const key of Object.keys(sources).sort((left, right) => Number(left.slice(1)) - Number(right.slice(1)))) {
-		const source = sources[key];
-		values.push(publicSource(source));
-		changes.push(initial && source && typeof source === "object" && "kind" in source && source.kind === "collection" ? resetCollectionChange : collectionChange(source));
-	}
-	return {
-		values,
-		changes
-	};
-};
-function createIncrementalValue(dependencies, processor) {
-	const dependencyMap = dependenciesOf(dependencies);
-	const build = (sources) => {
-		const state = Object.create(null);
-		let current;
-		const publicInputsForBuild = publicInputs(sources, true);
-		const result = processor({
-			sources: publicInputsForBuild.values,
-			changes: publicInputsForBuild.changes,
-			previous: void 0,
-			reset: true,
-			cause: sourceCause(sources),
-			state
-		});
-		if (isRebuild(result)) throw new TypeError("Initial incremental processor cannot rebuild.");
-		current = result;
-		return {
-			value: current,
-			update: (nextSources) => {
-				const publicInputsForUpdate = publicInputs(nextSources);
-				const next = processor({
-					sources: publicInputsForUpdate.values,
-					changes: publicInputsForUpdate.changes,
-					previous: current,
-					reset: false,
-					cause: sourceCause(nextSources),
-					state
-				});
-				if (isRebuild(next)) return next;
-				current = next;
-				return {
-					kind: "changed",
-					value: current
-				};
-			}
-		};
-	};
-	return defineIncrementalValue({
-		dependencies: dependencyMap,
-		build
-	});
-}
-function dependenciesOf(dependencies) {
-	if (!Array.isArray(dependencies)) throw new TypeError("Incremental dependencies must be projections.");
-	dependencies.forEach((dependency) => definitionOf(dependency));
-	return Object.freeze(Object.fromEntries(dependencies.map((dependency, index) => [`d${index}`, dependency])));
-}
-function createIncrementalCollection(dependencies, processor) {
-	const dependencyMap = dependenciesOf(dependencies);
-	const build = (input) => {
-		const state = Object.create(null);
-		const publicInputsForBuild = publicInputs(input.sources, true);
-		if (processor({
-			sources: publicInputsForBuild.values,
-			changes: publicInputsForBuild.changes,
-			previous: input.previous,
-			next: input.next,
-			reset: true,
-			cause: sourceCause(input.sources),
-			state,
-			output: input.output
-		})?.kind === "rebuild") throw new TypeError("Initial incremental collection processor cannot rebuild.");
-		return { update: (nextInput) => {
-			const publicInputsForUpdate = publicInputs(nextInput.sources);
-			return processor({
-				sources: publicInputsForUpdate.values,
-				changes: publicInputsForUpdate.changes,
-				previous: nextInput.previous,
-				next: nextInput.next,
-				reset: false,
-				cause: sourceCause(nextInput.sources),
-				state,
-				output: nextInput.output
-			});
-		} };
-	};
-	return defineIncrementalCollection({
-		dependencies: dependencyMap,
-		build
-	});
-}
-const groupOutputMetadata = /* @__PURE__ */ new WeakMap();
-const isPlainGroupNamespace = (value) => value !== null && typeof value === "object" && !groupOutputMetadata.has(value) && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
-const compileGroupShape = (value, path, declaredOutputs, used, outputs) => {
-	if (value !== null && typeof value === "object") {
-		const metadata = groupOutputMetadata.get(value);
-		if (metadata) {
-			if (!declaredOutputs.has(value)) throw new TypeError("Incremental group outputs must be declared by this group.");
-			if (used.has(value)) throw new TypeError("An incremental group output cannot be reused.");
-			used.add(value);
-			const index = outputs.length;
-			outputs.push({
-				path: Object.freeze([...path]),
-				isEqual: metadata.isEqual
-			});
-			return index;
-		}
-	}
-	if (!isPlainGroupNamespace(value)) throw new TypeError("Incremental group outputs must be a static object tree.");
-	for (const key of Reflect.ownKeys(value)) {
-		if (typeof key !== "string") throw new TypeError("Incremental group output names must be strings.");
-		if (!Object.prototype.propertyIsEnumerable.call(value, key)) throw new TypeError("Incremental group namespaces must contain enumerable properties.");
-	}
-	const keys = Object.keys(value);
-	if (!keys.length) throw new TypeError("Incremental group namespaces cannot be empty.");
-	const result = Object.create(null);
-	for (const key of keys) {
-		if (key === "__proto__" || key === "prototype" || key === "constructor") throw new TypeError(`Invalid incremental group output name: ${key}`);
-		const descriptor = Object.getOwnPropertyDescriptor(value, key);
-		if (!descriptor || !("value" in descriptor)) throw new TypeError("Incremental group namespaces cannot contain accessors.");
-		result[key] = compileGroupShape(descriptor.value, [...path, key], declaredOutputs, used, outputs);
-	}
-	return Object.freeze(result);
-};
-const hydrateGroupShape = (shape, values) => {
-	if (typeof shape === "number") return values[shape];
-	const result = {};
-	for (const [key, child] of Object.entries(shape)) result[key] = hydrateGroupShape(child, values);
-	return Object.freeze(result);
-};
-function createIncrementalGroup(dependencies, defineOutputs, processor) {
-	const dependencyMap = dependenciesOf(dependencies);
-	if (typeof defineOutputs !== "function") throw new TypeError("Incremental group outputs must be declared by a callback.");
-	if (typeof processor !== "function") throw new TypeError("Incremental group processor must be a function.");
-	let active = true;
-	const declaredOutputs = /* @__PURE__ */ new Set();
-	const declared = defineOutputs({ collection: (equality) => {
-		if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
-		const descriptor = Object.freeze({});
-		groupOutputMetadata.set(descriptor, { isEqual: equality });
-		declaredOutputs.add(descriptor);
-		return descriptor;
-	} });
-	assertSynchronous(declared);
-	active = false;
-	const outputs = [];
-	const used = /* @__PURE__ */ new Set();
-	const shape = compileGroupShape(declared, [], declaredOutputs, used, outputs);
-	if (typeof shape === "number") throw new TypeError("Incremental group declarations must return an output namespace.");
-	if (used.size === 0 || used.size !== declaredOutputs.size) throw new TypeError("Every incremental group output must be returned by the declaration.");
-	const stateFactory = () => Object.create(null);
-	const build = (input) => {
-		const state = stateFactory();
-		const run = (nextInput, reset) => {
-			const publicInput = publicInputs(nextInput.sources, reset);
-			const result = processor({
-				sources: publicInput.values,
-				changes: publicInput.changes,
-				previous: hydrateGroupShape(shape, nextInput.previous),
-				next: hydrateGroupShape(shape, nextInput.next),
-				outputs: hydrateGroupShape(shape, nextInput.outputs),
-				reset,
-				cause: sourceCause(nextInput.sources),
-				state
-			});
-			assertSynchronous(result);
-			return result;
-		};
-		if (isRebuild(run(input, true))) throw new TypeError("Initial incremental group processor cannot rebuild.");
-		return { update: (nextInput) => {
-			const result = run(nextInput, false);
-			return isRebuild(result) ? result : void 0;
-		} };
-	};
-	return hydrateGroupShape(shape, defineIncrementalGroup({
-		dependencies: dependencyMap,
-		outputs,
-		build
-	}).projections);
-}
-const incremental = Object.assign(createIncrementalValue, {
-	collection: createIncrementalCollection,
-	group: createIncrementalGroup
-});
-//#endregion
-export { projectionHandles as a, definitionOf as c, isProjection as d, observe as f, createScheduler as i, derive as l, ownerOf as m, assertScope as n, ProjectionDisposedError as o, ownDefinition as p, assertSynchronous as r, ProjectionError as s, incremental as t, input as u };
-
-//# sourceMappingURL=advanced-BYZCjNWL.js.map