@verdant-web/common 2.3.0-next.0 → 2.3.0

package/dist/esm/EventSubscriber.d.ts

@@ -0,0 +1,18 @@
+export declare class EventSubscriber<Events extends {
+    [key: string]: (...args: any[]) => void;
+}> {
+    private _onAllUnsubscribed?;
+    protected subscribers: Record<string, Record<string, (...args: any[]) => void>>;
+    protected counts: Record<string, number>;
+    private _disabled;
+    protected disposed: boolean;
+    constructor(_onAllUnsubscribed?: ((event: keyof Events) => void) | undefined);
+    get disabled(): boolean;
+    subscriberCount: (event: Extract<keyof Events, string>) => number;
+    totalSubscriberCount: () => number;
+    subscribe: <K extends Extract<keyof Events, string>>(event: K, callback: Events[K]) => () => void;
+    emit: <K extends Extract<keyof Events, string>>(event: K, ...args: Parameters<Events[K]>) => void;
+    dispose: () => void;
+    disable: () => void;
+}
+export type EventsOf<T extends EventSubscriber<any>> = T extends EventSubscriber<infer E> ? keyof E : never;

package/dist/esm/baseline.d.ts

@@ -0,0 +1,5 @@
+export type DocumentBaseline<T extends any = any> = {
+    oid: string;
+    snapshot: T;
+    timestamp: string;
+};

package/dist/esm/batching.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="node" resolution-mode="require"/>
+export declare class Batcher<T, UserData = any> {
+    private flusher;
+    private batches;
+    constructor(flusher: (items: T[], batchKey: string, userData: UserData) => any);
+    add({ key, userData, items, max, timeout, }: {
+        key: string;
+        userData?: UserData;
+        items: T[];
+        max?: number | null;
+        timeout?: number | null;
+    }): Batch<T, UserData>;
+    flush: (key: string) => any;
+    discard: (key: string) => void;
+    flushAll: () => any[];
+    getSize: (key: string) => number;
+}
+export declare class Batch<T, UserData = any> {
+    items: Array<T>;
+    max: number | null;
+    startedAt: number;
+    timeout: number | null;
+    flushTimeout?: NodeJS.Timeout;
+    userData?: any;
+    flusher: (items: T[], batchKey: string, userData: UserData) => any;
+    key: string;
+    constructor({ max, startedAt, timeout, userData, flusher, key, }: {
+        key: string;
+        max: number | null;
+        startedAt: number;
+        timeout: number | null;
+        userData?: UserData;
+        flusher: (items: T[], batchKey: string, userData: UserData) => any;
+    });
+    update: ({ items, max, timeout, userData, }: {
+        items: Array<T>;
+        max?: number | null | undefined;
+        timeout?: number | null | undefined;
+        userData?: UserData | undefined;
+    }) => void;
+    flush: () => any;
+    discard: () => void;
+}

package/dist/esm/error.d.ts

@@ -0,0 +1,22 @@
+export declare enum VerdantErrorCode {
+    InvalidRequest = 4000,
+    BodyRequired = 4001,
+    NoToken = 4010,
+    InvalidToken = 4011,
+    TokenExpired = 4012,
+    Forbidden = 4030,
+    NotFound = 4040,
+    Unexpected = 5000,
+    ConfigurationError = 5010,
+    NoFileStorage = 5011
+}
+export declare class VerdantError extends Error {
+    code: VerdantErrorCode;
+    static Code: typeof VerdantErrorCode;
+    constructor(code: VerdantErrorCode, cause?: Error | undefined, message?: string);
+    get httpStatus(): number;
+    toResponse: () => string;
+}
+export declare function isVerdantErrorResponse(body: any): body is {
+    code: number;
+};

package/dist/esm/files.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" resolution-mode="require"/>
+export type FileRef = {
+    '@@type': 'file';
+    id: string;
+};
+export declare function isFileRef(value: any): value is FileRef;
+export declare function createFileRef(id: string): FileRef;
+export type FileData = {
+    id: string;
+    /**
+     * For locally created files, this starts false, until it's uploaded
+     * Remote files this is always true
+     */
+    remote: boolean;
+    name: string;
+    type: string;
+    file?: Blob;
+    url?: string;
+};
+export declare function getAllFileFields(snapshot: any): [string, FileRef][];

package/dist/esm/index.d.ts

