doxum 0.1.34 → 0.1.35

package/dist/index.d.cts

@@ -29,10 +29,18 @@ declare function observe<T>(readable: Readable<T>): Projection<T>;
 declare function observe<S extends ObjectSchema<object>, P extends CollectionPath>(document: ReadonlyDocument<S>, selector: (path: SchemaPath<S>) => P): KeyedProjection<CollectionId<P>, ReadonlyValue<CollectionEntry<P>>>;
 declare function observe<S extends ObjectSchema<object>, P>(document: ReadonlyDocument<S>, selector: (path: SchemaPath<S>) => P): Projection<PathValueOf<P>>;
 //#endregion
+//#region core/src/projection/dependency.d.ts
+type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>> & Partial<Record<keyof Projection<unknown>, never>>;
+type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
+//#endregion
+//#region core/src/projection/keyed/entries.d.ts
+type KeyedEntries<K extends string, V> = readonly (readonly [K, V])[];
+//#endregion
 //#region core/src/projection/keyed/composition.d.ts
 type Equality$2<T> = (previous: T, next: T) => boolean;
 declare function createKeyedFrom<K extends string, V>(source: Projection<readonly V[]>, keyOf: (value: NoInfer<V>) => Synchronous<K>, equality?: Equality$2<V>): KeyedProjection<K, V>;
 declare function createKeyedFrom<K extends string, V>(source: readonly V[], keyOf: (value: NoInfer<V>) => Synchronous<K>, equality?: Equality$2<V>): KeyedProjection<K, V>;
