doxum 0.1.17 → 0.1.18

package/dist/index.cjs

@@ -3,7 +3,7 @@ const require_issue = require("./issue-DhrNdQNg.cjs");
 const require_scope = require("./scope-Ezs-Y3TY.cjs");
 const require_notification = require("./notification-CDSUfiip.cjs");
 const require_driver = require("./driver-BCyfqxsl.cjs");
-const require_definition = require("./definition-De6rhTlZ.cjs");
+const require_advanced = require("./advanced-Dgu8-bPS.cjs");
 //#region core/src/schema.ts
 const node = (value) => Object.freeze(value);
 const field = (validator) => node({
@@ -1196,7 +1196,9 @@ const createScheduler = (onError) => {
 		phase = "compute";
 		lock(true);
 		try {
-			pending.forEach((source) => source.consumers.forEach(enqueue));
+			pending.forEach((source) => {
+				if (source.shouldSettle?.() ?? true) source.consumers.forEach(enqueue);
+			});
 			while (heap.length) {
 				const node = pop();
 				if (node.disposed) continue;
@@ -1338,12 +1340,29 @@ const createScheduler = (onError) => {
 		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 node = records.get(handle);
+			if (!node || !nodes.has(node)) throw new Error("Unknown projection node.");
+			if (node.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);
+			records.delete(handle);
+			pending.delete(node);
+			queued.delete(node);
+			emissions.delete(node);
+		},
 		source(handle) {
 			assertActive();
 			const source = records.get(handle);
@@ -1685,6 +1704,149 @@ const createSources = (scheduler) => {
 			}
 		};
 	};
+	const collectionInput = (initial) => {
+		const values = new Map(initial);
+		const touched = /* @__PURE__ */ new Map();
+		let beforeIds;
+		let revision = 0;
+		let cause;
+		const handle = Object.freeze({ kind: "collection" });
+		const change = () => {
+			const added = [];
+			const updated = [];
+			const removed = [];
+			for (const [key, before] of touched) {
+				const afterPresent = values.has(key);
+				if (!before.present && afterPresent) added.push({
+					key,
+					after: values.get(key)
+				});
+				else if (before.present && !afterPresent) removed.push({
+					key,
+					before: before.value
+				});
+				else if (before.present && afterPresent && !Object.is(before.value, values.get(key))) updated.push({
+					key,
+					before: before.value,
+					after: values.get(key)
+				});
+			}
+			let order;
+			if (beforeIds) {
+				const afterIds = [...values.keys()];
+				const beforeKeys = new Set(beforeIds);
+				const afterKeys = new Set(afterIds);
+				const beforeCommon = beforeIds.filter((key) => afterKeys.has(key));
+				const afterCommon = afterIds.filter((key) => beforeKeys.has(key));
+				if (beforeCommon.some((key, index) => key !== afterCommon[index])) order = Object.freeze({
+					before: beforeIds,
+					after: Object.freeze(afterIds)
+				});
+			}
+			if (!added.length && !updated.length && !removed.length && !order) return void 0;
+			return Object.freeze({
+				kind: "incremental",
+				added: Object.freeze(added),
+				updated: Object.freeze(updated),
+				removed: Object.freeze(removed),
+				...order ? { order } : {}
+			});
+		};
+		const record = {
+			consumers: /* @__PURE__ */ new Set(),
+			disposed: false,
+			fault: void 0,
+			revision: () => revision,
+			reset: () => false,
+			shouldSettle: () => change() !== void 0,
+			clear: () => {
+				touched.clear();
+				beforeIds = void 0;
+				cause = void 0;
+			},
+			context: (active) => {
+				assertScope(active);
+				const read = Object.freeze({
+					get: (key) => {
+						assertScope(active);
+						return values.get(key);
+					},
+					has: (key) => {
+						assertScope(active);
+						return values.has(key);
+					},
+					ids: () => {
+						assertScope(active);
+						return Object.freeze([...values.keys()]);
+					}
+				});
+				return Object.freeze({
+					kind: "collection",
+					read,
+					change: change(),
+					revision,
+					cause
+				});
+			}
+		};
+		scheduler.register(handle, record);
+		return {
+			source: handle,
+			update(run) {
+				scheduler.assertIdle();
+				const staged = /* @__PURE__ */ new Map();
+				let active = true;
+				const draft = Object.freeze({
+					get: (key) => {
+						assertScope(() => active);
+						const entry = staged.get(key);
+						return entry ? entry.present ? entry.value : void 0 : values.get(key);
+					},
+					has: (key) => {
+						assertScope(() => active);
+						const entry = staged.get(key);
+						return entry ? entry.present : values.has(key);
+					},
+					set: (key, value) => {
+						assertScope(() => active);
+						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+						staged.set(key, {
+							present: true,
+							value
+						});
+					},
+					remove: (key) => {
+						assertScope(() => active);
+						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+						staged.set(key, { present: false });
+					}
+				});
+				try {
+					assertSynchronous(run(draft));
+				} finally {
+					active = false;
+				}
+				let changed = false;
+				for (const [key, entry] of staged) {
+					const present = values.has(key);
+					if (entry.present ? present && Object.is(values.get(key), entry.value) : !present) continue;
+					if (!touched.has(key)) touched.set(key, {
+						present,
+						value: values.get(key)
+					});
+					if (!beforeIds && present !== entry.present) beforeIds = Object.freeze([...values.keys()]);
+					if (entry.present) values.set(key, entry.value);
+					else values.delete(key);
+					changed = true;
+				}
+				if (!changed) return;
+				revision++;
+				cause = scheduler.batchContext()?.cause ?? cause;
+				scheduler.capture(record);
+				scheduler.run();
+			}
+		};
+	};
 	const externalValueSource = (port, equal) => {
 		scheduler.assertIdle();
 		const old = externalSources.get(port);
@@ -1877,6 +2039,7 @@ const createSources = (scheduler) => {
 				set
 			});
 		},
+		collectionInput,
 		fromReadable: (readable, options) => {
 			scheduler.assertIdle();
 			if (projectionHandles.has(readable)) throw new Error("Projection nodes must be declared directly as sources.");
@@ -2497,11 +2660,15 @@ const createProjectionGraph = (options) => {
 		fromSource: (source, options) => sources.fromSource(source, options),
 		fromCollectionSource: (source) => sources.fromCollectionSource(source),
 		input: sources.input,
+		collectionInput: sources.collectionInput,
 		fromReadable: sources.fromReadable,
 		value,
 		collection: (spec) => createCollection(scheduler, spec),
 		map,
 		batch: scheduler.batch,
+		assertIdle: scheduler.assertIdle,
+		releaseNode: scheduler.releaseNode,
+		releaseInput: scheduler.unregisterSource,
 		dispose: () => {
 			try {
 				scheduler.dispose();
@@ -2671,16 +2838,27 @@ const sourceOf = (instance) => instance;
 const createProjectionRuntime = (options) => {
 	const runtime = createProjectionGraph({ onError: options?.onError ?? (() => void 0) });
 	const materialized = /* @__PURE__ */ new WeakMap();
-	const materialize = (projection) => {
+	let disposed = false;
+	const scopes = /* @__PURE__ */ new Set();
+	const materialize = (projection, requester) => {
+		const owner = require_advanced.ownerOf(projection);
+		if (owner) {
+			if (owner !== requester) throw new TypeError("Projection belongs to another scope.");
+			if (!requester.active) throw new ProjectionDisposedError();
+		}
 		const old = materialized.get(projection);
 		if (old) return old.node;
-		const definition = require_definition.definitionOf(projection);
+		const definition = require_advanced.definitionOf(projection);
 		let instance;
-		let setter;
+		let write;
 		switch (definition.kind) {
 			case "input": {
 				const input = runtime.input(definition.initial, { isEqual: definition.isEqual });
-				setter = input.set;
+				write = {
+					kind: "value-input",
+					source: input.source,
+					set: input.set
+				};
 				instance = runtime.value({
 					sources: { input: input.source },
 					build: (values) => ({
@@ -2693,6 +2871,16 @@ const createProjectionRuntime = (options) => {
 				});
 				break;
 			}
+			case "collection-input": {
+				const source = runtime.collectionInput(definition.initial);
+				write = {
+					kind: "collection-input",
+					source: source.source,
+					update: source.update
+				};
+				instance = runtime.map(source.source, (_key, value) => value);
+				break;
+			}
 			case "readable": {
 				const source = runtime.fromReadable(definition.readable, { isEqual: definition.isEqual });
 				instance = runtime.value({
@@ -2764,7 +2952,7 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 			case "derive": {
-				const sources = Object.fromEntries(definition.dependencies.map((dependency, index) => [`d${index}`, sourceOf(materialize(dependency))]));
+				const sources = Object.fromEntries(definition.dependencies.map((dependency, index) => [`d${index}`, sourceOf(materialize(dependency, owner))]));
 				instance = runtime.value({
 					sources,
 					build: (values) => ({
@@ -2778,7 +2966,7 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 			case "incremental-value": {
-				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
+				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency, owner))]));
 				instance = runtime.value({
 					sources,
 					build: definition.build
@@ -2786,7 +2974,7 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 			case "incremental-collection": {
-				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
+				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency, owner))]));
 				instance = runtime.collection({
 					sources,
 					build: definition.build,
@@ -2796,14 +2984,19 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 		}
-		materialized.set(projection, {
+		const record = write ? {
 			node: instance,
-			set: setter
-		});
+			...write
+		} : {
+			kind: "projection",
+			node: instance
+		};
+		materialized.set(projection, record);
+		if (owner) owner.materialized.push(projection);
 		return instance;
 	};
-	const get = (projection) => {
-		const instance = materialize(projection);
+	const get = (projection, requester) => {
+		const instance = materialize(projection, requester);
 		const current = instance.current();
 		if (instance.kind === "collection") {
 			const record = materialized.get(projection) ?? materialized.get(instance);
@@ -2831,11 +3024,11 @@ const createProjectionRuntime = (options) => {
 		}
 		return current;
 	};
-	function readable(projection, selector, equality = Object.is) {
+	const makeReadable = (projection, selector, equality = Object.is, requester) => {
 		if (!selector) return Object.freeze({
-			current: () => get(projection),
-			revision: () => materialize(projection).revision(),
-			subscribe: (listener) => materialize(projection).subscribe(listener)
+			current: () => get(projection, requester),
+			revision: () => materialize(projection, requester).revision(),
+			subscribe: (listener) => materialize(projection, requester).subscribe(listener)
 		});
 		let initialized = false;
 		let value;
@@ -2850,7 +3043,7 @@ const createProjectionRuntime = (options) => {
 		let unsubscribeSource;
 		const listeners = /* @__PURE__ */ new Set();
 		const updateCollectionSnapshot = () => {
-			const current = get(projection);
+			const current = get(projection, requester);
 			previousCollection = isMapLike(current) ? current : void 0;
 		};
 		const evaluate = () => {
@@ -2864,7 +3057,7 @@ const createProjectionRuntime = (options) => {
 			let source;
 			let next;
 			try {
-				source = get(projection);
+				source = get(projection, requester);
 				next = selector(source);
 			} finally {
 				activeTracker = previousTracker;
@@ -2881,30 +3074,30 @@ const createProjectionRuntime = (options) => {
 			}
 			selection = nextSelection;
 			initialized = true;
-			sourceRevision = materialize(projection).revision();
+			sourceRevision = materialize(projection, requester).revision();
 			updateCollectionSnapshot();
 			return changed;
 		};
 		const ensureCurrent = () => {
-			const revision = materialize(projection).revision();
+			const revision = materialize(projection, requester).revision();
 			if (!initialized || !unsubscribeSource && sourceRevision !== revision) evaluate();
 			return value;
 		};
 		const onProjectionChange = (incoming) => {
 			let change = incoming;
 			if (!change && previousCollection) {
-				const current = get(projection);
+				const current = get(projection, requester);
 				if (isMapLike(current)) {
 					change = mapChange(previousCollection, current);
 					previousCollection = current;
 					if (!change) {
-						sourceRevision = materialize(projection).revision();
+						sourceRevision = materialize(projection, requester).revision();
 						return;
 					}
 				} else previousCollection = void 0;
 			}
 			if (!selectionAffects(selection, change)) {
-				sourceRevision = materialize(projection).revision();
+				sourceRevision = materialize(projection, requester).revision();
 				updateCollectionSnapshot();
 				return;
 			}
@@ -2912,12 +3105,12 @@ const createProjectionRuntime = (options) => {
 			const changed = evaluate();
 			if (unsubscribeSource && !sameSelection(previousSelection, selection)) {
 				unsubscribeSource();
-				unsubscribeSource = materialize(projection).subscribe(onProjectionChange);
+				unsubscribeSource = materialize(projection, requester).subscribe(onProjectionChange);
 			}
 			if (changed) Array.from(listeners).forEach((listener) => listener());
 		};
 		const installSource = () => {
-			if (!unsubscribeSource) unsubscribeSource = materialize(projection).subscribe(onProjectionChange);
+			if (!unsubscribeSource) unsubscribeSource = materialize(projection, requester).subscribe(onProjectionChange);
 		};
 		return Object.freeze({
 			current: ensureCurrent,
@@ -2938,18 +3131,134 @@ const createProjectionRuntime = (options) => {
 				};
 			}
 		});
+	};
+	function readable(projection, selector, equality) {
+		return makeReadable(projection, selector, equality);
 	}
+	const setInput = (target, value, requester) => {
+		materialize(target, requester);
+		const record = materialized.get(target);
+		if (record?.kind !== "value-input") throw new TypeError("Projection is not a value input.");
+		record.set(value);
+	};
+	const updateInput = (target, run, requester) => {
+		materialize(target, requester);
+		const record = materialized.get(target);
+		if (record?.kind !== "collection-input") throw new TypeError("Projection is not a collection input.");
+		record.update(run);
+	};
+	const createScope = () => {
+		runtime.assertIdle();
+		const state = {
+			active: true,
+			materialized: [],
+			subscriptions: /* @__PURE__ */ new Set()
+		};
+		scopes.add(state);
+		const assertActive = () => {
+			if (!state.active) throw new ProjectionDisposedError();
+		};
+		const own = (projection) => {
+			assertActive();
+			const definition = require_advanced.definitionOf(projection);
+			const dependencies = definition.kind === "derive" ? definition.dependencies : definition.kind === "incremental-value" || definition.kind === "incremental-collection" ? Object.values(definition.dependencies) : [];
+			for (const dependency of dependencies) {
+				const dependencyOwner = require_advanced.ownerOf(dependency);
+				if (dependencyOwner && dependencyOwner !== state) throw new TypeError("A scope cannot depend on another scope.");
+			}
+			require_advanced.ownDefinition(projection, state);
+			return projection;
+		};
+		const scopedInput = Object.assign((initial, equality) => own(require_advanced.input(initial, equality)), { collection: (initial) => own(require_advanced.input.collection(initial)) });
+		const scopedDerive = (dependencies, compute, equality) => own(require_advanced.derive(dependencies, compute, equality));
+		const scopedIncremental = Object.assign((dependencies, processor) => own(require_advanced.incremental(dependencies, processor)), { collection: (dependencies, processor) => own(require_advanced.incremental.collection(dependencies, processor)) });
+		function scopeReadable(projection, selector, equality) {
+			assertActive();
+			materialize(projection, state);
+			const source = makeReadable(projection, selector, equality, state);
+			return Object.freeze({
+				current: () => {
+					assertActive();
+					return source.current();
+				},
+				revision: () => {
+					assertActive();
+					return source.revision();
+				},
+				subscribe: (listener) => {
+					assertActive();
+					const stop = source.subscribe(listener);
+					let subscribed = true;
+					const unsubscribe = () => {
+						if (!subscribed) return;
+						subscribed = false;
+						state.subscriptions.delete(unsubscribe);
+						stop();
+					};
+					state.subscriptions.add(unsubscribe);
+					return unsubscribe;
+				}
+			});
+		}
+		function scopeBatch(optionsOrCallback, maybeCallback) {
+			assertActive();
+			return typeof optionsOrCallback === "function" ? runtime.batch(optionsOrCallback) : runtime.batch(optionsOrCallback, maybeCallback);
+		}
+		return Object.freeze({
+			input: scopedInput,
+			derive: scopedDerive,
+			incremental: scopedIncremental,
+			get: (projection) => {
+				assertActive();
+				return get(projection, state);
+			},
+			readable: scopeReadable,
+			set: (target, value) => {
+				assertActive();
+				setInput(target, value, state);
+			},
+			update: (target, run) => {
+				assertActive();
+				updateInput(target, run, state);
+			},
+			batch: scopeBatch,
+			dispose: () => {
+				if (!state.active) return;
+				runtime.assertIdle();
+				state.active = false;
+				state.subscriptions.forEach((unsubscribe) => unsubscribe());
+				for (const definition of state.materialized.reverse()) {
+					const record = materialized.get(definition);
+					if (!record) continue;
+					runtime.releaseNode(record.node);
+					if (record.kind !== "projection") runtime.releaseInput(record.source);
+					materialized.delete(definition);
+				}
+				state.materialized.length = 0;
+				scopes.delete(state);
+			}
+		});
+	};
 	const store = {
 		get,
 		readable,
-		set: ((input, value) => {
-			materialize(input);
-			const target = materialized.get(input);
-			if (!target?.set) throw new TypeError("Projection is not an input.");
-			target.set(value);
-		}),
+		set: setInput,
+		update: updateInput,
 		batch: runtime.batch,
-		dispose: runtime.dispose
+		scope: createScope,
+		dispose: () => {
+			if (disposed) return;
+			runtime.assertIdle();
+			disposed = true;
+			for (const scope of scopes) {
+				scope.active = false;
+				scope.subscriptions.forEach((unsubscribe) => unsubscribe());
+				scope.subscriptions.clear();
+				scope.materialized.length = 0;
+			}
+			scopes.clear();
+			runtime.dispose();
+		}
 	};
 	return Object.freeze(store);
 };
@@ -2963,13 +3272,13 @@ exports.TransactionRejected = require_notification.TransactionRejected;
 exports.asReadable = asReadable;
 exports.createDocument = createDocument;
 exports.createProjectionRuntime = createProjectionRuntime;
-exports.derive = require_definition.derive;
+exports.derive = require_advanced.derive;
 exports.field = field;
-exports.input = require_definition.input;
+exports.input = require_advanced.input;
 exports.list = list;
 exports.map = map;
 exports.object = object;
-exports.observe = require_definition.observe;
+exports.observe = require_advanced.observe;
 exports.optional = optional;
 exports.parse = require_scope.parse;
 exports.read = read;