@verdant-web/store 3.4.0-next.0 → 3.4.0

package/dist/esm/entities/EntityMetadata.d.ts

@@ -0,0 +1,68 @@
+import { DocumentBaseline, ObjectIdentifier, Operation } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { EntityChange } from './types.js';
+export type EntityMetadataView = {
+    view: any;
+    fromOlderVersion: boolean;
+    deleted: boolean;
+    empty: boolean;
+    updatedAt: number;
+};
+export declare class EntityMetadata {
+    private ctx;
+    private baseline;
+    private confirmedOperations;
+    private pendingOperations;
+    readonly oid: string;
+    constructor({ oid, ctx, confirmedOperations, pendingOperations, baseline, }: {
+        oid: ObjectIdentifier;
+        ctx: Context;
+        confirmedOperations?: Operation[];
+        pendingOperations?: Operation[];
+        baseline?: DocumentBaseline;
+    });
+    /**
+     * Compute the current view of the entity.
+     */
+    computeView: (omitPending?: boolean) => EntityMetadataView;
+    addBaseline: (baseline: DocumentBaseline) => void;
+    /**
+     * @returns total number of new operations added
+     */
+    addConfirmedOperations: (operations: Operation[]) => number;
+    addPendingOperation: (operation: Operation) => void;
+    private applyOperations;
+}
+/**
+ * Represents the metadata for a group of entities underneath a Document.
+ * Metadata is separated out this way so that these classes can be
+ * garbage collected when the root Document goes out of scope.
+ */
+export declare class EntityFamilyMetadata {
+    private ctx;
+    private entities;
+    private onPendingOperations;
+    private rootOid;
+    constructor({ ctx, onPendingOperations, rootOid, }: {
+        ctx: Context;
+        onPendingOperations: (ops: Operation[]) => void;
+        rootOid: ObjectIdentifier;
+    });
+    get: (oid: ObjectIdentifier) => EntityMetadata;
+    getAllOids: () => string[];
+    addConfirmedData: ({ baselines, operations, isLocal, }: {
+        baselines?: DocumentBaseline[] | undefined;
+        operations?: Record<string, Operation[]> | undefined;
+        isLocal?: boolean | undefined;
+    }) => EntityChange[];
+    /**
+     * Adds local, unconfirmed operations to the system.
+     * The API is different here to streamline for the way
+     * local changes are usually handled, as a list.
+     */
+    addPendingData: (operations: Operation[]) => EntityChange[];
+    replaceAllData: ({ operations, baselines, }: {
+        operations?: Record<string, Operation[]> | undefined;
+        baselines?: DocumentBaseline[] | undefined;
+    }) => EntityChange[];
+}

package/dist/esm/entities/EntityStore.d.ts

