doxum 0.1.26 → 0.1.28

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import { $ as table, A as ParseError, B as DocumentListConfig, C as Read, D as ChangeSet, E as Change, F as CollectionPath, G as ReadonlyValue, H as DocumentTreeValue, I as PathValueOf, J as field, K as Schema, L as SchemaPath, M as parse, N as CollectionEntry, O as MemberChange, P as CollectionId, Q as optional, R as DocumentAddress, S as Draft, T as snapshot, U as Infer, V as DocumentTreeNode, W as ObjectSchema, X as map, Y as list, Z as object, _ as Unsubscribe, a as DocumentProblem, b as CollectionImpact, c as HistoryState, d as OperationResult, et as tree, f as ReadonlyDocument, g as Readable, h as TransactionResult, i as DocumentDisposedError, j as ParseIssue, k as ValueTransition, l as LocalHistory, m as TransactionRejected, n as DocumentCommit, o as DocumentReentrancyError, p as Synchronous, q as Validator, r as DocumentDiagnostic, s as DocumentRuntime, t as CommitSource, tt as variant, u as ObserverError, v as MutationIssue, w as replace, x as DocumentImpact, y as MutationIssueCode, z as DocumentAnchor } from "./contract-CNR6BS75.cjs";
-import { a as Projection, d as ExternalCollectionRead, f as ExternalCollectionSource, g as ProjectionError, h as ProjectionDisposedError, i as KeyedProjection, m as ExternalValueSource, n as CollectionInputDraft, p as ExternalValueEvent, r as Input, t as CollectionInput, u as ExternalCollectionEvent } from "./definition-CDOuvb5C.cjs";
+import { _ as ProjectionDisposedError, a as Input, f as ExternalCollectionEvent, g as ExternalValueSource, h as ExternalValueEvent, i as CollectionInputDraft, m as ExternalCollectionSource, n as KeyedDependencyValues, o as KeyedProjection, p as ExternalCollectionRead, r as CollectionInput, s as Projection, t as KeyedDependencies, v as ProjectionError } from "./dependency-B3E65M1E.cjs";
 
 //#region core/src/runtime.d.ts
 declare const createDocument: <S extends ObjectSchema<object>>(input: {
@@ -33,24 +33,37 @@ declare function observe<S extends ObjectSchema<object>, P>(document: ReadonlyDo
 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;
-/** A declared dynamic lookup from one driver entry to one key in another keyed projection. */
-type KeyedDependency<DriverKey extends string, DriverValue, SourceKey extends string = string, SourceValue = unknown> = {
-  readonly source: KeyedProjection<SourceKey, SourceValue>;
-  readonly key: (value: DriverValue, key: DriverKey) => Synchronous<SourceKey | undefined>;
-};
-type KeyedDeriveDependency<K extends string, V> = (Projection<unknown> & {
-  readonly source?: never;
-  readonly key?: never;
-}) | KeyedDependency<K, V, string, unknown>;
-type KeyedDeriveDependencies<K extends string, V, D extends object> = { readonly [P in keyof D]: P extends string ? KeyedDeriveDependency<K, V> : never };
-type KeyedDependencyValues<D extends Readonly<Record<string, unknown>>> = { readonly [P in keyof D]: D[P] extends {
-  readonly source: KeyedProjection<infer _K extends string, infer V>;
-} ? V | undefined : D[P] extends Projection<infer T> ? T : never };
 declare function createValueDerive<const D extends ProjectionDependencies, T>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<T>, equality?: Equality<T>): Projection<T>;
-declare function createKeyedDerive<K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: V, key: K) => Synchronous<T>, equality?: Equality<T>): KeyedProjection<K, T>;
-declare function createKeyedDerive<K extends string, V, const D extends object & KeyedDeriveDependencies<K, V, D>, T>(source: KeyedProjection<K, V>, dependencies: D, select: (value: V, key: K, dependencies: KeyedDependencyValues<D>) => Synchronous<T>, equality?: Equality<T>): KeyedProjection<K, T>;
 declare const derive: typeof createValueDerive & {
-  keyed: typeof createKeyedDerive;
+  keyed: {
+    <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+    <K extends string, V, const D extends object, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+  } & {
+    keys: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly K[]>;
+    values: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly V[]>;
+    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>;
+    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[]>;
+      <K extends string, V, const D extends object, G extends string>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, selector: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<G | readonly G[]>): KeyedProjection<G, readonly K[]>;
+    };
+    singleton: <K extends string, V>(source: Projection<V | undefined>, keyOf: (value: V) => Synchronous<K>, equality?: (previous: V, next: V) => boolean) => KeyedProjection<K, V>;
+    subset: <K extends string, V>(source: KeyedProjection<K, V>, orderedKeys: Projection<readonly K[]> | readonly K[]) => KeyedProjection<K, V>;
+    filter: {
+      <K extends string, V>(source: KeyedProjection<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<boolean>): KeyedProjection<K, V>;
+      <K extends string, V, const D extends object>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, predicate: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<boolean>): KeyedProjection<K, V>;
+    };
+    compact: {
+      <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+      <K extends string, V, const D extends object, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+    };
+  };
+};
+//#endregion
+//#region core/src/projection/readable/keyed.d.ts
+type ProjectionItems<K extends string, V> = {
+  readonly keys: Readable<readonly K[]>;
+  get(key: K): Readable<V | undefined>;
 };
 //#endregion
 //#region core/src/projection/runtime.d.ts
