doxum 0.1.32 → 0.1.33

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as ownProjections, C as snapshotDependencyValue, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as createCollectionChange, a as createKeyedDependencyRuntime, b as sameArray, c as assertScope, d as ProjectionDisposedError, f as ProjectionError, g as collectionHasStructuralChange, h as collectionChangeTouchesKey, i as compileKeyedDependencies, j as producerOf, k as isProjection, l as assertSynchronous, m as collectionChangeIntersects, n as keyedAbsent, o as outputKind, r as assertKeyedProjection, s as createKeyRelation, t as createKeyedTransform, u as createScheduler, v as diffCollection, w as collectionView, x as snapshotArray, y as iterableMatchesArray } from "./transform-gOtqcdHe.js";
+import { A as isProjection, C as compileProjectionDependencies, D as snapshotCollectionView, E as mapRead, M as producerOf, N as projectionRef, O as defineProcessor, P as profile, S as collectKeyedInvalidation, T as collectionView, _ as assertScope, a as collectionChangeTouchesKey, b as ProjectionDisposedError, c as diffCollection, d as createKeyedDependencyRuntime, f as outputKind, g as snapshotArray, h as sameArray, i as collectionChangeIntersects, j as ownProjections, k as defineSource, l as assertKeyedProjection, m as iterableMatchesArray, n as keyedAbsent, o as collectionHasStructuralChange, p as createKeyRelation, s as createCollectionChange, t as createKeyedTransform, u as compileKeyedDependencies, v as assertSynchronous, w as snapshotDependencyValue, x as ProjectionError, y as createScheduler } from "./transform-A9Lx5R2l.js";
 import { n as isPlainObject, r as isRecord, t as installOwn } from "./record-B2yRhYsc.js";
 import { c as AddressIndex, d as invalidValue, f as children, g as validate, h as parent, i as contextOf, l as MutationRejected, m as is, o as decodeChanges, p as contains$1, r as bindContext, s as sealChanges, t as assertRuntimeWritable, u as fail } from "./driver-B7RR-VfX.js";
 //#region core/src/schema/model.ts
@@ -2774,6 +2774,108 @@ const isExternalSource = (source) => {
 	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
 };
 //#endregion
