doxum 0.1.7 → 0.1.9

package/dist/runtime-BFmhzPpZ.d.ts

@@ -1,150 +0,0 @@
-import { A as CollectionImpact, H as CollectionReader, Rt as SchemaPath, W as DocumentReader, _ as Unsubscribe, _t as CollectionNode, h as Synchronous, jt as ImpactTarget, kt as EntitySchemaNode, n as DocumentCommit, o as DocumentReadable, q as ReaderOfNode, v as Readable, vt as CollectionPath, wt as DocumentSchema, yt as CollectionSelector } from "./contract-DNZ4D53r.js";
-
-//#region core/src/projection/contract.d.ts
-declare const sourceContext: unique symbol;
-type ProjectionSource<T> = {
-  readonly [sourceContext]: T;
-};
-type ProjectionSources = Readonly<Record<string, ProjectionSource<unknown>>>;
-type ProjectionInputs<S extends ProjectionSources> = { readonly [K in keyof S]: S[K] extends ProjectionSource<infer T> ? T : never };
-type DocumentInput<S extends DocumentSchema> = {
-  readonly read: DocumentReader<S>;
-  readonly revision: number;
-  readonly commits: readonly DocumentCommit<S>[];
-  readonly reset: boolean;
-};
-type DocumentCollectionInput<S extends DocumentSchema, N extends EntitySchemaNode> = {
-  readonly read: CollectionReader<string, N>;
-  readonly target: CollectionSelector<string, N>;
-  readonly revision: number;
-  readonly commits: readonly DocumentCommit<S>[];
-  readonly reset: boolean;
-  readonly candidates: {
-    readonly keys: readonly string[];
-    readonly orderDirty: boolean;
-  };
-};
-type DocumentSource<S extends DocumentSchema> = ProjectionSource<DocumentInput<S>> & {
-  collection<P extends CollectionPath>(pick: (path: SchemaPath<S['shape']>) => P): DocumentCollectionSource<S, CollectionNode<P>>;
-  targets(...targets: readonly [ImpactTarget, ...ImpactTarget[]]): ProjectionSource<DocumentInput<S>>;
-};
-type DocumentCollectionSource<S extends DocumentSchema, N extends EntitySchemaNode> = ProjectionSource<DocumentCollectionInput<S, N>>;
-type ValueInput<T> = {
-  readonly value: T;
-  readonly previous: T;
-  readonly changed: boolean;
-  readonly revision: number;
-  readonly reset: boolean;
-};
-type ProjectionInput<T> = {
-  readonly source: ProjectionSource<ValueInput<T>>;
-  set(value: T): void;
-};
-type ValueUpdate<T> = {
-  readonly kind: 'unchanged';
-} | {
-  readonly kind: 'changed';
-  readonly value: T;
-} | {
-  readonly kind: 'rebuild';
-};
-type ValueSpec<S extends ProjectionSources, T> = {
-  readonly name?: string;
-  readonly sources: S;
-  readonly build: (sources: ProjectionInputs<S>) => {
-    readonly value: T;
-    readonly update: (sources: ProjectionInputs<S>) => ValueUpdate<NoInfer<T>>;
-  };
-};
-type ProjectionValue<T> = Readable<T> & ProjectionSource<ValueInput<T>> & {
-  rebuild(): void;
-  dispose(): void;
-};
-type CollectionRead<K extends string, V> = {
-  get(key: K): V | undefined;
-  has(key: K): boolean;
-  ids(): readonly K[];
-};
-type CollectionInput<K extends string, V> = CollectionRead<K, V> & {
-  readonly change: CollectionImpact<K> | undefined;
-  readonly revision: number;
-  readonly reset: boolean;
-};
-type ProjectionCollection<K extends string, V> = ProjectionSource<CollectionInput<K, V>> & {
-  readonly ids: Readable<readonly K[]>;
-  readonly all: Readable<readonly V[]>;
-  item(key: K): Readable<V | undefined>;
-  revision(): number;
-  subscribe(listener: (change: CollectionImpact<K>) => void): Unsubscribe;
-  rebuild(): void;
-  dispose(): void;
-};
-type ProjectionCollectionWriter<K extends string, V> = {
-  set(key: K, value: V): void;
-  remove(key: K): void;
-  order(ids: readonly K[]): void;
-  replace(entries: readonly (readonly [K, V])[]): void;
-};
-type CollectionProcess<S extends ProjectionSources, K extends string, V> = {
-  readonly sources: ProjectionInputs<S>;
-  readonly previous: CollectionRead<K, V>;
-  readonly next: CollectionRead<K, V>;
-  readonly writer: ProjectionCollectionWriter<K, V>;
-};
-type CollectionSpec<S extends ProjectionSources, K extends string, V> = {
-  readonly name?: string;
-  readonly sources: S;
-  readonly isEqual?: (previous: V, next: V) => boolean;
-  readonly build: (input: CollectionProcess<S, K, V>) => {
-    readonly update: (input: CollectionProcess<S, K, V>) => void | {
-      readonly kind: 'rebuild';
-    };
-  };
-};
-declare class ProjectionError extends Error {
-  readonly phase: 'processor' | 'listener' | 'source' | 'blocked';
-  readonly identity: string;
-  readonly revisions: readonly number[];
-  constructor(phase: 'processor' | 'listener' | 'source' | 'blocked', identity: string, revisions: readonly number[], cause: unknown);
-}
-declare class ProjectionDisposedError extends Error {
-  constructor();
-}
-type ProjectionRuntime = {
-  document<S extends DocumentSchema>(runtime: DocumentReadable<S>): DocumentSource<S>;
-  fromReadable<T>(readable: Readable<T>, options?: {
-    readonly isEqual?: (a: T, b: T) => boolean;
-  }): ProjectionSource<ValueInput<T>>;
-  input<T>(initial: T, options?: {
-    readonly isEqual?: (a: T, b: T) => boolean;
-  }): ProjectionInput<T>;
-  value<S extends ProjectionSources, T>(sources: S, compute: (sources: ProjectionInputs<S>) => Synchronous<T>, options?: {
-    readonly isEqual?: (a: NoInfer<T>, b: NoInfer<T>) => boolean;
-  }): ProjectionValue<T>;
-  value<S extends ProjectionSources, T>(spec: ValueSpec<S, T>, options?: {
-    readonly isEqual?: (a: NoInfer<T>, b: NoInfer<T>) => boolean;
-  }): ProjectionValue<T>;
-  collection<V, K extends string = string>(): <S extends ProjectionSources>(spec: CollectionSpec<S, K, V>) => ProjectionCollection<K, V>;
-  map<S extends DocumentSchema, N extends EntitySchemaNode, V>(source: DocumentCollectionSource<S, N>, mapper: (id: string, entry: ReaderOfNode<N>) => Synchronous<V>, options?: {
-    readonly isEqual?: (a: V, b: V) => boolean;
-  }): ProjectionCollection<string, V>;
-  map<K extends string, V, R>(source: ProjectionCollection<K, V>, mapper: (id: K, entry: V) => Synchronous<R>, options?: {
-    readonly isEqual?: (a: NoInfer<R>, b: NoInfer<R>) => boolean;
-  }): ProjectionCollection<K, R>;
-  batch<T>(run: () => Synchronous<T>): T;
-  dispose(): void;
-};
-//#endregion
-//#region core/src/projection/runtime.d.ts
-declare const projectionDebug: (runtime: ProjectionRuntime) => Readonly<{
-  nodes: number;
-  sources: number;
-  subscriptions: number;
-  pending: number;
-}>;
-declare const createProjectionRuntime: (options: {
-  readonly onError: (error: ProjectionError) => void;
-}) => ProjectionRuntime;
-//#endregion
-export { DocumentSource as a, ProjectionError as c, ProjectionSource as d, ProjectionValue as f, DocumentCollectionSource as i, ProjectionInput as l, projectionDebug as n, ProjectionCollection as o, ValueSpec as p, CollectionSpec as r, ProjectionDisposedError as s, createProjectionRuntime as t, ProjectionRuntime as u };
-//# sourceMappingURL=runtime-BFmhzPpZ.d.ts.map