@@ -0,0 +1,81 @@
+/// <reference types="node" resolution-mode="require"/>
+import { DocumentBaseline, ObjectIdentifier, Operation } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { Metadata } from '../metadata/Metadata.js';
+import { Entity } from './Entity.js';
+import { Disposable } from '../utils/Disposable.js';
+import { FileManager } from '../files/FileManager.js';
+import { WeakEvent } from 'weak-event';
+import { abort } from 'process';
+export type EntityStoreEventData = {
+    oid: ObjectIdentifier;
+    operations?: Record<string, Operation[]>;
+    baselines?: DocumentBaseline[];
+    isLocal: boolean;
+};
+export type EntityStoreEvents = {
+    add: WeakEvent<EntityStore, EntityStoreEventData>;
+    replace: WeakEvent<EntityStore, EntityStoreEventData>;
+    resetAll: WeakEvent<EntityStore, void>;
+};
+type IncomingData = {
+    operations?: Operation[];
+    baselines?: DocumentBaseline[];
+    reset?: boolean;
+    isLocal?: boolean;
+};
+export declare class EntityStore extends Disposable {
+    private ctx;
+    private meta;
+    private files;
+    private batcher;
+    private queryableStorage;
+    private events;
+    private cache;
+    private pendingEntityPromises;
+    private abortDataQueueController;
+    private ongoingResetPromise;
+    private entityFinalizationRegistry;
+    constructor({ ctx, meta, files, }: {
+        ctx: Context;
+        meta: Metadata;
+        files: FileManager;
+    });
+    get batch(): ({ undoable, batchName, max, timeout, }?: {
+        undoable?: boolean | undefined;
+        batchName?: string | undefined;
+        max?: number | null | undefined;
+        timeout?: number | null | undefined;
+    }) => import("./OperationBatcher.js").OperationBatch;
+    get flushAllBatches(): () => Promise<any[]>;
+    addData: (data: IncomingData) => Promise<void>;
+    private resetData;
+    private processData;
+    hydrate: (oid: string, opts?: {
+        abort: AbortSignal;
+    }) => Promise<Entity | null>;
+    destroy: () => Promise<void>;
+    /**
+     * Creates a new Entity with the given initial data.
+     */
+    create: (initial: any, oid: ObjectIdentifier, { undoable }?: {
+        undoable?: boolean | undefined;
+    }) => Promise<Entity<any, any, any>>;
+    deleteAll: (oids: ObjectIdentifier[], options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+    delete: (oid: ObjectIdentifier, options?: {
+        undoable?: boolean;
+    }) => Promise<void>;
+    private getCollectionSchema;
+    /**
+     * Constructs an entity from an OID, but does not load it.
+     */
+    private constructEntity;
+    private onPendingOperations;
+    /**
+     * Loads initial Entity data from storage
+     */
+    private loadEntity;
+}
+export {};

package/dist/esm/entities/OperationBatcher.d.ts

@@ -0,0 +1,52 @@
+import { Operation } from '@verdant-web/common';
+import { Metadata } from '../metadata/Metadata.js';
+import { Context } from '../context.js';
+import type { EntityStore } from './EntityStore.js';
+import { Entity } from './Entity.js';
+export interface OperationBatch {
+    run: (fn: () => void) => this;
+    /** @deprecated - use commit() */
+    flush: () => Promise<void>;
+    commit: () => Promise<void>;
+    discard: () => void;
+}
+export declare class OperationBatcher {
+    private batcher;
+    private currentBatchKey;
+    private defaultBatchTimeout;
+    private meta;
+    private ctx;
+    private entities;
+    constructor({ batchTimeout, meta, ctx, entities, }: {
+        batchTimeout?: number;
+        meta: Metadata;
+        ctx: Context;
+        entities: EntityStore;
+    });
+    get isDefaultBatch(): boolean;
+    private flushOperations;
+    /**
+     * Immediately flushes operations to storage / sync.
+     * Providing source to second arg skips hydrating related
+     * Entity from storage, which is useful when that Entity
+     * isn't in storage (i.e. still creating) or just to speed
+     * up the commit.
+     */
+    commitOperations: (operations: Operation[], meta: {
+        undoable?: boolean;
+        source?: Entity;
+    }) => Promise<void>;
+    /**
+     * Adds operations to the active batch.
+     */
+    addOperations: (operations: Operation[]) => void;
+    batch: ({ undoable, batchName, max, timeout, }?: {
+        undoable?: boolean | undefined;
+        batchName?: string | undefined;
+        max?: number | null | undefined;
+        timeout?: number | null | undefined;
+    }) => OperationBatch;
+    flushAll: () => Promise<any[]>;
+    private createUndo;
+    private getInverseOperations;
+}

package/dist/esm/entities/types.d.ts

@@ -0,0 +1,103 @@
+import { ObjectIdentifier } from '@verdant-web/common';
+import type { Entity } from './Entity.js';
+export type AccessibleEntityProperty<T> = T extends Array<any> ? number : T extends object ? keyof T : never;
+export type DataFromInit<Init> = Init extends {
+    [key: string]: any;
+} ? {
+    [Key in keyof Init]: Init[Key];
+} : Init extends Array<any> ? Init : any;
+export type DeletableKeys<T> = keyof {
+    [Key in keyof T as IfNullableThen<T[Key], Key>]: Key;
+};
+type IfNullableThen<T, Out> = undefined extends T ? Out : null extends T ? Out : never;
+export type EntityShape<E extends Entity<any, any>> = E extends Entity<infer Value, any> ? Value : never;
+export type BaseEntityValue = {
+    [Key: string]: any;
+} | any[];
+export interface EntityChange {
+    oid: ObjectIdentifier;
+    isLocal: boolean;
+}
+export interface EntityChangeInfo {
+    isLocal?: boolean;
+}
+export type EntityEvents = {
+    change: (info: EntityChangeInfo) => void;
+    changeDeep: (target: BaseEntity<any, any, any>, info: EntityChangeInfo) => void;
+    delete: (info: EntityChangeInfo) => void;
+    restore: (info: EntityChangeInfo) => void;
+};
+export interface BaseEntity<Init, Value extends BaseEntityValue, Snapshot = DataFromInit<Init>> {
+    dispose: () => void;
+    subscribe<EventName extends keyof EntityEvents>(event: EventName, callback: EntityEvents[EventName]): () => void;
+    get<Key extends keyof Value>(key: Key): Value[Key];
+    getAll(): Value;
+    getSnapshot(): Snapshot;
+    readonly deleted: boolean;
+    readonly updatedAt: number;
+    readonly uid: string;
+}
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export interface ObjectEntity<Init, Value extends BaseEntityValue, Snapshot = DataFromInit<Init>> extends BaseEntity<Init, Value, Snapshot> {
+    keys(): string[];
+    entries(): [string, Exclude<Value[keyof Value], undefined>][];
+    values(): Exclude<Value[keyof Value], undefined>[];
+    set<Key extends keyof Init>(key: Key, value: Init[Key]): void;
+    delete(key: DeletableKeys<Value>): void;
+    update(value: DeepPartial<Init>, options?: {
+        /**
+         * Forces the replacement of sub-objects in the update payload - rather than
+         * Verdant keeping their identities intact and merging changes, your update
+         * will replace these objects entirely, overwriting any other changes from other
+         * sources.
+         *
+         * Useful when the update you're making is logically replacing sub-objects, rather
+         * than simply modifying them.
+         *
+         * Default: false
+         */
+        replaceSubObjects?: boolean;
+        /**
+         * If set to false, this will drop any keys in the object which were
+         * not provided in your update payload, while also merging the ones that
+         * were. This option only works for `map` and `any` type fields; you cannot
+         * use it with defined `object` type fields.
+         *
+         * Default: true
+         */
+        merge?: boolean;
+    }): void;
+    readonly isList: false;
+}
+export interface ListEntity<Init, Value extends BaseEntityValue, Snapshot = DataFromInit<Init>> extends Iterable<ListItemValue<Value>>, BaseEntity<Init, Value, Snapshot> {
+    readonly isList: true;
+    readonly length: number;
+    push(value: ListItemInit<Init>): void;
+    insert(index: number, value: ListItemInit<Init>): void;
+    move(from: number, to: number): void;
+    moveItem(item: ListItemValue<Value>, to: number): void;
+    /**
+     * A Set operation which adds a value if an equivalent value is not already present.
+     * Object values are never the same.
+     */
+    add(value: ListItemValue<Value>): void;
+    removeAll(item: ListItemValue<Value>): void;
+    removeFirst(item: ListItemValue<Value>): void;
+    removeLast(item: ListItemValue<Value>): void;
+    map<U>(callback: (value: ListItemValue<Value>, index: number) => U): U[];
+    filter(callback: (value: ListItemValue<Value>, index: number) => boolean): ListItemValue<Value>[];
+    delete(index: number): void;
+    has(value: ListItemValue<Value>): boolean;
+    forEach(callback: (value: ListItemValue<Value>, index: number) => void): void;
+    some(predicate: (value: ListItemValue<Value>) => boolean): boolean;
+    every(predicate: (value: ListItemValue<Value>) => boolean): boolean;
+    find(predicate: (value: ListItemValue<Value>) => boolean): ListItemValue<Value> | undefined;
+    includes(value: ListItemValue<Value>): boolean;
+}
+export type AnyEntity<Init, KeyValue extends BaseEntityValue, Snapshot extends any> = ListEntity<Init, KeyValue, Snapshot> | ObjectEntity<Init, KeyValue, Snapshot>;
+export type ListItemValue<KeyValue> = KeyValue extends Array<infer T> ? T : never;
+export type ListItemInit<Init> = Init extends Array<infer T> ? T : never;
+export type EntityDestructured<T extends AnyEntity<any, any, any> | null> = (T extends ListEntity<any, infer KeyValue, any> ? KeyValue : T extends ObjectEntity<any, infer KeyValue, any> ? KeyValue : never) | (T extends null ? null : never);
+export {};

package/dist/esm/files/EntityFile.d.ts

@@ -0,0 +1,35 @@
+import { EventSubscriber, FileData } from '@verdant-web/common';
+export type EntityFileEvents = {
+    change: () => void;
+};
+export declare const UPDATE: unique symbol;
+export declare const MARK_FAILED: unique symbol;
+export type EntityFileSnapshot = {
+    id: string;
+    url?: string | null;
+};
+/**
+ * Provides a consistent interface for files used in an app via
+ * Entity access.
+ */
+export declare class EntityFile extends EventSubscriber<EntityFileEvents> {
+    readonly id: string;
+    private _objectUrl;
+    private _fileData;
+    private _loading;
+    private _failed;
+    private _downloadRemote;
+    constructor(id: string, { downloadRemote, }?: {
+        downloadRemote?: boolean;
+    });
+    get downloadRemote(): boolean;
+    [UPDATE]: (fileData: FileData) => void;
+    [MARK_FAILED]: () => void;
+    get url(): string | null;
+    get name(): string | null;
+    get type(): string | null;
+    get loading(): boolean;
+    get failed(): boolean;
+    destroy: () => void;
+    getSnapshot(): EntityFileSnapshot;
+}

package/dist/esm/files/FileManager.d.ts

@@ -0,0 +1,47 @@
+import { FileData } from '@verdant-web/common';
+import { Context } from '../context.js';
+import { Metadata } from '../metadata/Metadata.js';
+import { Sync } from '../sync/Sync.js';
+import { EntityFile } from './EntityFile.js';
+import { ReturnedFileData } from './FileStorage.js';
+export interface FileManagerConfig {
+    /**
+     * Override the heuristic for deciding when a deleted file can be cleaned up.
+     * By default this waits 3 days since deletion, then deletes the file data.
+     * If the file has been synchronized to a server, it could still be restored
+     * if the server has not yet deleted it.
+     */
+    canCleanupDeletedFile?: (file: ReturnedFileData) => boolean;
+}
+export declare class FileManager {
+    private storage;
+    private sync;
+    private context;
+    private files;
+    private config;
+    private meta;
+    constructor({ db, sync, context, meta, config, }: {
+        db: IDBDatabase;
+        sync: Sync;
+        context: Context;
+        config?: FileManagerConfig;
+        meta: Metadata;
+    });
+    add: (fileInput: Omit<FileData, 'remote'>) => Promise<void>;
+    private uploadFile;
+    /**
+     * Immediately returns an EntityFile to use, then either loads
+     * the file from cache, local database, or the server.
+     */
+    get: (id: string, options?: {
+        downloadRemote?: boolean;
+    }) => EntityFile;
+    private load;
+    listUnsynced: () => Promise<ReturnedFileData[]>;
+    exportAll: (downloadRemote?: boolean) => Promise<ReturnedFileData[]>;
+    importAll: (files: ReturnedFileData[]) => Promise<void>;
+    private onOnlineChange;
+    private tryCleanupDeletedFiles;
+    private handleFileRefsDeleted;
+    close: () => void;
+}

package/dist/esm/files/FileStorage.d.ts

@@ -0,0 +1,39 @@
+import { FileData } from '@verdant-web/common';
+import { IDBService } from '../IDBService.js';
+/**
+ * When stored in IDB, replace the file blob with an array buffer
+ * since it's more compatible, and replace remote boolean with
+ * a string since IDB doesn't support boolean indexes.
+ */
+export interface StoredFileData extends Omit<FileData, 'remote' | 'file'> {
+    remote: 'true' | 'false';
+    buffer?: ArrayBuffer;
+    deletedAt: number | null;
+}
+export interface ReturnedFileData extends FileData {
+    deletedAt: number | null;
+}
+export declare class FileStorage extends IDBService {
+    addFile: (file: FileData, { transaction, downloadRemote, }?: {
+        transaction?: IDBTransaction | undefined;
+        downloadRemote?: boolean | undefined;
+    }) => Promise<IDBValidKey>;
+    private hydrateFileData;
+    markUploaded: (id: string, { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<IDBValidKey>;
+    private getFileRaw;
+    getFile: (id: string, { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<ReturnedFileData | undefined>;
+    deleteFile(id: string, { transaction }?: {
+        transaction?: IDBTransaction;
+    }): Promise<undefined>;
+    markPendingDelete: (id: string, { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<IDBValidKey>;
+    listUnsynced: () => Promise<ReturnedFileData[]>;
+    iterateOverPendingDelete: (iterator: (file: ReturnedFileData, store: IDBObjectStore) => void, transaction?: IDBTransaction) => Promise<void>;
+    getAll: () => Promise<ReturnedFileData[]>;
+}
+export declare function arrayBufferToBlob(buffer: ArrayBuffer, type: string): Blob;

package/dist/esm/files/utils.d.ts

@@ -0,0 +1,10 @@
+import { FileData } from '@verdant-web/common';
+export declare function createFileData(file: File): FileData;
+export declare function isFile(value: any): value is File;
+/**
+ * MUTATES the value.
+ * Replaces File values with refs and returns the normalized value.
+ * The list of files passed to the second argument will be populated with the files found in the value.
+ */
+export declare function processValueFiles(value: any, onFileIdentified: (fileData: FileData) => void): any;
+export declare function fileToArrayBuffer(file: File | Blob): Promise<ArrayBuffer>;

package/dist/esm/files/utils.test.d.ts

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

package/dist/esm/idb.d.ts

@@ -0,0 +1,13 @@
+export declare function isAbortError(err: unknown): boolean;
+export declare function storeRequestPromise<T>(request: IDBRequest<T>): Promise<T>;
+export declare function cursorIterator<T>(request: IDBRequest<IDBCursorWithValue | null>, callback: (value: T | null) => boolean): Promise<void>;
+export declare function getSizeOfObjectStore(database: IDBDatabase, storeName: string): Promise<{
+    count: number;
+    size: number;
+}>;
+export declare function getAllFromObjectStores(db: IDBDatabase, stores: string[]): Promise<any[][]>;
+export declare function closeDatabase(db: IDBDatabase): Promise<void>;
+export declare function deleteAllDatabases(namespace: string, indexedDB?: IDBFactory): Promise<void>;
+export declare function deleteDatabase(name: string, indexedDB?: IDBFactory): Promise<IDBDatabase>;
+export declare function getAllDatabaseNamesAndVersions(indexedDB?: IDBFactory): Promise<IDBDatabaseInfo[]>;
+export declare function createAbortableTransaction(db: IDBDatabase, storeNames: string[], mode: 'readonly' | 'readwrite', abortSignal?: AbortSignal, log?: (...args: any[]) => void): IDBTransaction;

package/dist/esm/index.d.ts

@@ -0,0 +1,23 @@
+import { ClientDescriptor, ClientDescriptorOptions } from './client/ClientDescriptor.js';
+import { Client } from './client/Client.js';
+export type { ClientWithCollections } from './client/Client.js';
+export { ClientDescriptor };
+export { Client };
+export { ClientDescriptor as StorageDescriptor };
+export { Client as Storage };
+export type { ClientDescriptorOptions };
+export type { ClientDescriptorOptions as StorageInitOptions };
+export { Entity } from './entities/Entity.js';
+export type { ObjectEntity, ListEntity, EntityShape, AccessibleEntityProperty, AnyEntity, EntityDestructured, } from './entities/types.js';
+export { ServerSync } from './sync/Sync.js';
+export type { SyncTransportMode } from './sync/Sync.js';
+export { EntityFile, type EntityFileSnapshot } from './files/EntityFile.js';
+export { 
+/** @deprecated - use schema.collection */
+collection, schema, createDefaultMigration, migrate, createMigration, } from '@verdant-web/common';
+export type { StorageDocument, StorageSchema, StorageCollectionSchema, StorageAnyFieldSchema, StorageArrayFieldSchema, StorageObjectFieldSchema, StorageBooleanFieldSchema, StorageFieldSchema, StorageFileFieldSchema, StorageMapFieldSchema, StorageNumberFieldSchema, StorageStringFieldSchema, StorageFieldsSchema, IndexValueTag, Migration, } from '@verdant-web/common';
+export type { UserInfo } from '@verdant-web/common';
+export type { Query } from './queries/types.js';
+export type { QueryStatus } from './queries/BaseQuery.js';
+export type { CollectionQueries } from './queries/CollectionQueries.js';
+export { MigrationPathError } from './migration/errors.js';

package/dist/esm/metadata/AckInfoStore.d.ts

@@ -0,0 +1,10 @@
+import { IDBService } from '../IDBService.js';
+type AckInfo = {
+    type: 'ack';
+    globalAckTimestamp: string | null;
+};
+export declare class AckInfoStore extends IDBService {
+    getAckInfo: () => Promise<AckInfo>;
+    setGlobalAck: (ack: string) => Promise<void>;
+}
+export {};

package/dist/esm/metadata/BaselinesStore.d.ts

@@ -0,0 +1,40 @@
+import { DocumentBaseline, ObjectIdentifier } from '@verdant-web/common';
+import { IDBService } from '../IDBService.js';
+import { Context } from '../context.js';
+export declare class BaselinesStore extends IDBService {
+    constructor(db: IDBDatabase, opts: {
+        log?: Context['log'];
+    });
+    getAllForDocument: (oid: ObjectIdentifier, { mode, transaction, }?: {
+        mode?: "readonly" | "readwrite" | undefined;
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<DocumentBaseline[]>;
+    iterateOverAllForDocument: (oid: ObjectIdentifier, iterator: (baseline: DocumentBaseline, store: IDBObjectStore) => void, { mode, transaction, }?: {
+        mode?: "readonly" | "readwrite" | undefined;
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<void>;
+    iterateOverAllForCollection: (collection: string, iterator: (baseline: DocumentBaseline, store: IDBObjectStore) => void, { mode, transaction, }?: {
+        mode?: "readonly" | "readwrite" | undefined;
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<void>;
+    getAllForMultipleDocuments: (docOids: string[], { mode }?: {
+        mode?: "readonly" | "readwrite" | undefined;
+    }) => Promise<DocumentBaseline[]>;
+    getAllSince: (timestamp: string | null, { mode }?: {
+        mode?: "readonly" | "readwrite" | undefined;
+    }) => Promise<DocumentBaseline[]>;
+    get: (oid: ObjectIdentifier, { transaction, mode, }?: {
+        transaction?: IDBTransaction | undefined;
+        mode?: "readonly" | "readwrite" | undefined;
+    }) => Promise<DocumentBaseline>;
+    set: <T>(baseline: DocumentBaseline<T>, { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<void>;
+    setAll: <T>(baselines: DocumentBaseline<T>[], { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<void>;
+    reset: () => Promise<undefined>;
+    delete: (oid: ObjectIdentifier, { transaction }: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<void>;
+}

package/dist/esm/metadata/LocalReplicaStore.d.ts

@@ -0,0 +1,18 @@
+import { IDBService } from '../IDBService.js';
+export type LocalReplicaInfo = {
+    type: 'localReplicaInfo';
+    id: string;
+    ackedLogicalTime: string | null;
+    lastSyncedLogicalTime: string | null;
+};
+export declare class LocalReplicaStore extends IDBService {
+    private _creating;
+    private cached;
+    get: ({ transaction, }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<LocalReplicaInfo>;
+    update: (data: Partial<LocalReplicaInfo>, { transaction }?: {
+        transaction?: IDBTransaction | undefined;
+    }) => Promise<void>;
+    reset: () => Promise<void>;
+}

package/dist/esm/metadata/MessageCreator.d.ts

@@ -0,0 +1,19 @@
+import { AckMessage, HeartbeatMessage, OperationMessage, PresenceUpdateMessage, SyncMessage } from '@verdant-web/common';
+import { Metadata } from './Metadata.js';
+export declare class MessageCreator {
+    private meta;
+    constructor(meta: Metadata);
+    createOperation: (init: Pick<OperationMessage, 'operations'> & {
+        timestamp?: string;
+    }) => Promise<OperationMessage>;
+    createMigrationOperation: ({ targetVersion, ...init }: Pick<OperationMessage, "operations"> & {
+        targetVersion: number;
+    }) => Promise<OperationMessage>;
+    /**
+     * @param since - override local understanding of last sync time
+     */
+    createSyncStep1: (since?: string | null) => Promise<SyncMessage>;
+    createPresenceUpdate: (presence: any) => Promise<PresenceUpdateMessage>;
+    createHeartbeat: () => Promise<HeartbeatMessage>;
+    createAck: (nonce: string) => Promise<AckMessage>;
+}