@@ -0,0 +1,21 @@
+export * from './protocol.js';
+export * from './timestamp.js';
+export * from './operation.js';
+export * from './baseline.js';
+export * from './replica.js';
+export * from './schema/index.js';
+export * from './utils.js';
+export * from './indexes.js';
+export { migrate, migrationRange, createDefaultMigration, createMigration, } from './migration.js';
+export type { Migration, MigrationIndexDescription, MigrationEngine, } from './migration.js';
+export type { UserInfo } from './presence.js';
+export * from './patch.js';
+export * from './oids.js';
+export * from './EventSubscriber.js';
+export * from './undo.js';
+export * from './batching.js';
+export * from './files.js';
+export type { Ref } from './refs.js';
+export { makeObjectRef, makeFileRef, isRef, compareRefs } from './refs.js';
+export * from './memo.js';
+export * from './error.js';

package/dist/esm/indexes.d.ts

@@ -0,0 +1,17 @@
+import { StorageCollectionSchema, StorageDirectSyntheticSchema } from './index.js';
+export declare const COMPOUND_INDEX_SEPARATOR = "\uFFFFFE";
+export declare const COMPOUND_INDEX_LOWER_BOUND_SEPARATOR = "\0";
+export declare const COMPOUND_INDEX_UPPER_BOUND_SEPARATOR = "\uFFFFFF";
+type IndexableFieldValue = string | number | boolean | any[];
+export type CompoundIndexValue = string | string[];
+export declare function createCompoundIndexValue(...fields: IndexableFieldValue[]): CompoundIndexValue;
+export declare function createUpperBoundIndexValue(...fields: IndexableFieldValue[]): string;
+export declare function createLowerBoundIndexValue(...fields: IndexableFieldValue[]): string;
+export declare function isDirectSynthetic(index: any): index is StorageDirectSyntheticSchema<any>;
+export declare function computeSynthetics(schema: StorageCollectionSchema, obj: any): Record<string, any>;
+export declare function computeCompoundIndices(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
+export declare function getIndexValues(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
+export declare function assignIndexValues(schema: StorageCollectionSchema<any, any, any>, doc: any): any;
+export declare const NULL_INDEX_VALUE = "null";
+export declare function sanitizeIndexValue(value: unknown): string | number | (string | number)[];
+export {};

package/dist/esm/indexes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/memo.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Memoizes the last invocation of a function with the same memo keys.
+ * As long as key identity and set doesn't change, the last computed
+ * value will be returned.
+ */
+export declare function memoByKeys<TRet, TKeys extends any[]>(fn: (...args: unknown[]) => TRet, getKeys: () => TKeys): (...args: unknown[]) => TRet;

package/dist/esm/memo.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/migration.d.ts

@@ -0,0 +1,174 @@
+import { StorageCollectionSchema, StorageSchema, StorageDocument, CollectionFilter, StorageDocumentInit } from './index.js';
+/**@deprecated */
+export interface DroppedCollectionMigrationStrategy<Old extends StorageCollectionSchema<any, any, any>> {
+    (old: Old): void | Promise<void>;
+}
+/**@deprecated */
+export interface PreservedCollectionMigrationStrategy<Old extends StorageCollectionSchema<any, any, any>, New extends StorageCollectionSchema<any, any, any>> {
+    (old: StorageDocument<Old>): StorageDocument<New> | Promise<StorageDocument<New>>;
+}
+/** @deprecated */
+export type MigrationsKeyedOnCollection<Old extends StorageSchema<any>, New extends StorageSchema<any>> = PreservedCollectionMigrations<Old, New> | DroppedCollectionMigrations<Old, New>;
+/**@deprecated */
+type NotInSchema<Name extends string | number | symbol, Schema extends StorageSchema<any>> = Name extends keyof Schema['collections'] ? never : Name;
+/** @deprecated */
+type InSchema<Name extends string | number | symbol, Schema extends StorageSchema<any>> = Name extends keyof Schema['collections'] ? Name : never;
+/** @deprecated */
+type DroppedCollections<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
+    [Key in keyof Old['collections'] as NotInSchema<Key, New>]: StorageCollectionSchema<any, any, any>;
+};
+/** @deprecated */
+type PreservedCollections<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
+    [Key in keyof Old['collections'] as InSchema<Key, New>]: StorageCollectionSchema<any, any, any>;
+};
+/** @deprecated */
+type DroppedCollectionMigrations<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
+    [Key in keyof DroppedCollections<Old, New>]: DroppedCollectionMigrationStrategy<Old['collections'][Key]>;
+};
+/** @deprecated */
+type PreservedCollectionMigrations<Old extends StorageSchema<any>, New extends StorageSchema<any>> = {
+    [Key in keyof PreservedCollections<Old, New>]: PreservedCollectionMigrationStrategy<Old['collections'][Key], New['collections'][Key]>;
+};
+/** @deprecated */
+type StrategyFor<Key extends string, Old extends StorageSchema<any>, New extends StorageSchema<any>> = Key extends keyof New['collections'] ? PreservedCollectionMigrationStrategy<Old['collections'][Key], New['collections'][Key]> : DroppedCollectionMigrationStrategy<Old['collections'][Key]>;
+/** @deprecated */
+type DeprecatedMigrationRunner<Old extends StorageSchema<any>, New extends StorageSchema<any>> = <Collection extends Extract<keyof Old['collections'], string>>(collection: Collection, strategy: StrategyFor<Collection, Old, New>) => Promise<void>;
+/** @deprecated */
+type DeprecatedMigrationQueryMaker<Collection extends StorageCollectionSchema<any, any, any>> = {
+    get(primaryKey: string): Promise<StorageDocument<Collection> | undefined>;
+    findOne(query: CollectionFilter): Promise<StorageDocument<Collection> | undefined>;
+    findAll(query?: CollectionFilter): Promise<StorageDocument<Collection>[]>;
+};
+/** @deprecated */
+type DeprecatedMigrationQueries<Old extends StorageSchema<any>> = {
+    [Key in keyof Old['collections']]: DeprecatedMigrationQueryMaker<Old['collections'][Key]>;
+};
+/** @deprecated */
+type DeprecatedMigrationMutations<New extends StorageSchema> = {
+    [Key in keyof New['collections']]: {
+        put(document: StorageDocumentInit<New['collections'][Key]>): Promise<StorageDocument<New['collections'][Key]>>;
+        delete(primaryKey: string): Promise<void>;
+    };
+};
+/** @deprecated */
+export interface DeprecatedMigrationTools<Old extends StorageSchema<any>, New extends StorageSchema<any>> {
+    migrate: DeprecatedMigrationRunner<Old, New>;
+    identity: <T>(val: T) => T;
+    /**
+     * @deprecated - default field values are automatically
+     * applied during migration, you don't need to use this.
+     * Please remove it from your migrations - even old ones
+     * (old migrations can be updated!)
+     */
+    withDefaults: (collectionName: string, value: any) => any;
+    queries: DeprecatedMigrationQueries<Old>;
+    mutations: DeprecatedMigrationMutations<New>;
+    info: {
+        changedCollections: keyof Old['collections'][];
+        addedCollections: keyof New['collections'][];
+        removedCollections: keyof Old['collections'][];
+    };
+}
+export interface MigrationEngine {
+    migrate: (collection: string, strategy: (val: any) => any) => Promise<void>;
+    queries: MigrationQueries<any>;
+    mutations: MigrationMutations<any>;
+    /** OIDs of any new documents created during the migration */
+    newOids: string[];
+    /** Promises that should be resolved before completing the migration */
+    awaitables: Promise<any>[];
+    /** Deletes all documents in a collection - used for removed collections */
+    deleteCollection: (collection: string) => Promise<void>;
+    log: (...messages: any[]) => void;
+}
+/** @deprecated */
+type DeprecatedMigrationProcedure<Old extends StorageSchema, New extends StorageSchema> = (tools: DeprecatedMigrationTools<Old, New>) => Promise<void>;
+type EmptySchema = {
+    version: 0;
+    collections: {};
+};
+/** @deprecated - use createMigration */
+export declare function migrate<Schema extends StorageSchema>(schema: Schema, procedure: DeprecatedMigrationProcedure<EmptySchema, Schema>): Migration<EmptySchema, Schema>;
+/** @deprecated = use createMigration */
+export declare function migrate<Old extends StorageSchema, New extends StorageSchema>(oldSchema: Old, newSchema: New, procedure: DeprecatedMigrationProcedure<Old, New>): Migration<Old, New>;
+export interface MigrationIndexDescription {
+    name: string;
+    multiEntry: boolean;
+    synthetic: boolean;
+    compound: boolean;
+}
+export interface Migration<Old extends StorageSchema = any, New extends StorageSchema = any> {
+    version: number;
+    oldSchema: Old;
+    newSchema: New;
+    migrate: (engine: MigrationEngine) => Promise<void>;
+    /** Collections which are added in the new schema and not present in the old */
+    addedCollections: string[];
+    /** Collections which were removed from the old schema */
+    removedCollections: string[];
+    /** All collections which exist after the migration has completed - i.e. the ones in the new schema */
+    allCollections: string[];
+    /** Only the collections which were in the old schema */
+    oldCollections: string[];
+    /** Collections whose fields or indexes changed between schemas */
+    changedCollections: string[];
+    addedIndexes: Record<string, MigrationIndexDescription[]>;
+    removedIndexes: Record<string, MigrationIndexDescription[]>;
+}
+export declare function migrationRange(from: number, to: number): number[];
+/** @deprecated - use createMigration with no procedure function */
+export declare function createDefaultMigration(schema: StorageSchema): Migration<{
+    version: 0;
+    collections: {};
+}>;
+/** @deprecated - use createMigration with no procedure function */
+export declare function createDefaultMigration<Old extends StorageSchema>(oldSchema: Old, newSchema: StorageSchema): Migration<Old>;
+/** New, simpler type-safety migration tools */
+type DocumentShape<Init = any, Snapshot = any> = {
+    init: Init;
+    snapshot: Snapshot;
+};
+type SchemaDocuments = Record<string, DocumentShape>;
+type CollectionProcedure<OldSnapshot, NewInit> = {
+    (old: OldSnapshot): NewInit | Promise<NewInit>;
+};
+type MigrationQueries<Old extends SchemaDocuments> = {
+    [Key in keyof Old]: {
+        get(primaryKey: string): Promise<Old[Key]['snapshot'] | undefined>;
+        findOne(query: CollectionFilter): Promise<Old[Key]['snapshot'] | undefined>;
+        findAll(query?: CollectionFilter): Promise<Old[Key]['snapshot'][]>;
+    };
+};
+type MigrationMutations<New extends SchemaDocuments> = {
+    [Key in keyof New]: {
+        put(document: New[Key]['init']): Promise<New[Key]['snapshot']>;
+        delete(primaryKey: string): Promise<void>;
+    };
+};
+type MigrationTools<Old extends SchemaDocuments, New extends SchemaDocuments> = {
+    /**
+     * Process a change in a collection's documents by taking in each existing
+     * document and returning its new shape. This is typed so you can be
+     * confident the proper transformations are made.
+     */
+    migrate: <Collection extends keyof Old & keyof New>(collection: Collection, strategy: CollectionProcedure<Old[Collection]['snapshot'], New[Collection]['init']>) => Promise<void>;
+    mutations: MigrationMutations<New>;
+    queries: MigrationQueries<Old>;
+    info: {
+        changedCollections: (keyof Old & keyof New)[];
+        addedCollections: (keyof New)[];
+        removedCollections: (keyof Old)[];
+    };
+};
+type MigrationProcedure<Old extends SchemaDocuments, New extends SchemaDocuments> = {
+    (tools: MigrationTools<Old, New>): Promise<void>;
+};
+type InitialMigrationTools<New extends SchemaDocuments> = {
+    mutations: MigrationMutations<New>;
+};
+type InitialMigrationProcedure<New extends SchemaDocuments> = {
+    (tools: InitialMigrationTools<New>): Promise<void>;
+};
+export declare function createMigration<New extends SchemaDocuments>(newSchema: StorageSchema, procedure?: InitialMigrationProcedure<New>): any;
+export declare function createMigration<Old extends SchemaDocuments, New extends SchemaDocuments>(oldSchema: StorageSchema, newSchema: StorageSchema, procedure?: MigrationProcedure<Old, New>): any;
+export {};

