doxum 0.1.13 → 0.1.14

package/dist/{definition-kxnWUvX9.d.cts → definition-DN6yW2vi.d.cts}

@@ -3,55 +3,53 @@ import { J as Infer, L as CollectionId, R as CollectionNode, Z as ObjectNode, _
 //#region core/src/projection/contract.d.ts
 /** Opaque application metadata identifying the action that produced a source event. */
 type Cause = unknown;
-type BatchContext = {
-  readonly id: number;
-  readonly cause?: Cause;
-};
 type BatchOptions = {
   readonly cause?: Cause;
 };
-type CollectionEntryTransition<K extends string, V> = {
-  readonly key: K;
-  readonly kind: 'added' | 'updated' | 'removed';
-  readonly before: V | undefined;
-  readonly after: V | undefined;
-};
-type ValueContext<T, D = unknown> = {
-  readonly value: T;
-  readonly previous: T;
-  readonly changed: boolean;
-  readonly revision: number;
-  readonly reset: boolean;
-  readonly detail?: D;
-  readonly cause?: Cause;
-  readonly batch?: BatchContext;
-};
 type CollectionRead<K extends string, V> = {
   get(key: K): V | undefined;
   has(key: K): boolean;
   ids(): readonly K[];
 };
-type CollectionContext<K extends string, V, D = unknown> = CollectionRead<K, V> & {
-  readonly previous: CollectionRead<K, V>;
-  readonly change: CollectionImpact<K> | undefined;
-  readonly revision: number;
-  readonly reset: boolean;
-  readonly transitions: (keys?: Iterable<K>) => readonly CollectionEntryTransition<K, V>[];
-  readonly detail?: D;
-  readonly cause?: Cause;
-  readonly batch?: BatchContext;
+type ExternalCollectionRead<K extends string, V> = {
+  readonly get: (key: K) => V | undefined;
+  readonly has: (key: K) => boolean;
+  readonly ids: () => readonly K[];
 };
 type ExternalValueSource<T, D = unknown> = {
   readonly kind: 'value';
   current(): T;
   revision(): number;
-  subscribe(listener: (event: ValueContext<T, D>) => void): Unsubscribe;
+  subscribe(listener: (event: ExternalValueEvent<T, D>) => void): Unsubscribe;
 };
 type ExternalCollectionSource<K extends string, V, D = unknown> = {
   readonly kind: 'collection';
-  current(): CollectionRead<K, V>;
+  current(): ExternalCollectionRead<K, V>;
   revision(): number;
-  subscribe(listener: (event: CollectionContext<K, V, D>) => void): Unsubscribe;
+  subscribe(listener: (event: ExternalCollectionEvent<K, V, D>) => void): Unsubscribe;
+};
+type ExternalValueEvent<T, D = unknown> = {
+  readonly value: T;
+  readonly revision: number;
+  readonly reset?: boolean;
+  readonly detail?: D;
+  readonly cause?: Cause;
+  readonly batch?: {
+    readonly id: number;
+    readonly cause?: Cause;
+  };
+};
+type ExternalCollectionEvent<K extends string, V, D = unknown> = {
+  readonly previous: ExternalCollectionRead<K, V>;
+  readonly revision: number;
+  readonly reset?: boolean;
+  readonly change?: CollectionImpact<K>;
+  readonly detail?: D;
+  readonly cause?: Cause;
+  readonly batch?: {
+    readonly id: number;
+    readonly cause?: Cause;
+  };
 };
 type CollectionDraft<K extends string, V> = {
   set(key: K, value: V): void;
@@ -85,14 +83,17 @@ type PublicCollection<K extends string, V> = ReadonlyMap<K, V>;
 type ObservedCollection<P extends CollectionPath> = PublicCollection<CollectionId<P>, ReadonlyValue<Infer<CollectionNode<P>>>>;
 declare const input: <T>(initial: T, equality?: (previous: T, next: T) => boolean) => Input<T>;
 /**
- * Establishes a reactive boundary from a document. The selector is compiled
- * when the definition is materialized, so declarations stay lazy and reusable.
+ * Establishes a reactive boundary from a document, readable, or external
+ * source. The selector is compiled when the definition is materialized, so
+ * declarations stay lazy and reusable.
  */
 declare function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;
+declare function observe<T, D>(source: ExternalValueSource<T, D>): Projection<T>;
+declare function observe<K extends string, V, D>(source: ExternalCollectionSource<K, V, D>): Projection<PublicCollection<K, V>>;
 declare function observe<T>(readable: Readable<T>): Projection<T>;
 declare function observe<S extends ObjectNode, P extends CollectionPath>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<ObservedCollection<P>>;
 declare function observe<S extends ObjectNode, P>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<PathValueOf<P>>;
 declare function derive<const D extends readonly Projection<unknown>[], T>(dependencies: D, compute: (...values: ProjectionValues<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
 //#endregion
-export { derive as a, BatchOptions as c, ExternalCollectionSource as d, ExternalValueSource as f, PublicCollection as i, CollectionDraft as l, ProjectionError as m, Projection as n, input as o, ProjectionDisposedError as p, ProjectionValues as r, observe as s, Input as t, CollectionRead as u };
-//# sourceMappingURL=definition-kxnWUvX9.d.cts.map
+export { ProjectionError as _, derive as a, BatchOptions as c, ExternalCollectionEvent as d, ExternalCollectionRead as f, ProjectionDisposedError as g, ExternalValueSource as h, PublicCollection as i, CollectionDraft as l, ExternalValueEvent as m, Projection as n, input as o, ExternalCollectionSource as p, ProjectionValues as r, observe as s, Input as t, CollectionRead as u };
+//# sourceMappingURL=definition-DN6yW2vi.d.cts.map

package/dist/{definition-BlMeHwdz.d.ts → definition-Dr8tHwTD.d.ts}

@@ -3,55 +3,53 @@ import { J as Infer, L as CollectionId, R as CollectionNode, Z as ObjectNode, _
 //#region core/src/projection/contract.d.ts
 /** Opaque application metadata identifying the action that produced a source event. */
 type Cause = unknown;
-type BatchContext = {
-  readonly id: number;
-  readonly cause?: Cause;
-};
 type BatchOptions = {
   readonly cause?: Cause;
 };
-type CollectionEntryTransition<K extends string, V> = {
-  readonly key: K;
-  readonly kind: 'added' | 'updated' | 'removed';
-  readonly before: V | undefined;
-  readonly after: V | undefined;
-};
-type ValueContext<T, D = unknown> = {
-  readonly value: T;
-  readonly previous: T;
-  readonly changed: boolean;
-  readonly revision: number;
-  readonly reset: boolean;
-  readonly detail?: D;
-  readonly cause?: Cause;
-  readonly batch?: BatchContext;
-};
 type CollectionRead<K extends string, V> = {
   get(key: K): V | undefined;
   has(key: K): boolean;
   ids(): readonly K[];
 };
-type CollectionContext<K extends string, V, D = unknown> = CollectionRead<K, V> & {
-  readonly previous: CollectionRead<K, V>;
-  readonly change: CollectionImpact<K> | undefined;
-  readonly revision: number;
-  readonly reset: boolean;
-  readonly transitions: (keys?: Iterable<K>) => readonly CollectionEntryTransition<K, V>[];
-  readonly detail?: D;
-  readonly cause?: Cause;
-  readonly batch?: BatchContext;
+type ExternalCollectionRead<K extends string, V> = {
+  readonly get: (key: K) => V | undefined;
+  readonly has: (key: K) => boolean;
+  readonly ids: () => readonly K[];
 };
 type ExternalValueSource<T, D = unknown> = {
   readonly kind: 'value';
   current(): T;
   revision(): number;
-  subscribe(listener: (event: ValueContext<T, D>) => void): Unsubscribe;
+  subscribe(listener: (event: ExternalValueEvent<T, D>) => void): Unsubscribe;
 };
 type ExternalCollectionSource<K extends string, V, D = unknown> = {
   readonly kind: 'collection';
-  current(): CollectionRead<K, V>;
+  current(): ExternalCollectionRead<K, V>;
   revision(): number;
-  subscribe(listener: (event: CollectionContext<K, V, D>) => void): Unsubscribe;
+  subscribe(listener: (event: ExternalCollectionEvent<K, V, D>) => void): Unsubscribe;
+};
+type ExternalValueEvent<T, D = unknown> = {
+  readonly value: T;
+  readonly revision: number;
+  readonly reset?: boolean;
+  readonly detail?: D;
+  readonly cause?: Cause;
+  readonly batch?: {
+    readonly id: number;
+    readonly cause?: Cause;
+  };
+};
+type ExternalCollectionEvent<K extends string, V, D = unknown> = {
+  readonly previous: ExternalCollectionRead<K, V>;
+  readonly revision: number;
+  readonly reset?: boolean;
+  readonly change?: CollectionImpact<K>;
+  readonly detail?: D;
+  readonly cause?: Cause;
+  readonly batch?: {
+    readonly id: number;
+    readonly cause?: Cause;
+  };
 };
 type CollectionDraft<K extends string, V> = {
   set(key: K, value: V): void;
@@ -85,14 +83,17 @@ type PublicCollection<K extends string, V> = ReadonlyMap<K, V>;
 type ObservedCollection<P extends CollectionPath> = PublicCollection<CollectionId<P>, ReadonlyValue<Infer<CollectionNode<P>>>>;
 declare const input: <T>(initial: T, equality?: (previous: T, next: T) => boolean) => Input<T>;
 /**
- * Establishes a reactive boundary from a document. The selector is compiled
- * when the definition is materialized, so declarations stay lazy and reusable.
+ * Establishes a reactive boundary from a document, readable, or external
+ * source. The selector is compiled when the definition is materialized, so
+ * declarations stay lazy and reusable.
  */
 declare function observe<S extends ObjectNode>(document: DocumentReadable<S>): Projection<Infer<S>>;
+declare function observe<T, D>(source: ExternalValueSource<T, D>): Projection<T>;
+declare function observe<K extends string, V, D>(source: ExternalCollectionSource<K, V, D>): Projection<PublicCollection<K, V>>;
 declare function observe<T>(readable: Readable<T>): Projection<T>;
 declare function observe<S extends ObjectNode, P extends CollectionPath>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<ObservedCollection<P>>;
 declare function observe<S extends ObjectNode, P>(document: DocumentReadable<S>, selector: (path: SchemaPath<S['shape']>) => P): Projection<PathValueOf<P>>;
 declare function derive<const D extends readonly Projection<unknown>[], T>(dependencies: D, compute: (...values: ProjectionValues<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): Projection<T>;
 //#endregion
-export { derive as a, BatchOptions as c, ExternalCollectionSource as d, ExternalValueSource as f, PublicCollection as i, CollectionDraft as l, ProjectionError as m, Projection as n, input as o, ProjectionDisposedError as p, ProjectionValues as r, observe as s, Input as t, CollectionRead as u };
-//# sourceMappingURL=definition-BlMeHwdz.d.ts.map
+export { ProjectionError as _, derive as a, BatchOptions as c, ExternalCollectionEvent as d, ExternalCollectionRead as f, ProjectionDisposedError as g, ExternalValueSource as h, PublicCollection as i, CollectionDraft as l, ExternalValueEvent as m, Projection as n, input as o, ExternalCollectionSource as p, ProjectionValues as r, observe as s, Input as t, CollectionRead as u };
+//# sourceMappingURL=definition-Dr8tHwTD.d.ts.map

package/dist/{definition-DXrKMVs7.js → definition-wOvuklwp.js}

@@ -735,6 +735,7 @@ const input = (initial, equality = Object.is) => define({
 	isEqual: equality
 });
 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",
@@ -742,6 +743,11 @@ function observe(document, selector) {
 		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({
@@ -751,7 +757,7 @@ function derive(dependencies, compute, equality = Object.is) {
 		isEqual: equality
 	});
 }
-/** Internal adapters used by the integration boundary, not exported publicly. */
+/** Internal source adapters used by observe, not exported publicly. */
 const defineReadable = (readable, equality = Object.is) => define({
 	kind: "readable",
 	readable,
@@ -780,6 +786,6 @@ const defineIncrementalCollection = (definition) => define({
 	name: definition.name
 });
 //#endregion
-export { copyValue as _, defineReadable as a, input as c, createAccess as d, replace as f, checkValue as g, checkKey as h, defineIncrementalValue as i, observe as l, ParseError as m, defineExternalValue as n, definitionOf as o, snapshot as p, defineIncrementalCollection as r, derive as s, defineExternalCollection as t, collectionAccess as u, equalValue as v, parse as y };
+export { input as a, createAccess as c, ParseError as d, checkKey as f, parse as g, equalValue as h, derive as i, replace as l, copyValue as m, defineIncrementalValue as n, observe as o, checkValue as p, definitionOf as r, collectionAccess as s, defineIncrementalCollection as t, snapshot as u };
 
-//# sourceMappingURL=definition-DXrKMVs7.js.map
+//# sourceMappingURL=definition-wOvuklwp.js.map