+declare function createKeyedFromEntries<const D extends ProjectionDependencies, K extends string, V>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<KeyedEntries<K, V>>, equality?: Equality$2<NoInfer<V>>): KeyedProjection<K, V>;
 declare function createKeyedMerge<K extends string, V>(sources: readonly KeyedProjection<K, V>[], options: {
   readonly conflict: 'error' | 'first' | 'last';
   readonly equality?: Equality$2<V>;
@@ -47,14 +55,11 @@ declare function createKeyedMerge<K extends string, V>(sources: readonly KeyedPr
 }): KeyedProjection<K, V>;
 //#endregion
 //#region core/src/projection/keyed/flat-map.d.ts
-type Entries<K extends string, V> = readonly (readonly [K, V])[];
 type Equality$1<V> = (previous: V, next: V) => boolean;
-declare function createKeyedFlatMap<K extends string, V, O extends string, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<Entries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
-declare function createKeyedFlatMap<K extends string, V, const D extends object, O extends string, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<Entries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
+declare function createKeyedFlatMap<K extends string, V, O extends string, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<KeyedEntries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
+declare function createKeyedFlatMap<K extends string, V, const D extends object, O extends string, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<KeyedEntries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
 //#endregion
 //#region core/src/projection/derive.d.ts
-type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>>;
-type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
 type Equality<T> = (previous: T, next: T) => boolean;
 declare function createValueDerive<const D extends ProjectionDependencies, T>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<T>, equality?: Equality<T>): Projection<T>;
 declare const derive: typeof createValueDerive & {
@@ -67,6 +72,7 @@ declare const derive: typeof createValueDerive & {
     entries: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly (readonly [K, V])[]>;
     get: <K extends string, V>(source: KeyedProjection<K, V>, key: Projection<NoInfer<K> | undefined>, equality?: (previous: V | undefined, next: V | undefined) => boolean) => Projection<V | undefined>;
     from: typeof createKeyedFrom;
+    fromEntries: typeof createKeyedFromEntries;
     merge: typeof createKeyedMerge;
     groupBy: {
       <K extends string, V, G extends string>(source: KeyedProjection<K, V>, selector: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<G | readonly G[]>): KeyedProjection<G, readonly K[]>;

package/dist/index.d.ts

@@ -29,10 +29,18 @@ declare function observe<T>(readable: Readable<T>): Projection<T>;
 declare function observe<S extends ObjectSchema<object>, P extends CollectionPath>(document: ReadonlyDocument<S>, selector: (path: SchemaPath<S>) => P): KeyedProjection<CollectionId<P>, ReadonlyValue<CollectionEntry<P>>>;
 declare function observe<S extends ObjectSchema<object>, P>(document: ReadonlyDocument<S>, selector: (path: SchemaPath<S>) => P): Projection<PathValueOf<P>>;
 //#endregion
+//#region core/src/projection/dependency.d.ts
+type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>> & Partial<Record<keyof Projection<unknown>, never>>;
+type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
+//#endregion
+//#region core/src/projection/keyed/entries.d.ts
+type KeyedEntries<K extends string, V> = readonly (readonly [K, V])[];
+//#endregion
 //#region core/src/projection/keyed/composition.d.ts
 type Equality$2<T> = (previous: T, next: T) => boolean;
 declare function createKeyedFrom<K extends string, V>(source: Projection<readonly V[]>, keyOf: (value: NoInfer<V>) => Synchronous<K>, equality?: Equality$2<V>): KeyedProjection<K, V>;
 declare function createKeyedFrom<K extends string, V>(source: readonly V[], keyOf: (value: NoInfer<V>) => Synchronous<K>, equality?: Equality$2<V>): KeyedProjection<K, V>;
+declare function createKeyedFromEntries<const D extends ProjectionDependencies, K extends string, V>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<KeyedEntries<K, V>>, equality?: Equality$2<NoInfer<V>>): KeyedProjection<K, V>;
 declare function createKeyedMerge<K extends string, V>(sources: readonly KeyedProjection<K, V>[], options: {
   readonly conflict: 'error' | 'first' | 'last';
   readonly equality?: Equality$2<V>;
@@ -47,14 +55,11 @@ declare function createKeyedMerge<K extends string, V>(sources: readonly KeyedPr
 }): KeyedProjection<K, V>;
 //#endregion
 //#region core/src/projection/keyed/flat-map.d.ts
-type Entries<K extends string, V> = readonly (readonly [K, V])[];
 type Equality$1<V> = (previous: V, next: V) => boolean;
-declare function createKeyedFlatMap<K extends string, V, O extends string, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<Entries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
-declare function createKeyedFlatMap<K extends string, V, const D extends object, O extends string, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<Entries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
+declare function createKeyedFlatMap<K extends string, V, O extends string, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<KeyedEntries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
+declare function createKeyedFlatMap<K extends string, V, const D extends object, O extends string, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<KeyedEntries<O, T>>, equality?: Equality$1<T>): KeyedProjection<O, T>;
 //#endregion
 //#region core/src/projection/derive.d.ts
-type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>>;
-type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
 type Equality<T> = (previous: T, next: T) => boolean;
 declare function createValueDerive<const D extends ProjectionDependencies, T>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<T>, equality?: Equality<T>): Projection<T>;
 declare const derive: typeof createValueDerive & {
@@ -67,6 +72,7 @@ declare const derive: typeof createValueDerive & {
     entries: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly (readonly [K, V])[]>;
     get: <K extends string, V>(source: KeyedProjection<K, V>, key: Projection<NoInfer<K> | undefined>, equality?: (previous: V | undefined, next: V | undefined) => boolean) => Projection<V | undefined>;
     from: typeof createKeyedFrom;
+    fromEntries: typeof createKeyedFromEntries;
     merge: typeof createKeyedMerge;
     groupBy: {
       <K extends string, V, G extends string>(source: KeyedProjection<K, V>, selector: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<G | readonly G[]>): KeyedProjection<G, readonly K[]>;

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 assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform-RghG_Qxs.js";
+import { A as ownProjections, C as snapshotProjectionValues, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform-3mj0eStL.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,12 @@ 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/entries.ts
+/** Shared entry boundary; membership and duplicate policy belong to each operation. */
+function assertKeyedEntry(entry, name) {
+	if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError(`${name} entries must be [string key, value] tuples.`);
+}
+//#endregion
 //#region core/src/projection/keyed/flat-map.ts
 function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
 	const name = "derive.keyed.flatMap";
@@ -2820,7 +2826,7 @@ function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, mayb
 						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.`);
+							assertKeyedEntry(entry, name);
 							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)}.`);
@@ -2907,6 +2913,25 @@ const assertCollectionSources = (sources, expected) => {
 	if (sources.length !== expected) throw new Error("derive.keyed.merge resolved an invalid dependency count.");
 	for (const source of sources) if (source.kind !== "collection") throw new Error("derive.keyed.merge requires collection inputs.");
 };
+/** Complete ordered result reconciliation, without retaining a second member/value cache. */
+const stageKeyedSnapshot = (values, output, keyOf, valueOf, name) => {
+	const seen = /* @__PURE__ */ new Set();
+	const order = new Array(values.length);
+	const previous = output.previous.ids();
+	profile.collectionView.idsScanned(values.length + previous.length);
+	for (let index = 0; index < values.length; index++) {
+		const value = values[index];
+		const key = keyOf(value);
+		assertSynchronous(key);
+		if (typeof key !== "string") throw new TypeError(`${name} key selector must return a string.`);
+		if (seen.has(key)) throw new TypeError(`${name} duplicate key ${JSON.stringify(key)}.`);
+		seen.add(key);
+		order[index] = key;
+		output.output.set(key, valueOf(value));
+	}
+	for (const key of previous) if (!seen.has(key)) output.output.remove(key);
+	output.output.order(order);
+};
 function createKeyedFrom(source, keyOf, equality) {
 	if (typeof keyOf !== "function") throw new TypeError("derive.keyed.from requires a key selector.");
 	const outputEquality = assertEquality(equality, "derive.keyed.from");
@@ -2936,25 +2961,38 @@ function createKeyedFrom(source, keyOf, equality) {
 				values = scalar.value;
 			}
 			if (!values) throw new Error("derive.keyed.from has no source values.");
-			const seen = /* @__PURE__ */ new Set();
-			const order = new Array(values.length);
-			for (let index = 0; index < values.length; index++) {
-				const value = values[index];
-				const key = keyOf(value);
-				assertSynchronous(key);
-				if (typeof key !== "string") throw new TypeError("derive.keyed.from key selector must return a string.");
-				if (seen.has(key)) throw new TypeError(`derive.keyed.from duplicate key ${JSON.stringify(key)}.`);
-				seen.add(key);
-				order[index] = key;
-				output.output.set(key, value);
-			}
-			for (const previousKey of output.previous.ids()) if (!seen.has(previousKey)) output.output.remove(previousKey);
-			output.output.order(order);
+			stageKeyedSnapshot(values, output, keyOf, (value) => value, "derive.keyed.from");
 		} }),
 		name: "derive.keyed.from"
 	});
 	return projection;
 }