package/dist/esm/oids.d.ts

@@ -0,0 +1,101 @@
+import { ObjectRef } from './operation.js';
+/**
+ * OIDs
+ *
+ * OIDs are used to identify objects in the document. They also encode
+ * information about the object useful to identifying an object found
+ * on its own and associating it back to its parent.
+ *
+ * An OID is structured as such:
+ * <collection>/<root id>[/<key paths>]:<random>
+ *
+ * OIDs have a few characteristics:
+ * - They include the collection name of the parent document
+ * - They include the primary key of the parent document
+ * - They include the key path of the object within the document
+ * - They include a random sequence to identify different objects which
+ *   exist at the same key path
+ *
+ * Collection name and document key are used to link any isolated
+ * object back to its parent document.
+ *
+ * The key path is used for authorization - to associate the object
+ * (or an operation related to it by OID) with the field it inhabits
+ * to utilize authorization rules from that field in the schema.
+ *
+ * The random sequence allows the application to encode different
+ * identities for objects at the same position in a document for
+ * conflict resolution purposes
+ */
+export type ObjectIdentifier = string;
+export declare const LEGACY_OID_KEY = "__@@oid_do_not_use";
+export declare const OID_KEY = "@@id";
+export declare function getOid(obj: any): string;
+export declare function maybeGetOid(obj: any): ObjectIdentifier | undefined;
+export declare function assignOid(obj: any, oid: ObjectIdentifier): any;
+export declare function hasOid(obj: any): boolean;
+export declare function removeOid(obj: any): any;
+export declare function isOidKey(key: string): boolean;
+/**
+ * For sub-objects, assign a random sub-OID if no OID
+ * is already assigned.
+ */
+export declare function ensureOid(obj: any, rootOid: ObjectIdentifier, createSubId?: () => string): string;
+export declare function ensureCompatibleOid(obj: any, rootOid: ObjectIdentifier, createSubId?: () => string): string;
+export declare function createOid(collection: string, documentId: string, subId?: string): string;
+export declare function createSubOid(root: ObjectIdentifier, createSubId?: () => string): string;
+export declare function decomposeOid(oid: ObjectIdentifier): {
+    collection: string;
+    id: string;
+    subId?: string;
+};
+export declare function assertAllLevelsHaveOids(obj: any, root?: any): void;
+export declare function assignOidsToAllSubObjects(obj: any, createSubId?: () => string): void;
+export declare function assignOidProperty(obj: any, oid: ObjectIdentifier): any;
+export declare function maybeGetOidProperty(obj: any): any;
+/**
+ * Assigns a special property to all objects in the given object
+ * which have an OID
+ */
+export declare function assignOidPropertiesToAllSubObjects(obj: any): void;
+/**
+ *
+ * Removes the special property from all objects in the given object
+ * which have an OID, transferring the OID from the property to the OID
+ * system in-memory.
+ */
+export declare function removeOidPropertiesFromAllSubObjects(obj: any): void;
+export declare function removeOidsFromAllSubObjects(obj: any): void;
+export declare function createOidSubId(): string;
+export declare function createRef(oid: ObjectIdentifier): ObjectRef;
+export declare function normalize(obj: any, refs?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
+/**
+ * Only normalizes direct children. The created map
+ * of objects will still have nested objects.
+ */
+export declare function normalizeFirstLevel(obj: any): {
+    refs: Map<string, any>;
+    oidKeyPairs: Map<string, string | number>;
+};
+export declare function getOidRoot(oid: ObjectIdentifier): string;
+/**
+ * Returns an inclusive range of OIDs that represent
+ * all of an OID's possible sub-objects.
+ */
+export declare function getOidSubIdRange(oid: ObjectIdentifier): string[];
+export declare function getLegacyDotOidSubIdRange(oid: ObjectIdentifier): string[];
+export declare function getRoots(oids: ObjectIdentifier[]): string[];
+export declare function areOidsRelated(oidA: ObjectIdentifier, oidB: ObjectIdentifier): boolean;
+/**
+ * Recursively rewrites any OIDs in an object which are 'foreign' -
+ * i.e. relate to some other object/entity - to be local to the
+ * current object. This is deterministic, so it can be done
+ * on multiple clients independently with predictable results.
+ */
+export declare function fixForeignOids(obj: any): void;
+export declare function isLegacyDotOid(oid: ObjectIdentifier): boolean;
+export declare function convertLegacyOid(oid: ObjectIdentifier): string;
+export declare const MATCH_LEGACY_OID_JSON_STRING: RegExp;
+export declare function replaceLegacyOidsInJsonString(string: string): string;
+export declare function replaceLegacyOidsInObject(obj: any): any;
+export declare function isRootOid(oid: ObjectIdentifier): boolean;

package/dist/esm/oids.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/operation.d.ts

@@ -0,0 +1,142 @@
+import { DocumentBaseline } from './baseline.js';
+import { FileRef } from './files.js';
+import { ObjectIdentifier } from './oids.js';
+export type ObjectRef = {
+    '@@type': 'ref';
+    id: ObjectIdentifier;
+};
+export declare function isObjectRef(obj: any): obj is ObjectRef;
+export type Normalized<T> = {
+    [key in keyof T]: T[key] extends Object ? ObjectRef : T[key];
+};
+export type PropertyName = string | number;
+/**
+ * List patches can target a particular child list or
+ * nested lists. The first path item is the property path
+ * of the first child list, any subsequent values are nested
+ * list indices.
+ */
+export type PropertyValue = string | number | boolean | null | undefined | ObjectRef | FileRef;
+interface BaseOperationPatch {
+}
+export interface OperationPatchInitialize extends BaseOperationPatch {
+    op: 'initialize';
+    value: any;
+}
+export interface OperationPatchSet extends BaseOperationPatch {
+    op: 'set';
+    name: PropertyName;
+    value: PropertyValue;
+}
+export interface OperationPatchRemove extends BaseOperationPatch {
+    op: 'remove';
+    name: PropertyName;
+}
+export interface OperationPatchListPush extends BaseOperationPatch {
+    op: 'list-push';
+    value: PropertyValue;
+}
+export interface OperationPatchListInsert extends BaseOperationPatch {
+    op: 'list-insert';
+    index: number;
+    value?: PropertyValue;
+    values?: PropertyValue[];
+}
+export interface OperationPatchListDelete extends BaseOperationPatch {
+    op: 'list-delete';
+    index: number;
+    count: number;
+}
+/**
+ * Optimal for lists of object references. Moves
+ * the selected item to the target index even if it
+ * is not at the original index anymore.
+ */
+export interface OperationPatchListMoveByRef extends BaseOperationPatch {
+    op: 'list-move-by-ref';
+    value: ObjectRef | FileRef;
+    index: number;
+}
+/**
+ * Suitable for any list move, whether object lists
+ * or primitive lists.
+ */
+export interface OperationPatchListMoveByIndex extends BaseOperationPatch {
+    op: 'list-move-by-index';
+    from: number;
+    to: number;
+}
+/**
+ * Removes all instances of the value from
+ * the list. Good for set behavior or removing
+ * a specific item even if it changes index
+ * from conflicts.
+ */
+export interface OperationPatchListRemove extends BaseOperationPatch {
+    op: 'list-remove';
+    value: PropertyValue;
+    only?: 'first' | 'last';
+}
+export interface OperationPatchListAdd extends BaseOperationPatch {
+    op: 'list-add';
+    value: PropertyValue;
+}
+export interface OperationPatchDelete extends BaseOperationPatch {
+    op: 'delete';
+}
+export interface OperationPatchTouch extends BaseOperationPatch {
+    op: 'touch';
+}
+export type OperationPatch = OperationPatchInitialize | OperationPatchSet | OperationPatchRemove | OperationPatchListPush | OperationPatchListInsert | OperationPatchListDelete | OperationPatchListMoveByRef | OperationPatchListMoveByIndex | OperationPatchListRemove | OperationPatchDelete | OperationPatchListAdd | OperationPatchTouch;
+export type Operation = {
+    oid: ObjectIdentifier;
+    timestamp: string;
+    data: OperationPatch;
+};
+export declare function diffToPatches<T extends {
+    [key: string]: any;
+} | any[]>(from: T, to: T, getNow: () => string, createSubId?: () => string, patches?: Operation[], options?: {
+    /**
+     * If an object is merged with another and the new one does not
+     * have an OID assigned, assume it is the same identity as previous
+     */
+    mergeUnknownObjects?: boolean;
+    /**
+     * If an incoming value is not assigned on the new object, use the previous value.
+     * If false, undefined properties will erase the previous value.
+     */
+    defaultUndefined?: boolean;
+}): Operation[];
+export declare function shallowDiffToPatches(from: any, to: any, getNow: () => string, patches?: Operation[]): Operation[];
+/**
+ * Takes a basic object and constructs a patch list to create it and
+ * all of its nested objects.
+ */
+export declare function initialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, createSubId?: () => string, patches?: Operation[]): Operation[];
+export declare function shallowInitialToPatches(initial: any, rootOid: ObjectIdentifier, getNow: () => string, patches?: Operation[]): Operation[];
+export declare function groupPatchesByOid(patches: Operation[]): Record<string, Operation[]>;
+export declare function groupPatchesByRootOid(patches: Operation[]): Record<string, Operation[]>;
+export declare function groupBaselinesByRootOid(baselines: DocumentBaseline[]): Record<string, DocumentBaseline[]>;
+export type NormalizedObject = {
+    [key: PropertyName]: PropertyValue;
+} | Array<PropertyValue>;
+/**
+ * The incoming object should already be normalized!
+ * This function will mutate the base object.
+ */
+export declare function applyPatch<T extends NormalizedObject>(base: T | undefined, patch: OperationPatch, 
+/**
+ * Optionally supply a list to which any refs which
+ * are removed during the patch will be appended.
+ */
+deletedRefs?: (FileRef | ObjectRef)[]): T | undefined;
+export declare function applyOperations<T extends NormalizedObject>(base: T | undefined, operations: Operation[], deletedRefs?: (ObjectRef | FileRef)[]): T | undefined;
+/**
+ * Mutates the original object in place. Returns all referenced
+ * objects oids.
+ */
+export declare function substituteRefsWithObjects(base: any, refs: Map<ObjectIdentifier, any>, used?: ObjectIdentifier[]): ObjectIdentifier[];
+export declare function substituteFirstLevelObjectsWithRefs<Base extends {
+    [key: string]: any;
+} | any[]>(base: Base, refObjects?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
+export {};

package/dist/esm/operation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/patch.d.ts

@@ -0,0 +1,28 @@
+/**
+ * High-level patch creation for use with complex nested objects.
+ */
+import { FileRef } from './files.js';
+import { ObjectIdentifier } from './oids.js';
+import { ObjectRef, Operation, PropertyName } from './operation.js';
+export declare class PatchCreator {
+    private getNow;
+    private createSubId?;
+    constructor(getNow: () => string, createSubId?: (() => string) | undefined);
+    isPrimitive: (value: any) => boolean;
+    createDiff: (from: any, to: any, options?: {
+        mergeUnknownObjects?: boolean;
+        defaultUndefined?: boolean;
+    }) => Operation[];
+    createInitialize: (obj: any, oid: ObjectIdentifier) => Operation[];
+    createSet: (oid: ObjectIdentifier, key: PropertyName, value: any) => Operation[];
+    createRemove: (oid: ObjectIdentifier, key: PropertyName) => Operation[];
+    createListPush: (oid: ObjectIdentifier, value: any) => Operation[];
+    createListAdd: (oid: ObjectIdentifier, value: any) => Operation[];
+    createListInsert: (oid: ObjectIdentifier, index: number, value: any) => Operation[];
+    createListRemove: (oid: ObjectIdentifier, value: any, only?: 'first' | 'last') => Operation[];
+    createListDelete: (oid: ObjectIdentifier, index: number, count?: number) => Operation[];
+    createListMoveByRef: (oid: ObjectIdentifier, value: ObjectRef | FileRef, index: number) => Operation[];
+    createListMoveByIndex: (oid: ObjectIdentifier, fromIndex: number, toIndex: number) => Operation[];
+    createDelete: (oid: ObjectIdentifier) => Operation[];
+    createDeleteAll: (oids: ObjectIdentifier[]) => Operation[];
+}

package/dist/esm/presence.d.ts

@@ -0,0 +1,29 @@
+export interface UserInfo<Profile, Presence> {
+    /**
+     * @deprecated - include the ID in your Profile data instead.
+     *
+     * This is the ID representing the user who is utilizing a
+     * replica client to connect to the storage network.
+     * One user may have multiple replica clients active at once,
+     * but their presence will only reflect the most recent
+     * replica used.
+     */
+    id: string;
+    /**
+     * This is the ID representing the replica client that is
+     * connected to the storage network. This is used to
+     * identify the client when sending messages to it.
+     */
+    replicaId: string;
+    /**
+     * This is the user's server profile. This data is associated
+     * with the logged in user of the app and cannot be modified
+     * by the local replica directly.
+     */
+    profile: Profile;
+    /**
+     * Presence info which can update frequently as a replica
+     * makes changes. The shape of presence is up to you.
+     */
+    presence: Presence;
+}