+//#region core/src/projection/keyed/flat-map.ts
+function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
+	const name = "derive.keyed.flatMap";
+	assertKeyedProjection(source, `${name} source`);
+	const specs = typeof dependenciesOrSelect === "function" ? void 0 : dependenciesOrSelect;
+	const select = specs === void 0 ? dependenciesOrSelect : selectOrEquality;
+	const equality = specs === void 0 ? selectOrEquality : maybeEquality;
+	if (typeof select !== "function") throw new TypeError(`${name} requires a selector.`);
+	if (equality !== void 0 && typeof equality !== "function") throw new TypeError(`${name} equality must be a function.`);
+	const compiled = compileKeyedDependencies(source, specs, name);
+	const [projection] = defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: equality ?? Object.is
+		}],
+		name,
+		create: () => {
+			const dependencies = createKeyedDependencyRuntime(compiled);
+			const childrenByParent = /* @__PURE__ */ new Map();
+			const ownerByOutput = /* @__PURE__ */ new Map();
+			return {
+				evaluate: (evaluation) => {
+					const driver = evaluation.sources[0];
+					const output = evaluation.outputs[0];
+					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error(`${name} requires collection input and output.`);
+					const plan = collectKeyedInvalidation(driver, evaluation.sources, dependencies, evaluation.reset);
+					dependencies.prepare(evaluation.sources, plan.rebuild);
+					if (plan.rebuild) {
+						dependencies.clearBindings();
+						childrenByParent.clear();
+						ownerByOutput.clear();
+					}
+					const replaced = new Set(plan.keys);
+					for (const entry of plan.removed) replaced.add(entry.key);
+					const proposals = /* @__PURE__ */ new Map();
+					const segments = /* @__PURE__ */ new Map();
+					let orderDirty = plan.structural;
+					for (const parent of replaced) {
+						if (!driver.read.has(parent)) continue;
+						const value = driver.read.get(parent);
+						const entries = select(value, parent, dependencies.resolve(value, parent, evaluation.sources));
+						assertSynchronous(entries);
+						if (!Array.isArray(entries)) throw new TypeError(`${name} selector must return an array of entries.`);
+						const keys = [];
+						for (const entry of entries) {
+							if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError(`${name} entries must be [string key, value] tuples.`);
+							const [key, child] = entry;
+							const owner = ownerByOutput.get(key);
+							if (proposals.has(key) || owner !== void 0 && !replaced.has(owner)) throw new TypeError(`${name} duplicate key ${JSON.stringify(key)}.`);
+							proposals.set(key, {
+								parent,
+								value: child
+							});
+							keys.push(key);
+						}
+						const previous = childrenByParent.get(parent);
+						const unchanged = previous ? sameArray(previous, keys) : keys.length === 0;
+						if (!unchanged) orderDirty = true;
+						if (keys.length) segments.set(parent, unchanged && previous ? previous : Object.freeze(keys));
+					}
+					if (plan.rebuild) {
+						if (!evaluation.reset) {
+							for (const key of output.previous.ids()) if (!proposals.has(key)) output.output.remove(key);
+						}
+					} else for (const parent of replaced) {
+						const previous = childrenByParent.get(parent);
+						if (previous) for (const key of previous) {
+							if (!proposals.has(key)) output.output.remove(key);
+							ownerByOutput.delete(key);
+						}
+						childrenByParent.delete(parent);
+					}
+					for (const entry of plan.removed) dependencies.remove(entry.key);
+					for (const [parent, keys] of segments) childrenByParent.set(parent, keys);
+					for (const [key, entry] of proposals) {
+						ownerByOutput.set(key, entry.parent);
+						output.output.set(key, entry.value);
+					}
+					if (orderDirty) {
+						const order = [];
+						const parents = driver.read.ids();
+						for (const parent of parents) {
+							const keys = childrenByParent.get(parent);
+							if (keys) for (const key of keys) order.push(key);
+						}
+						profile.collectionView.idsScanned(parents.length + order.length);
+						output.output.order(order);
+					}
+					dependencies.remember(evaluation.sources);
+				},
+				release: () => {
+					childrenByParent.clear();
+					ownerByOutput.clear();
+					dependencies.release();
+				}
+			};
+		}
+	});
+	return projection;
+}
+//#endregion
 //#region core/src/projection/keyed/composition.ts
 const assertEquality = (equality, role) => {
 	if (equality !== void 0 && typeof equality !== "function") throw new TypeError(`${role} equality must be a function.`);
@@ -3440,44 +3542,26 @@ function createKeyedGroupBy(source, dependenciesOrSelector, maybeSelector) {
 					const driver = evaluation.sources[0];
 					const output = evaluation.outputs[0];
 					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error("derive.keyed.groupBy requires collection input and output.");
-					dependencies.prepare(evaluation.sources, evaluation.reset);
-					if (evaluation.reset) {
+					const invalidation = collectKeyedInvalidation(driver, evaluation.sources, dependencies, evaluation.reset);
+					dependencies.prepare(evaluation.sources, invalidation.rebuild);
+					if (invalidation.rebuild) {
 						rebuild(driver, evaluation.sources, output);
 						dependencies.remember(evaluation.sources);
 						return;
 					}
-					const dirty = /* @__PURE__ */ new Set();
 					const affected = /* @__PURE__ */ new Set();
-					let all = false;
-					let structural = false;
-					let orderDirty = false;
-					if (dependencies.driverChanged(driver)) {
-						const change = driver.change;
-						if (!change || change.kind === "reset") {
-							rebuild(driver, evaluation.sources, output);
-							dependencies.remember(evaluation.sources);
-							return;
-						} else {
-							for (const entry of change.removed) {
-								const changed = removeSourceKey(entry.key, affected);
-								orderDirty ||= changed;
-								dependencies.remove(entry.key);
-								dirty.delete(entry.key);
-							}
-							for (const entry of change.added) dirty.add(entry.key);
-							for (const entry of change.updated) dirty.add(entry.key);
-							structural = Boolean(change.added.length || change.removed.length || change.order);
-							orderDirty ||= structural;
-							if (structural) refreshOrderIndex(driver);
-						}
+					let orderDirty = invalidation.structural;
+					for (const entry of invalidation.removed) {
+						const changed = removeSourceKey(entry.key, affected);
+						orderDirty ||= changed;
+						dependencies.remove(entry.key);
 					}
-					all ||= dependencies.collectInvalidated(evaluation.sources, dirty);
-					if (all) for (const key of driver.read.ids()) dirty.add(key);
-					for (const key of dirty) {
+					if (invalidation.structural) refreshOrderIndex(driver);
+					for (const key of invalidation.keys) {
 						const changed = selectGroups(driver, evaluation.sources, key, affected);
 						orderDirty ||= changed;
 					}
-					if (structural) markAllGroups(output, affected);
+					if (invalidation.structural) markAllGroups(output, affected);
 					publishAffected(affected, output, orderDirty);
 					dependencies.remember(evaluation.sources);
 				},
@@ -3501,6 +3585,7 @@ const keyedDerive = Object.assign(createKeyedDerive, {
 	from: createKeyedFrom,
 	merge: createKeyedMerge,
 	groupBy: createKeyedGroupBy,
+	flatMap: createKeyedFlatMap,
 	singleton: createKeyedSingleton,
 	subset: createKeyedSubset,
 	filter: createKeyedFilter,
@@ -3622,11 +3707,11 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 	}
 };
 //#endregion
-//#region core/src/projection/output/collection.ts
-const createPublishedCollection = () => {
-	const values = /* @__PURE__ */ new Map();
-	let ids = Object.freeze([]);
-	let index = PersistentKeyedIndex.empty();
+//#region core/src/projection/collection/state.ts
+const createCollectionState = (initial) => {
+	const values = new Map(initial);
+	let ids = Object.freeze([...values.keys()]);
+	let index = values.size ? PersistentKeyedIndex.from(values) : PersistentKeyedIndex.empty();
 	return {
 		get: (key) => values.get(key),
 		has: (key) => values.has(key),
@@ -3651,7 +3736,7 @@ const createPublishedCollection = () => {
 				}
 			});
 		},
-		publish: (staged, nextIds, reset) => {
+		install: (staged, nextIds, reset) => {
 			if (reset) {
 				values.clear();
 				for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
@@ -3670,9 +3755,11 @@ const createPublishedCollection = () => {
 		}
 	};
 };
+//#endregion
+//#region core/src/projection/output/collection.ts
 /** Owns staged keyed intent, exact transitions and published collection state. */
 const createCollectionOutput = (binding) => {
-	const published = createPublishedCollection();
+	const published = createCollectionState();
 	const staged = /* @__PURE__ */ new Map();
 	let nextIds = published.ids();
 	let change;
@@ -3761,12 +3848,18 @@ const createCollectionOutput = (binding) => {
 					continue;
 				}
 				const before = published.get(key);
-				if (!isEqual(before, entry.value)) updatedEntries.push({
+				const equal = isEqual(before, entry.value);
+				assertSynchronous(equal);
+				if (!equal) updatedEntries.push({
 					key,
 					before,
 					after: entry.value
 				});
-				else if (!nextReset) staged.delete(key);
+				else if (nextReset) staged.set(key, {
+					present: true,
+					value: before
+				});
+				else staged.delete(key);
 				continue;
 			}
 			if (existed) removedEntries.push({
@@ -3836,7 +3929,7 @@ const createCollectionOutput = (binding) => {
 		revision: () => revision,
 		reset: () => reset,
 		publish: () => {
-			if (change) published.publish(staged, nextIds, change.kind === "reset");
+			if (change) published.install(staged, nextIds, change.kind === "reset");
 			if (change && initialized) revision++;
 			initialized = true;
 		},
@@ -3916,7 +4009,9 @@ const createValueOutput = (binding) => {
 			return false;
 		}
 		const candidate = staged;
-		changed = !initialized || !isEqual(value, candidate);
+		const equal = initialized ? isEqual(value, candidate) : false;
+		assertSynchronous(equal);
+		changed = !equal;
 		next = changed ? candidate : value;
 		reset = nextReset;
 		return changed;
@@ -5398,101 +5493,145 @@ const createExternalSourceRegistry = (scheduler, documents) => {
 //#region core/src/projection/source/input.ts
 const materializeInputSource = (scheduler, definition) => {
 	const source = definition.source;
+	if (source.kind !== "value-input" && source.kind !== "collection-input") throw new Error("Invalid projection input source.");
+	const equal = (previous, next) => {
+		const result = source.equality(previous, next);
+		assertSynchronous(result);
+		return result;
+	};
 	if (source.kind === "value-input") {
 		let latest = source.initial;
-		const boundary = createValueBoundary(scheduler, "projection input", source.initial, source.equality, () => latest, () => void 0);
+		const boundary = createValueBoundary(scheduler, "projection input", source.initial, Object.is, () => latest, () => void 0);
+		boundary.detach(() => {
+			latest = void 0;
+		});
 		return {
 			...boundary,
-			write: {
+			input: {
 				kind: "value",
+				read: () => latest,
 				set(value) {
-					scheduler.assertIdle();
-					latest = value;
+					const next = scheduler.acceptInput(() => {
+						if (equal(latest, value)) return latest;
+						if (source.equality === Object.is) return value;
+						const published = boundary.output.current();
+						return !Object.is(latest, published) && equal(published, value) ? published : value;
+					});
+					if (Object.is(latest, next)) return;
+					latest = next;
 					boundary.mark();
 					scheduler.run();
 				}
 			}
 		};
 	}
-	if (source.kind !== "collection-input") throw new Error("Invalid projection input source.");
-	const values = new Map(source.initial);
-	const boundary = createCollectionBoundary(scheduler, "projection collection input", () => mapRead(values), definition.output.equality, () => void 0);
+	const values = createCollectionState(source.initial);
+	let view;
+	const latest = {
+		get: values.get,
+		has: values.has,
+		ids: values.ids
+	};
+	const boundary = createCollectionBoundary(scheduler, "projection collection input", () => latest, Object.is, () => void 0);
+	boundary.detach(() => {
+		values.release();
+		view = void 0;
+	});
+	const check = () => {
+		scheduler.assertActive();
+		if (boundary.producer.disposed) throw new ProjectionDisposedError();
+	};
 	return {
 		...boundary,
-		write: {
+		input: {
 			kind: "collection",
+			read: () => view ??= collectionView(values.read(check)),
 			update(run) {
-				scheduler.assertIdle();
-				const staged = /* @__PURE__ */ new Map();
-				const operations = [];
-				let structural = false;
-				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 accepted = scheduler.acceptInput(() => {
+					const staged = /* @__PURE__ */ new Map();
+					const appended = /* @__PURE__ */ new Set();
+					let structural = false;
+					let active = true;
+					const has = (key) => {
 						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.");
-						const previous = staged.get(key);
-						structural ||= previous ? !previous.present : !values.has(key);
-						staged.set(key, {
-							present: true,
-							value
-						});
-						operations.push({
-							kind: "set",
-							key,
-							value
-						});
-					},
-					remove: (key) => {
-						assertScope(() => active);
-						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-						const previous = staged.get(key);
-						const present = previous ? previous.present : values.has(key);
-						structural ||= present;
-						staged.set(key, { present: false });
-						if (present) operations.push({
-							kind: "remove",
-							key
-						});
+					};
+					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);
+							return has(key);
+						},
+						set: (key, value) => {
+							assertScope(() => active);
+							if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+							if (!has(key)) {
+								appended.add(key);
+								structural = true;
+							}
+							staged.set(key, {
+								present: true,
+								value
+							});
+						},
+						remove: (key) => {
+							assertScope(() => active);
+							if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+							if (!has(key)) return;
+							appended.delete(key);
+							structural = true;
+							staged.set(key, { present: false });
+						}
+					});
+					try {
+						assertSynchronous(run(draft));
+					} finally {
+						active = false;
 					}
-				});
-				try {
-					assertSynchronous(run(draft));
-				} finally {
-					active = false;
-				}
-				if (!operations.length) return;
-				const candidates = /* @__PURE__ */ new Set();
-				const retained = /* @__PURE__ */ new Map();
-				for (const [key, entry] of staged) {
-					const existed = values.has(key);
-					if (entry.present) {
-						if (!existed) {
-							candidates.add(key);
+					const published = source.equality === Object.is ? void 0 : boundary.output.current();
+					for (const [key, entry] of staged) {
+						const existed = values.has(key);
+						if (!entry.present) {
+							if (!existed) staged.delete(key);
 							continue;
 						}
 						const previous = values.get(key);
-						if (source.equality(previous, entry.value)) retained.set(key, previous);
-						else candidates.add(key);
-					} else if (existed) candidates.add(key);
-				}
-				if (!candidates.size && !structural) return;
-				for (const operation of operations) if (operation.kind === "set") values.set(operation.key, operation.value);
-				else values.delete(operation.key);
-				for (const [key, value] of retained) if (values.has(key)) values.set(key, value);
+						let next = entry.value;
+						if (existed && equal(previous, next)) next = previous;
+						else if (published?.has(key)) {
+							const before = published.get(key);
+							if ((!existed || !Object.is(previous, before)) && equal(before, next)) next = before;
+						}
+						if (existed && Object.is(previous, next)) staged.delete(key);
+						else if (!Object.is(entry.value, next)) staged.set(key, {
+							present: true,
+							value: next
+						});
+					}
+					const beforeOrder = values.ids();
+					let order = beforeOrder;
+					if (structural) {
+						const next = [];
+						for (const key of beforeOrder) if (has(key) && !appended.has(key)) next.push(key);
+						for (const key of appended) next.push(key);
+						if (!sameArray(beforeOrder, next)) order = Object.freeze(next);
+					}
+					return {
+						staged,
+						order,
+						structural: order !== beforeOrder
+					};
+				});
+				if (!accepted.staged.size && !accepted.structural) return;
+				values.install(accepted.staged, accepted.order, false);
+				view = void 0;
 				boundary.mark({
-					candidates,
-					orderMayChange: structural
+					candidates: accepted.staged.keys(),
+					orderMayChange: accepted.structural
 				});
 				scheduler.run();
 			}
@@ -5789,7 +5928,7 @@ const createProjectionRuntime = (options) => {
 			result = Object.freeze({
 				record: source.producer,
 				outputs: Object.freeze([source.output]),
-				...source.write ? { write: source.write } : {}
+				...source.input ? { input: source.input } : {}
 			});
 		} else {
 			if (definition.owner === void 0 && definition.dependencies.some((dependency) => producerOf(dependency).owner !== void 0)) throw new TypeError("A root projection cannot depend on a scoped projection.");
@@ -5874,16 +6013,18 @@ const createProjectionRuntime = (options) => {
 	function selectProjection(projection, selector, equality) {
 		return makeReadable(projection, selector, equality);
 	}
-	const inputWrite = (target, requester) => {
+	const inputAccess = (target, requester) => {
+		scheduler.assertIdle();
+		if (requester && !requester.active) throw new ProjectionDisposedError();
 		const ref = projectionRef(target);
 		if (ref.output !== 0 || ref.producer.kind !== "source") throw new TypeError("Projection is not an input.");
 		if (ref.producer.source.kind !== "value-input" && ref.producer.source.kind !== "collection-input") throw new TypeError("Projection is not an input.");
-		const write = materializeProducer(ref.producer, requester).write;
-		if (!write) throw new TypeError("Projection input is not writable.");
-		return write;
+		const access = materializeProducer(ref.producer, requester).input;
+		if (!access) throw new TypeError("Projection input is not writable.");
+		return access;
 	};
 	const updateInput = (target, valueOrRun, requester) => {
-		const write = inputWrite(target, requester);
+		const write = inputAccess(target, requester);
 		if (write.kind === "value") {
 			write.set(valueOrRun);
 			return;
@@ -5894,7 +6035,18 @@ const createProjectionRuntime = (options) => {
 	function update(target, valueOrRun) {
 		updateInput(target, valueOrRun);
 	}
-	const batch = (run, options) => scheduler.batch(run, options);
+	const batch = (run, options, requester) => scheduler.batch(() => {
+		let active = true;
+		const read = (target) => {
+			assertScope(() => active);
+			return inputAccess(target, requester).read();
+		};
+		try {
+			return run(read);
+		} finally {
+			active = false;
+		}
+	}, options);
 	const disposeScope = (state) => {
 		if (!state.active) return;
 		scheduler.assertIdle();
@@ -5986,7 +6138,7 @@ const createProjectionRuntime = (options) => {
 		}
 		function scopeBatch(run, options) {
 			assertActive();
-			return batch(run, options);
+			return batch(run, options, state);
 		}
 		return Object.freeze({
 			own,