doxum 0.1.7 → 0.1.9

package/dist/contract-BNStLbSE.d.ts

@@ -0,0 +1,441 @@
+//#region core/src/schema-value.d.ts
+/** Pure synchronous validation. Successful output is ignored; input is never transformed. */
+type Validator<T> = ((value: unknown) => T) | {
+  readonly '~standard': {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly types?: {
+      readonly input: unknown;
+      readonly output: T;
+    };
+    validate(value: unknown): {
+      readonly value: T;
+      readonly issues?: undefined;
+    } | {
+      readonly issues: readonly {
+        readonly message: string;
+        readonly path?: readonly (PropertyKey | {
+          readonly key: PropertyKey;
+        })[];
+      }[];
+    } | PromiseLike<unknown>;
+  };
+};
+type ParseIssue = {
+  readonly address: DocumentAddress;
+  readonly code: 'invalid-value' | 'invalid-key' | 'missing-validator' | 'invalid-tree';
+  readonly message: string;
+};
+declare class ParseError extends TypeError {
+  readonly issues: readonly ParseIssue[];
+  constructor(issue: ParseIssue);
+}
+declare const parse: <N extends DocumentNode>(node: N, input: unknown) => Infer<N>;
+//#endregion
+//#region core/src/schema.d.ts
+type DocumentAddress = readonly string[];
+/** Shared payloads are immutable through every alias, including builtin methods. */
+type ReadonlyValue<T> = T extends ((...args: never[]) => unknown) ? T : T extends ReadonlyMap<infer K, infer V> ? ReadonlyMap<ReadonlyValue<K>, ReadonlyValue<V>> : T extends ReadonlySet<infer V> ? ReadonlySet<ReadonlyValue<V>> : T extends Date ? Omit<Date, `set${string}`> : T extends object ? { readonly [K in keyof T]: ReadonlyValue<T[K]> } : T;
+type DocumentListConfig<TItem> = {
+  readonly keyOf: (item: ReadonlyValue<TItem>) => string;
+};
+type DocumentTreeNode<TValue> = {
+  readonly parentId?: string;
+  readonly children: readonly string[];
+  readonly value?: ReadonlyValue<TValue>;
+};
+type DocumentTreeValue<TValue> = {
+  readonly rootId?: string;
+  readonly nodes: Readonly<Record<string, DocumentTreeNode<TValue>>>;
+};
+type BaseNode<K extends string> = {
+  readonly kind: K;
+  readonly optional?: boolean;
+};
+type FieldNode<T, Optional extends boolean = false> = BaseNode<'field'> & {
+  readonly __value?: T;
+  readonly validator?: Validator<T>;
+} & (Optional extends true ? {
+  readonly optional: true;
+} : {
+  readonly optional?: false;
+});
+/** A node with optional presence. The marker replaces, rather than intersects, a field marker. */
+type OptionalNode<TNode extends DocumentNode> = TNode extends FieldNode<infer TValue, boolean> ? FieldNode<TValue, true> : TNode & {
+  readonly optional: true;
+};
+interface ObjectShape {
+  readonly [key: string]: DocumentNode;
+}
+type ObjectNode<TShape extends ObjectShape = ObjectShape> = BaseNode<'object'> & {
+  readonly shape: TShape;
+};
+interface VariantShape {
+  readonly [key: string]: ObjectNode<ObjectShape>;
+}
+type VariantNode<TTag extends string, TVariants extends VariantShape> = BaseNode<'variant'> & {
+  readonly tag: TTag;
+  readonly variants: TVariants;
+};
+type TableNode<TValue extends ObjectNode<ObjectShape> | VariantNode<string, VariantShape>, TKey extends string = string> = BaseNode<'table'> & {
+  readonly value: TValue;
+  readonly key?: Validator<TKey>;
+};
+type MapNode<TValue extends ValueSchemaNode, TKey extends string = string> = BaseNode<'map'> & {
+  readonly value: TValue;
+  readonly key?: Validator<TKey>;
+};
+type ListNode<TItem> = BaseNode<'list'> & {
+  readonly value: FieldNode<TItem, boolean>;
+  keyOf(item: ReadonlyValue<TItem>): string;
+};
+type TreeNode<TValue> = BaseNode<'tree'> & {
+  readonly value: FieldNode<TValue, boolean>;
+};
+type DocumentNode = FieldNode<unknown, false> | FieldNode<unknown, true> | ObjectNode<ObjectShape> | VariantNode<string, VariantShape> | TableNode<ObjectNode<ObjectShape> | VariantNode<string, VariantShape>> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown>;
+type SchemaObject<T> = { [K in keyof T]: T[K] } & {};
+/** Infer a document or node value, including optional node presence. */
+type Infer<T extends DocumentNode> = T extends {
+  readonly optional: true;
+} ? NodeValue<T> | undefined : NodeValue<T>;
+type NodeValue<N> = N extends FieldNode<infer T, infer O> ? O extends true ? ReadonlyValue<T> | undefined : ReadonlyValue<T> : N extends ObjectNode<infer S> ? ShapeValue<S> : N extends VariantNode<infer T, infer V> ? { [K in keyof V & string]: SchemaObject<{ readonly [P in T]: K } & NodeValue<V[K]>> }[keyof V & string] : N extends TableNode<infer V, infer K> ? {
+  readonly ids: readonly K[];
+  readonly byId: Readonly<Record<K, NodeValue<V>>>;
+} : N extends MapNode<infer V, infer K> ? Readonly<Record<K, NodeValue<V>>> : N extends ListNode<infer I> ? readonly ReadonlyValue<I>[] : N extends TreeNode<infer T> ? DocumentTreeValue<T> : never;
+type OptionalKeys<S extends ObjectShape> = { [K in keyof S]: S[K] extends {
+  readonly optional: true;
+} ? K : never }[keyof S];
+type RequiredKeys<S extends ObjectShape> = Exclude<keyof S, OptionalKeys<S>>;
+type ShapeValue<S extends ObjectShape> = SchemaObject<{ readonly [K in RequiredKeys<S>]: NodeValue<S[K]> } & { readonly [K in OptionalKeys<S>]?: NodeValue<S[K]> }>;
+type EntitySchemaNode = ObjectNode<ObjectShape> | VariantNode<string, VariantShape>;
+type ValueSchemaNode = EntitySchemaNode | FieldNode<unknown, boolean>;
+type DocumentAnchor<K extends string = string> = {
+  readonly at: 'start' | 'end';
+} | {
+  readonly before: K;
+} | {
+  readonly after: K;
+};
+type CollectionSelector<TId extends string = string, TNode extends ValueSchemaNode = ValueSchemaNode> = {
+  readonly kind: 'collection';
+  readonly schema: ObjectNode;
+  readonly address: DocumentAddress;
+  readonly __id?: TId; /** Compile-time entry schema carried by schema selectors. */
+  readonly __node?: TNode;
+};
+type ValueSelector<TResult = unknown> = {
+  readonly kind: 'value';
+  readonly schema: ObjectNode;
+  readonly address: DocumentAddress;
+  readonly __value?: TResult;
+};
+type ImpactTarget<T = unknown> = {
+  readonly kind: 'value';
+  readonly at: DocumentAddress;
+} | ValueSelector<T> | {
+  readonly kind: 'collection';
+  readonly at: DocumentAddress;
+  readonly id?: string;
+} | CollectionSelector<string>;
+declare const pathValue: unique symbol;
+declare const collectionNode: unique symbol;
+declare const collectionKey: unique symbol;
+type PathMarker<TValue> = {
+  readonly [pathValue]: TValue;
+};
+type SchemaPathFor<S extends ObjectShape = ObjectShape, TValue = unknown> = { readonly [K in keyof S]: PathValue<S[K]> } & PathMarker<TValue>;
+type SchemaPath<S extends ObjectShape = ObjectShape> = SchemaPathFor<S, ShapeValue<S>>;
+type PathPick<S extends ObjectNode = ObjectNode> = (path: SchemaPath<S['shape']>) => PathMarker<unknown>;
+type VariantKeys<V extends VariantShape> = { [K in keyof V & string]: keyof (V[K] extends ObjectNode<infer S> ? S : {}) }[keyof V & string] & string;
+type VariantFieldPath<V extends VariantShape, K extends string> = { [P in keyof V & string]: V[P] extends ObjectNode<infer S> ? K extends keyof S ? PathValue<S[K]> : never : never }[keyof V & string];
+type VariantPath<T extends string, V extends VariantShape, TValue> = { readonly [K in VariantKeys<V>]: VariantFieldPath<V, K> } & { readonly [K in T]: PathMarker<keyof V & string> } & PathMarker<TValue>;
+type CollectionPath<N extends ValueSchemaNode = ValueSchemaNode, TValue = unknown, K extends string = string> = PathMarker<TValue> & {
+  item(id: K): PathValue<N>;
+  readonly [collectionNode]: N;
+  readonly [collectionKey]: K;
+};
+type PathValue<N extends DocumentNode> = N extends ObjectNode<infer S> ? SchemaPathFor<S, Infer<N>> : N extends VariantNode<infer TTag, infer V> ? VariantPath<TTag, V, Infer<N>> : N extends TableNode<infer V, infer K> ? CollectionPath<V, Infer<N>, K> : N extends MapNode<infer V, infer K> ? CollectionPath<V, Infer<N>, K> : PathMarker<Infer<N>>;
+type CollectionInfo<T> = T extends {
+  readonly [collectionNode]: infer TNode extends ValueSchemaNode;
+  readonly [collectionKey]: infer K extends string;
+} ? {
+  readonly id: K;
+  readonly node: TNode;
+} : never;
+type CollectionId<T> = CollectionInfo<T> extends {
+  readonly id: infer TId extends string;
+} ? TId : string;
+type CollectionNode<T> = CollectionInfo<T> extends {
+  readonly node: infer TNode extends ValueSchemaNode;
+} ? TNode : ValueSchemaNode;
+declare const field: <T>(validator?: Validator<T>) => FieldNode<T>;
+type OptionalLeaf = FieldNode<unknown, boolean> | VariantNode<string, VariantShape> | MapNode<ValueSchemaNode> | ListNode<unknown> | TreeNode<unknown>;
+declare const optional: <T extends OptionalLeaf>(value: T) => OptionalNode<T>;
+declare const object: <S extends ObjectShape>(shape: S) => ObjectNode<S>;
+declare const variant: <T extends string, V extends VariantShape>(tag: T, variants: V) => VariantNode<T, V>;
+declare const table: <V extends EntitySchemaNode, K extends string = string>(value: V, options?: {
+  readonly key: Validator<K>;
+}) => TableNode<V, K>;
+declare const map: <V extends ValueSchemaNode, K extends string = string>(value: V, options?: {
+  readonly key: Validator<K>;
+}) => MapNode<V, K>;
+declare const list: <TItem>(value: FieldNode<TItem, boolean>, config: DocumentListConfig<TItem>) => ListNode<TItem>;
+declare const tree: <TValue>(value: FieldNode<TValue, boolean>) => TreeNode<TValue>;
+//#endregion
+//#region core/src/changes.d.ts
+type ValueTransition<T = unknown> = {
+  readonly kind: 'added';
+  readonly after: T;
+} | {
+  readonly kind: 'removed';
+  readonly before: T;
+} | {
+  readonly kind: 'updated';
+  readonly before: T;
+  readonly after: T;
+};
+type MemberChange<T = unknown> = ValueTransition<T> & {
+  readonly key: string;
+};
+type Change = {
+  readonly kind: 'members';
+  readonly at: DocumentAddress;
+  readonly members: readonly MemberChange[];
+  readonly order?: {
+    readonly before: readonly string[];
+    readonly after: readonly string[];
+  };
+} | {
+  readonly kind: 'tree';
+  readonly at: DocumentAddress;
+  readonly before: string | null;
+  readonly after: string | null;
+  readonly nodes: readonly (ValueTransition<DocumentTreeNode<unknown>> & {
+    readonly id: string;
+  })[];
+} | {
+  readonly kind: 'reset';
+  readonly before: unknown;
+  readonly after: unknown;
+};
+/** One reversible, normalized state transition. Addresses are schema addresses. */
+type ChangeSet = {
+  readonly changes: readonly Change[];
+};
+//#endregion
+//#region core/src/mutation/tree.d.ts
+type TreePosition = {
+  readonly parentId?: string;
+  readonly index?: number;
+};
+//#endregion
+//#region core/src/address.d.ts
+/** The only resolved address representation used inside the runtime. */
+type AddressRef = {
+  readonly path: number;
+  readonly address: DocumentAddress;
+};
+declare const resolveAddress: (schema: ObjectNode, address: DocumentAddress, document?: unknown) => AddressRef | undefined;
+declare const read: (root: unknown, address: DocumentAddress, schema: DocumentNode) => unknown;
+declare const contains: (parent: DocumentAddress, child: DocumentAddress) => boolean;
+declare const overlaps: (a: DocumentAddress, b: DocumentAddress) => boolean;
+declare const debugKey: (address: DocumentAddress) => string;
+//#endregion
+//#region core/src/access/scope.d.ts
+declare const scopeValue: unique symbol;
+type Scoped<N extends DocumentNode> = {
+  readonly [scopeValue]?: Infer<N>;
+};
+type ShapeAccess<S extends ObjectShape, W extends boolean> = W extends true ? { -readonly [K in keyof S]: Access<S[K], W> } : { readonly [K in keyof S]: Access<S[K], W> };
+type TableAccess<K extends string, N extends ValueSchemaNode, W extends boolean> = {
+  get(id: K): Access<N, W> | undefined;
+  has(id: K): boolean;
+  ids(): readonly K[];
+} & (W extends true ? {
+  create(entries: {
+    readonly id: K;
+    readonly value: Infer<N>;
+  } | readonly {
+    readonly id: K;
+    readonly value: Infer<N>;
+  }[], anchor?: DocumentAnchor<K>): void;
+  remove(ids: K | readonly K[]): void;
+  move(id: K, anchor?: DocumentAnchor<K>): void;
+} : {});
+type ListAccess<T, W extends boolean> = {
+  get(key: string): ReadonlyValue<T> | undefined;
+  has(key: string): boolean;
+  ids(): readonly string[];
+} & (W extends true ? {
+  insert(value: ReadonlyValue<T>, anchor?: DocumentAnchor): void;
+  set(key: string, value: ReadonlyValue<T>): void;
+  remove(key: string): void;
+  move(key: string, anchor?: DocumentAnchor): void;
+  replace(value: readonly ReadonlyValue<T>[]): void;
+} : {});
+type TreeAccess<T, W extends boolean> = {
+  rootId(): string | undefined;
+  get(id: string): ReadonlyValue<T> | undefined;
+  has(id: string): boolean;
+  parent(id: string): string | undefined;
+  children(id: string): readonly string[] | undefined;
+} & (W extends true ? {
+  insert(id: string, value: ReadonlyValue<T>, position?: TreePosition): void;
+  set(id: string, value: ReadonlyValue<T>): void;
+  move(id: string, position?: TreePosition): void;
+  remove(id: string): void;
+  replace(value: DocumentTreeValue<T>): void;
+} : {});
+type NodeAccess<N extends DocumentNode, W extends boolean> = N extends FieldNode<infer T, boolean> ? ReadonlyValue<T> : N extends ObjectNode<infer S> ? ShapeAccess<S, W> & Scoped<N> : N extends VariantNode<infer Tag, infer V> ? { [K in keyof V & string]: ShapeAccess<V[K]['shape'], W> & { readonly [P in Tag]: K } & Scoped<N> }[keyof V & string] : N extends MapNode<infer V, infer K> ? (W extends true ? { [P in K]: Access<V, W> | undefined } : { readonly [P in K]: Access<V, W> | undefined }) & Scoped<N> : N extends TableNode<infer V, infer K> ? TableAccess<K, V, W> & Scoped<N> : N extends ListNode<infer T> ? ListAccess<T, W> & Scoped<N> : N extends TreeNode<infer T> ? TreeAccess<T, W> & Scoped<N> : never;
+type Access<N extends DocumentNode, W extends boolean> = N extends {
+  readonly optional: true;
+} ? NodeAccess<N, W> | undefined : NodeAccess<N, W>;
+type Read<N extends DocumentNode> = Access<N, false>;
+type Draft<N extends DocumentNode> = Access<N, true>;
+type Snapshot<T> = T extends {
+  readonly [scopeValue]?: infer V;
+} ? V : ReadonlyValue<T>;
+declare const snapshot: <T>(value: T) => Snapshot<T>;
+/** TypeScript cannot express asymmetric index signatures for nested collection tools. */
+declare const assign: <T extends object, K extends keyof Snapshot<T>>(container: T, key: K, value: NoInfer<Snapshot<T>[K]>) => void;
+/** Projection collection contexts use the same scoped access, with explicit collection tools. */
+type CollectionAccess<K extends string, N extends ValueSchemaNode> = TableAccess<K, N, false>;
+//#endregion
+//#region core/src/impact.d.ts
+type CollectionImpact<K> = {
+  readonly kind: 'reset';
+} | {
+  readonly kind: 'incremental';
+  readonly added: ReadonlySet<K>;
+  readonly removed: ReadonlySet<K>;
+  readonly updated: ReadonlySet<K>;
+  readonly orderChanged: boolean;
+};
+type DocumentImpact<S extends ObjectNode> = {
+  readonly kind: 'incremental' | 'reset';
+  affects(pick: PathPick<S>): boolean;
+  collection<P extends CollectionPath>(pick: (path: SchemaPath<S['shape']>) => P): CollectionImpact<CollectionId<P>>;
+};
+//#endregion
+//#region core/src/mutation/issue.d.ts
+type MutationIssueCode = 'invalid-address' | 'invalid-value' | 'invalid-key' | 'invalid-changes' | 'baseline-mismatch' | 'required-field' | 'invalid-anchor' | 'duplicate-entity' | 'missing-entity' | 'invalid-collection' | 'invalid-list-keys' | 'invalid-list-key' | 'duplicate-list-item' | 'missing-list-item' | 'invalid-tree' | 'duplicate-tree-node' | 'missing-tree-parent' | 'invalid-tree-index' | 'missing-tree-node' | 'tree-cycle';
+type MutationIssue = {
+  readonly source: 'mutation';
+  readonly code: MutationIssueCode;
+  readonly address: DocumentAddress;
+  readonly message: string;
+};
+//#endregion
+//#region core/src/projection/readable.d.ts
+type Readable<TValue> = {
+  current(): TValue;
+  revision(): number;
+  subscribe(listener: () => void): Unsubscribe;
+};
+//#endregion
+//#region core/src/runtime/contract.d.ts
+type Unsubscribe = () => void;
+type Synchronous<T> = T extends PromiseLike<unknown> ? never : T;
+type CommitSource = 'local' | 'system' | 'history' | 'remote';
+declare class DocumentReentrancyError extends Error {
+  constructor();
+}
+declare class DocumentDisposedError extends Error {
+  constructor();
+}
+type DiagnosticInput = {
+  readonly code: string;
+  readonly message: string;
+  readonly address?: DocumentAddress;
+};
+type DocumentDiagnostic = DiagnosticInput & {
+  readonly source: 'application';
+};
+type DocumentProblem = DocumentDiagnostic | MutationIssue;
+declare class TransactionRejected extends Error {
+  readonly issues: readonly DocumentDiagnostic[];
+  constructor(input: DiagnosticInput | readonly DiagnosticInput[]);
+}
+type DocumentCommit<S extends ObjectNode> = {
+  readonly revision: number;
+  readonly source: CommitSource;
+  readonly changes: ChangeSet;
+  readonly impact: DocumentImpact<S>;
+};
+type ObserverError = {
+  readonly phase: 'processor' | 'flush' | 'listener';
+  readonly error: unknown;
+};
+type TransactionResult<V, C> = {
+  readonly status: 'committed';
+  readonly value: V;
+  readonly commit: C;
+  readonly observerErrors: readonly ObserverError[];
+} | {
+  readonly status: 'unchanged';
+  readonly value: V;
+  readonly revision: number;
+} | {
+  readonly status: 'rejected';
+  readonly issues: readonly DocumentProblem[];
+  readonly revision: number;
+};
+type OperationResult<C> = {
+  readonly status: 'committed';
+  readonly commit: C;
+  readonly observerErrors: readonly ObserverError[];
+} | {
+  readonly status: 'unchanged';
+  readonly revision: number;
+} | {
+  readonly status: 'rejected';
+  readonly issues: readonly MutationIssue[];
+  readonly revision: number;
+};
+type HistoryState = {
+  readonly undoDepth: number;
+  readonly redoDepth: number;
+};
+type LocalHistory<C> = Readable<HistoryState> & {
+  undo(): OperationResult<C>;
+  redo(): OperationResult<C>;
+  clear(): void;
+  group(): {
+    end(): void;
+    cancel(): OperationResult<C>;
+  };
+};
+type CommitListener<S extends ObjectNode> = (commit: DocumentCommit<S>) => void;
+type DocumentReadable<S extends ObjectNode> = {
+  readonly address: {
+    resolve(address: DocumentAddress): AddressRef | undefined;
+    read(address: DocumentAddress): unknown;
+    contains(parent: DocumentAddress, child: DocumentAddress): boolean;
+    overlaps(left: DocumentAddress, right: DocumentAddress): boolean;
+    debugKey(address: DocumentAddress): string;
+  };
+  revision(): number;
+  subscribe(listener: CommitListener<S>): Unsubscribe;
+  subscribe(pick: PathPick<S> | readonly [PathPick<S>, ...PathPick<S>[]], listener: CommitListener<S>): Unsubscribe;
+};
+type DocumentRuntime<S extends ObjectNode> = DocumentReadable<S> & {
+  readonly schema: S;
+  update<V>(run: (draft: Draft<S>) => Synchronous<V>, options?: {
+    readonly source?: Extract<CommitSource, 'local' | 'system'>;
+    readonly history?: boolean;
+  }): TransactionResult<V, DocumentCommit<S>>;
+  apply(changes: unknown, options: {
+    readonly expectedRevision: number;
+    readonly source?: Exclude<CommitSource, 'history'>;
+    readonly history?: boolean;
+  }): OperationResult<DocumentCommit<S>>;
+  replace(value: Infer<S>, options?: {
+    readonly source?: Extract<CommitSource, 'system' | 'remote'>;
+  }): OperationResult<DocumentCommit<S>>;
+  snapshot(): Infer<S>;
+  readonly history: LocalHistory<DocumentCommit<S>>;
+  dispose(): void;
+};
+//#endregion
+export { ObjectShape as $, debugKey as A, CollectionPath as B, CollectionAccess as C, snapshot as D, assign as E, ChangeSet as F, DocumentTreeNode as G, DocumentAnchor as H, MemberChange as I, ImpactTarget as J, DocumentTreeValue as K, ValueTransition as L, read as M, resolveAddress as N, AddressRef as O, Change as P, ObjectNode as Q, CollectionId as R, DocumentImpact as S, Read as T, DocumentListConfig as U, DocumentAddress as V, DocumentNode as W, ListNode as X, Infer as Y, MapNode as Z, Unsubscribe as _, ParseError as _t, DocumentDisposedError as a, TreeNode as at, MutationIssueCode as b, parse as bt, DocumentReentrancyError as c, VariantShape as ct, LocalHistory as d, map as dt, OptionalNode as et, ObserverError as f, object as ft, TransactionResult as g, variant as gt, TransactionRejected as h, tree as ht, DocumentDiagnostic as i, TableNode as it, overlaps as j, contains as k, DocumentRuntime as l, field as lt, Synchronous as m, table as mt, CommitSource as n, ReadonlyValue as nt, DocumentProblem as o, ValueSchemaNode as ot, OperationResult as p, optional as pt, FieldNode as q, DocumentCommit as r, SchemaPath as rt, DocumentReadable as s, VariantNode as st, CommitListener as t, PathPick as tt, HistoryState as u, list as ut, Readable as v, ParseIssue as vt, Draft as w, CollectionImpact as x, MutationIssue as y, Validator as yt, CollectionNode as z };
+//# sourceMappingURL=contract-BNStLbSE.d.ts.map