+function createKeyedFromEntries(dependencies, compute, equality) {
+	const name = "derive.keyed.fromEntries";
+	const compiled = compileProjectionDependencies(dependencies, name);
+	if (typeof compute !== "function") throw new TypeError(`${name} requires a compute callback.`);
+	const outputEquality = assertEquality(equality, name);
+	const [projection] = defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: outputEquality
+		}],
+		name,
+		create: () => ({ evaluate: (evaluation) => {
+			const output = evaluation.outputs[0];
+			if (output.kind !== "collection") throw new Error(`${name} requires a collection output.`);
+			const entries = compute(snapshotProjectionValues(compiled.names, evaluation.sources));
+			assertSynchronous(entries);
+			if (!Array.isArray(entries)) throw new TypeError(`${name} compute must return an array of entries.`);
+			stageKeyedSnapshot(entries, output, (entry) => {
+				assertKeyedEntry(entry, name);
+				return entry[0];
+			}, (entry) => entry[1], name);
+		} })
+	});
+	return projection;
+}
 function createKeyedMerge(sources, options) {
 	if (!Array.isArray(sources)) throw new TypeError("derive.keyed.merge sources must be an array of keyed projections.");
 	const capturedSources = snapshotArray(sources);
@@ -3583,6 +3621,7 @@ const keyedDerive = Object.assign(createKeyedDerive, {
 	entries: createKeyedEntries,
 	get: createKeyedGet,
 	from: createKeyedFrom,
+	fromEntries: createKeyedFromEntries,
 	merge: createKeyedMerge,
 	groupBy: createKeyedGroupBy,
 	flatMap: createKeyedFlatMap,
@@ -3606,9 +3645,7 @@ function createValueDerive(dependencies, compute, equality = Object.is) {
 		create: () => ({ evaluate: (evaluation) => {
 			const output = evaluation.outputs[0];
 			if (output.kind !== "value") throw new Error("derive requires a value output.");
-			const values = Object.create(null);
-			for (let index = 0; index < names.length; index++) values[names[index]] = snapshotDependencyValue(evaluation.sources[index]);
-			const next = compute(Object.freeze(values));
+			const next = compute(snapshotProjectionValues(names, evaluation.sources));
 			assertSynchronous(next);
 			output.output.set(next);
 		} })