@@ -58,6 +71,7 @@ type ProjectionRuntime = {
   read<T>(projection: Projection<T>): T;
   select<T>(projection: Projection<T>): Readable<T>;
   select<T, R>(projection: Projection<T>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
+  items<K extends string, V>(projection: KeyedProjection<K, V>): ProjectionItems<K, V>;
   update<T>(input: Input<T>, value: T): void;
   update<K extends string, V>(input: CollectionInput<K, V>, run: (draft: CollectionInputDraft<K, V>) => void): void;
   batch<T>(run: () => T, options?: {
@@ -75,6 +89,7 @@ type ProjectionScope = {
   read<T>(projection: Projection<T>): T;
   select<T>(projection: Projection<T>): Readable<T>;
   select<T, R>(projection: Projection<T>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
+  items<K extends string, V>(projection: KeyedProjection<K, V>): ProjectionItems<K, V>;
   update<T>(input: Input<T>, value: T): void;
   update<K extends string, V>(input: CollectionInput<K, V>, run: (draft: CollectionInputDraft<K, V>) => void): void;
   batch<T>(run: () => T, options?: {
@@ -86,5 +101,5 @@ declare const createProjectionRuntime: (options?: {
   readonly onError?: (error: ProjectionError) => void;
 }) => ProjectionRuntime;
 //#endregion
-export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
+export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionItems, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { $ as table, A as ParseError, B as DocumentListConfig, C as Read, D as ChangeSet, E as Change, F as CollectionPath, G as ReadonlyValue, H as DocumentTreeValue, I as PathValueOf, J as field, K as Schema, L as SchemaPath, M as parse, N as CollectionEntry, O as MemberChange, P as CollectionId, Q as optional, R as DocumentAddress, S as Draft, T as snapshot, U as Infer, V as DocumentTreeNode, W as ObjectSchema, X as map, Y as list, Z as object, _ as Unsubscribe, a as DocumentProblem, b as CollectionImpact, c as HistoryState, d as OperationResult, et as tree, f as ReadonlyDocument, g as Readable, h as TransactionResult, i as DocumentDisposedError, j as ParseIssue, k as ValueTransition, l as LocalHistory, m as TransactionRejected, n as DocumentCommit, o as DocumentReentrancyError, p as Synchronous, q as Validator, r as DocumentDiagnostic, s as DocumentRuntime, t as CommitSource, tt as variant, u as ObserverError, v as MutationIssue, w as replace, x as DocumentImpact, y as MutationIssueCode, z as DocumentAnchor } from "./contract-COgxO5sv.js";
-import { a as Projection, d as ExternalCollectionRead, f as ExternalCollectionSource, g as ProjectionError, h as ProjectionDisposedError, i as KeyedProjection, m as ExternalValueSource, n as CollectionInputDraft, p as ExternalValueEvent, r as Input, t as CollectionInput, u as ExternalCollectionEvent } from "./definition-xgk3YNBp.js";
+import { _ as ProjectionDisposedError, a as Input, f as ExternalCollectionEvent, g as ExternalValueSource, h as ExternalValueEvent, i as CollectionInputDraft, m as ExternalCollectionSource, n as KeyedDependencyValues, o as KeyedProjection, p as ExternalCollectionRead, r as CollectionInput, s as Projection, t as KeyedDependencies, v as ProjectionError } from "./dependency-BYbdDHNa.js";
 
 //#region core/src/runtime.d.ts
 declare const createDocument: <S extends ObjectSchema<object>>(input: {
@@ -33,24 +33,37 @@ declare function observe<S extends ObjectSchema<object>, P>(document: ReadonlyDo
 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;
-/** A declared dynamic lookup from one driver entry to one key in another keyed projection. */
-type KeyedDependency<DriverKey extends string, DriverValue, SourceKey extends string = string, SourceValue = unknown> = {
-  readonly source: KeyedProjection<SourceKey, SourceValue>;
-  readonly key: (value: DriverValue, key: DriverKey) => Synchronous<SourceKey | undefined>;
-};
-type KeyedDeriveDependency<K extends string, V> = (Projection<unknown> & {
-  readonly source?: never;
-  readonly key?: never;
-}) | KeyedDependency<K, V, string, unknown>;
-type KeyedDeriveDependencies<K extends string, V, D extends object> = { readonly [P in keyof D]: P extends string ? KeyedDeriveDependency<K, V> : never };
-type KeyedDependencyValues<D extends Readonly<Record<string, unknown>>> = { readonly [P in keyof D]: D[P] extends {
-  readonly source: KeyedProjection<infer _K extends string, infer V>;
-} ? V | undefined : D[P] extends Projection<infer T> ? T : never };
 declare function createValueDerive<const D extends ProjectionDependencies, T>(dependencies: D, compute: (values: ProjectionValues<D>) => Synchronous<T>, equality?: Equality<T>): Projection<T>;
-declare function createKeyedDerive<K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: V, key: K) => Synchronous<T>, equality?: Equality<T>): KeyedProjection<K, T>;
-declare function createKeyedDerive<K extends string, V, const D extends object & KeyedDeriveDependencies<K, V, D>, T>(source: KeyedProjection<K, V>, dependencies: D, select: (value: V, key: K, dependencies: KeyedDependencyValues<D>) => Synchronous<T>, equality?: Equality<T>): KeyedProjection<K, T>;
 declare const derive: typeof createValueDerive & {
-  keyed: typeof createKeyedDerive;
+  keyed: {
+    <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+    <K extends string, V, const D extends object, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<T>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+  } & {
+    keys: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly K[]>;
+    values: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly V[]>;
+    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>;
+    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[]>;
+      <K extends string, V, const D extends object, G extends string>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, selector: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<G | readonly G[]>): KeyedProjection<G, readonly K[]>;
+    };
+    singleton: <K extends string, V>(source: Projection<V | undefined>, keyOf: (value: V) => Synchronous<K>, equality?: (previous: V, next: V) => boolean) => KeyedProjection<K, V>;
+    subset: <K extends string, V>(source: KeyedProjection<K, V>, orderedKeys: Projection<readonly K[]> | readonly K[]) => KeyedProjection<K, V>;
+    filter: {
+      <K extends string, V>(source: KeyedProjection<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<boolean>): KeyedProjection<K, V>;
+      <K extends string, V, const D extends object>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, predicate: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<boolean>): KeyedProjection<K, V>;
+    };
+    compact: {
+      <K extends string, V, T>(source: KeyedProjection<K, V>, select: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+      <K extends string, V, const D extends object, T>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, select: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<T | undefined>, equality?: (previous: T, next: T) => boolean): KeyedProjection<K, T>;
+    };
+  };
+};
+//#endregion
+//#region core/src/projection/readable/keyed.d.ts
+type ProjectionItems<K extends string, V> = {
+  readonly keys: Readable<readonly K[]>;
+  get(key: K): Readable<V | undefined>;
 };
 //#endregion
 //#region core/src/projection/runtime.d.ts
@@ -58,6 +71,7 @@ type ProjectionRuntime = {
   read<T>(projection: Projection<T>): T;
   select<T>(projection: Projection<T>): Readable<T>;
   select<T, R>(projection: Projection<T>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
+  items<K extends string, V>(projection: KeyedProjection<K, V>): ProjectionItems<K, V>;
   update<T>(input: Input<T>, value: T): void;
   update<K extends string, V>(input: CollectionInput<K, V>, run: (draft: CollectionInputDraft<K, V>) => void): void;
   batch<T>(run: () => T, options?: {
@@ -75,6 +89,7 @@ type ProjectionScope = {
   read<T>(projection: Projection<T>): T;
   select<T>(projection: Projection<T>): Readable<T>;
   select<T, R>(projection: Projection<T>, selector: (value: T) => R, equality?: (previous: R, next: R) => boolean): Readable<R>;
+  items<K extends string, V>(projection: KeyedProjection<K, V>): ProjectionItems<K, V>;
   update<T>(input: Input<T>, value: T): void;
   update<K extends string, V>(input: CollectionInput<K, V>, run: (draft: CollectionInputDraft<K, V>) => void): void;
   batch<T>(run: () => T, options?: {
@@ -86,5 +101,5 @@ declare const createProjectionRuntime: (options?: {
   readonly onError?: (error: ProjectionError) => void;
 }) => ProjectionRuntime;
 //#endregion
-export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
+export { type Change, type ChangeSet, type CollectionImpact, type CollectionInput, type CollectionInputDraft, type CommitSource, type DocumentAddress, type DocumentAnchor, type DocumentCommit, type DocumentDiagnostic, DocumentDisposedError, type DocumentImpact, type DocumentListConfig, type DocumentProblem, DocumentReentrancyError, type DocumentRuntime, type DocumentSelector, type DocumentTreeNode, type DocumentTreeValue, type Draft, type ExternalCollectionEvent, type ExternalCollectionRead, type ExternalCollectionSource, type ExternalValueEvent, type ExternalValueSource, type HistoryState, type Infer, type Input, type KeyedProjection, type LocalHistory, type MemberChange, type MutationIssue, type MutationIssueCode, type ObjectSchema, type ObserverError, type OperationResult, ParseError, type ParseIssue, type PathValueOf, type Projection, ProjectionDisposedError, ProjectionError, type ProjectionItems, type ProjectionRuntime, type ProjectionScope, type Read, type Readable, type ReadonlyDocument, type ReadonlyValue, type Schema, type SchemaPath, TransactionRejected, type TransactionResult, type Unsubscribe, type Validator, type ValueTransition, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
 //# sourceMappingURL=index.d.ts.map