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

package/dist/esm/client/Client.d.ts

@@ -1,120 +0,0 @@
-import { EventSubscriber, Migration } from '@verdant-web/common';
-import { Context } from '../context.js';
-import { DocumentManager } from '../DocumentManager.js';
-import { FileManagerConfig } from '../files/FileManager.js';
-import { ExportData, Metadata } from '../metadata/Metadata.js';
-import { EntityStore } from '../entities/EntityStore.js';
-import { ServerSyncOptions, Sync } from '../sync/Sync.js';
-import { CollectionQueries } from '../queries/CollectionQueries.js';
-import { ReturnedFileData } from '../files/FileStorage.js';
-interface ClientConfig<Presence = any> {
-    syncConfig?: ServerSyncOptions<Presence>;
-    migrations: Migration[];
-    files?: FileManagerConfig;
-}
-export type ClientWithCollections = Client & {
-    [key: string]: CollectionQueries<any, any, any>;
-};
-export declare class Client<Presence = any, Profile = any> extends EventSubscriber<{
-    /**
-     * Called when a change from a future version of the application has
-     * been witnessed. These changes are not applied but it indicates
-     * the app has been updated and a peer is using a newer version.
-     * You should listen to this event and prompt the user to reload
-     * their client, or reload it for them.
-     *
-     * This event may be called multiple times.
-     */
-    futureSeen: () => void;
-}> {
-    private config;
-    private context;
-    readonly meta: Metadata;
-    private _entities;
-    private _queryCache;
-    private _documentManager;
-    private _fileManager;
-    private _closed;
-    readonly collectionNames: string[];
-    private _sync;
-    get sync(): Sync<Presence, Profile>;
-    get entities(): EntityStore;
-    get documentManager(): DocumentManager<any>;
-    constructor(config: ClientConfig, context: Context, components: {
-        meta: Metadata;
-    });
-    private addData;
-    get documentDb(): IDBDatabase;
-    get metaDb(): IDBDatabase;
-    get schema(): import("@verdant-web/common").StorageSchema<{
-        [k: string]: import("@verdant-web/common").StorageCollectionSchema<import("@verdant-web/common").StorageFieldsSchema, import("@verdant-web/common").StorageSyntheticIndices<import("@verdant-web/common").StorageFieldsSchema>, import("@verdant-web/common").CollectionCompoundIndices<import("@verdant-web/common").StorageFieldsSchema, import("@verdant-web/common").StorageSyntheticIndices<import("@verdant-web/common").StorageFieldsSchema>>>;
-    }>;
-    get namespace(): string;
-    get undoHistory(): import("../UndoHistory.js").UndoHistory;
-    /**
-     * Batch multiple operations together to be executed in a single transaction.
-     * The changes made will not be included in the same undo history step as
-     * any other changes made outside of the batch. You can also disable undo
-     * for your batch to omit changes from undo history.
-     *
-     * Provide a batch name to apply multiple changes to the same batch
-     * across different invocations. Batches will automatically flush after
-     * a short delay or if they reach a maximum size.
-     */
-    get batch(): ({ undoable, batchName, max, timeout, }?: {
-        undoable?: boolean | undefined;
-        batchName?: string | undefined;
-        max?: number | null | undefined;
-        timeout?: number | null | undefined;
-    }) => import("../entities/OperationBatcher.js").OperationBatch;
-    stats: () => Promise<{
-        collections: Record<string, {
-            count: number;
-            size: number;
-        }>;
-        meta: {
-            operationsSize: {
-                count: number;
-                size: number;
-            };
-            baselinesSize: {
-                count: number;
-                size: number;
-            };
-        };
-        storage: StorageEstimate | undefined;
-        totalMetaSize: number;
-        totalCollectionsSize: number;
-        metaToDataRatio: number;
-        quotaUsage: number | undefined;
-    }>;
-    close: () => Promise<void>;
-    __dangerous__resetLocal: () => Promise<void>;
-    export: ({ downloadRemoteFiles }?: {
-        downloadRemoteFiles?: boolean | undefined;
-    }) => Promise<{
-        data: ExportData;
-        fileData: Omit<ReturnedFileData, "file">[];
-        files: File[];
-    }>;
-    private getFileExportName;
-    private parseFileExportname;
-    import: ({ data, fileData, files, }: {
-        data: ExportData;
-        fileData: Array<Omit<ReturnedFileData, 'file'>>;
-        files: File[];
-    }) => Promise<void>;
-    /**
-     * Export all data, then re-import it. This might resolve
-     * some issues with the local database, but it should
-     * only be done as a second-to-last resort. The last resort
-     * would be __dangerous__resetLocal on ClientDescriptor, which
-     * clears all local data.
-     *
-     * Unlike __dangerous__resetLocal, this method allows local-only
-     * clients to recover data, whereas __dangerous__resetLocal only
-     * lets networked clients recover from the server.
-     */
-    __dangerous__hardReset: () => Promise<void>;
-}
-export {};

package/dist/esm/client/ClientDescriptor.d.ts

@@ -1,76 +0,0 @@
-import { Migration, StorageSchema } from '@verdant-web/common';
-import { FileManagerConfig } from '../files/FileManager.js';
-import { ServerSyncOptions } from '../sync/Sync.js';
-import { UndoHistory } from '../UndoHistory.js';
-import { Client } from './Client.js';
-import { METADATA_VERSION_KEY } from './constants.js';
-export interface ClientDescriptorOptions<Presence = any, Profile = any> {
-    /** The schema used to create this client */
-    schema: StorageSchema<any>;
-    /** Migrations, in order, to upgrade to each successive version of the schema */
-    migrations: Migration<any>[];
-    /** Provide a sync config to turn on synchronization with a server */
-    sync?: ServerSyncOptions<Profile, Presence>;
-    /** Optionally override the IndexedDB implementation */
-    indexedDb?: IDBFactory;
-    /**
-     * Namespaces are used to separate data from different clients in IndexedDB.
-     */
-    namespace: string;
-    /**
-     * Provide your own UndoHistory to have a unified undo system across multiple
-     * clients if you so desire.
-     */
-    undoHistory?: UndoHistory;
-    /**
-     * Provide a log function to log internal debug messages
-     */
-    log?: (...args: any[]) => void;
-    disableRebasing?: boolean;
-    /**
-     * Provide a specific schema number to override the schema version
-     * in the database. This is useful for testing migrations or recovering
-     * from a mistakenly deployed incorrect schema. A specific version is required
-     * so that you don't leave this on accidentally for all new schemas.
-     */
-    overrideSchemaConflict?: number;
-    /**
-     * Configuration for file management
-     */
-    files?: FileManagerConfig;
-    /**
-     * Enables experimental WeakRef usage to cull documents
-     * from cache that aren't being used. This is a performance
-     * optimization which has been tested under all Verdant's test
-     * suites but I still want to keep testing it in the real world
-     * before turning it on.
-     */
-    EXPERIMENTAL_weakRefs?: boolean;
-    [METADATA_VERSION_KEY]?: number;
-}
-/**
- * Since storage initialization is async, this class wraps the core
- * Storage creation promise and exposes some metadata which can
- * be useful immediately.
- */
-export declare class ClientDescriptor<Presence = any, Profile = any, ClientImpl extends Client = Client> {
-    private readonly init;
-    private readonly _readyPromise;
-    private resolveReady;
-    private rejectReady;
-    private _resolvedValue;
-    private _initializing;
-    private _namespace;
-    get namespace(): string;
-    constructor(init: ClientDescriptorOptions<Presence, Profile>);
-    private initialize;
-    private initializeDatabases;
-    private initializeWIPDatabases;
-    private cleanupWIPDatabases;
-    get current(): ClientImpl | undefined;
-    get readyPromise(): Promise<ClientImpl>;
-    get schema(): StorageSchema<any>;
-    open: () => Promise<ClientImpl>;
-    close: () => Promise<void>;
-    __dangerous__resetLocal: () => Promise<void>;
-}

package/dist/esm/client/constants.d.ts

@@ -1 +0,0 @@
-export declare const METADATA_VERSION_KEY: unique symbol;

package/dist/esm/constants.d.ts

@@ -1 +0,0 @@
-export declare const TEST_API = "__unsafe__test_api__";

package/dist/esm/context.d.ts

@@ -1,38 +0,0 @@
-import { EventSubscriber, Migration, ObjectIdentifier, StorageSchema } from '@verdant-web/common';
-import { UndoHistory } from './UndoHistory.js';
-/**
- * Common components utilized across various client
- * services.
- */
-export interface Context {
-    namespace: string;
-    metaDb: IDBDatabase;
-    documentDb: IDBDatabase;
-    undoHistory: UndoHistory;
-    schema: StorageSchema;
-    log: (...args: any[]) => void;
-    entityEvents: EventSubscriber<{
-        collectionsChanged: (names: string[]) => void;
-        documentChanged: (oid: ObjectIdentifier) => void;
-    }>;
-    internalEvents: EventSubscriber<{
-        documentDbChanged: (db: IDBDatabase) => void;
-    }>;
-    globalEvents: EventSubscriber<{
-        /**
-         * A change from a future version of the application has been
-         * witnessed. These changes are not applied but it indicates
-         * the app has been updated and we should prompt the user
-         * to reload or have their app user manually reload.
-         *
-         * The parameter is the timestamp of the future change.
-         */
-        futureSeen: (timestamp: string) => void;
-    }>;
-    weakRef<T extends object>(value: T): WeakRef<T>;
-    migrations: Migration<any>[];
-    /**
-     * Get the current logical timestamp
-     */
-    getNow(): string;
-}

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

@@ -1,148 +0,0 @@
-import { EntityValidationProblem, EventSubscriber, ObjectIdentifier, PatchCreator, StorageFieldSchema } from '@verdant-web/common';
-import { Context } from '../context.js';
-import { FileManager } from '../files/FileManager.js';
-import { EntityCache } from './EntityCache.js';
-import { EntityFamilyMetadata, EntityMetadataView } from './EntityMetadata.js';
-import { BaseEntityValue, DataFromInit, EntityChange, EntityEvents, ListEntity, ListItemInit, ListItemValue, ObjectEntity } from './types.js';
-import { EntityStoreEvents } from './EntityStore.js';
-export interface EntityInit {
-    oid: ObjectIdentifier;
-    schema: StorageFieldSchema;
-    entityFamily?: EntityCache;
-    metadataFamily: EntityFamilyMetadata;
-    parent?: Entity;
-    ctx: Context;
-    files: FileManager;
-    readonlyKeys?: string[];
-    fieldPath?: (string | number)[];
-    patchCreator: PatchCreator;
-    events: EntityStoreEvents;
-}
-export declare class Entity<Init = any, KeyValue extends BaseEntityValue = any, Snapshot extends any = DataFromInit<Init>> extends EventSubscriber<EntityEvents> implements ObjectEntity<Init, KeyValue, Snapshot>, ListEntity<Init, KeyValue, Snapshot> {
-    readonly oid: ObjectIdentifier;
-    private readonlyKeys;
-    private fieldPath;
-    private entityFamily;
-    private metadataFamily;
-    private schema;
-    private parent;
-    private ctx;
-    private files;
-    private patchCreator;
-    private events;
-    private _viewData;
-    private validationError;
-    private cachedDeepUpdatedAt;
-    private wasDeletedLastChange;
-    private cachedView;
-    constructor({ oid, schema, entityFamily: childCache, parent, ctx, metadataFamily, readonlyKeys, files, patchCreator, events, }: EntityInit);
-    private onAdd;
-    private onReplace;
-    private onResetAll;
-    private get metadata();
-    /**
-     * The view of this Entity, not including nested
-     * entities (that's the snapshot - see #getSnapshot())
-     *
-     * Nested entities are represented by refs.
-     */
-    private get viewData();
-    /** convenience getter for viewData.view */
-    private get rawView();
-    /**
-     * An Entity's View includes the rendering of its underlying data,
-     * connecting of children where refs were, and validation
-     * and pruning according to schema.
-     */
-    private get view();
-    private childIsNull;
-    get uid(): string;
-    get deleted(): boolean;
-    get invalid(): boolean;
-    get isList(): any;
-    get updatedAt(): number;
-    get deepUpdatedAt(): number;
-    /**
-     * @internal - this is relevant to Verdant's system, not users.
-     *
-     * Indicates whether this document is from an outdated version
-     * of the schema - which means it cannot be used until it is upgraded.
-     */
-    get isOutdatedVersion(): boolean;
-    /**
-     * Pruning - when entities have invalid children, we 'prune' that
-     * data up to the nearest prunable point - a nullable field,
-     * or a list.
-     */
-    protected validate: (...args: unknown[]) => EntityValidationProblem | undefined;
-    private viewWithMappedChildren;
-    /**
-     * A current snapshot of this Entity's data, including nested
-     * Entities.
-     */
-    getSnapshot: () => any;
-    private addPendingOperations;
-    private addConfirmedData;
-    private replaceAllData;
-    private resetAllData;
-    private change;
-    protected deepChange: (target: Entity, ev: EntityChange) => void;
-    private getChild;
-    /**
-     * Gets a value from this Entity. If the value
-     * is an object, it will be wrapped in another
-     * Entity.
-     */
-    get: <Key extends keyof KeyValue>(key: Key) => KeyValue[Key];
-    private processInputValue;
-    private getDeleteMode;
-    /**
-     * Returns the referent value of an item in the list, used for
-     * operations which act on items. if the item is an object,
-     * it will attempt to create an OID reference to it. If it
-     * is a primitive, it will return the primitive.
-     */
-    private getItemRefValue;
-    set: <Key extends keyof Init>(key: Key, value: Init[Key]) => void;
-    /**
-     * Returns a destructured version of this Entity, where child
-     * Entities are accessible at their respective keys.
-     */
-    getAll: () => KeyValue;
-    delete: (key: any) => void;
-    keys: () => string[];
-    entries: () => [string, Exclude<KeyValue[keyof KeyValue], undefined>][];
-    values: () => Exclude<KeyValue[keyof KeyValue], undefined>[];
-    update: (data: any, { merge, replaceSubObjects, }?: {
-        replaceSubObjects?: boolean | undefined;
-        merge?: boolean | undefined;
-    }) => void;
-    get length(): number;
-    push: (value: ListItemInit<Init>) => void;
-    insert: (index: number, value: ListItemInit<Init>) => void;
-    move: (from: number, to: number) => void;
-    moveItem: (item: ListItemValue<KeyValue>, to: number) => void;
-    add: (value: ListItemValue<KeyValue>) => void;
-    removeAll: (item: ListItemValue<KeyValue>) => void;
-    removeFirst: (item: ListItemValue<KeyValue>) => void;
-    removeLast: (item: ListItemValue<KeyValue>) => void;
-    [Symbol.iterator](): {
-        next: () => {
-            readonly value: ListItemValue<KeyValue>;
-            readonly done: false;
-        } | {
-            readonly value: undefined;
-            readonly done: true;
-        };
-    };
-    map: <U>(callback: (value: ListItemValue<KeyValue>, index: number) => U) => U[];
-    filter: (callback: (value: ListItemValue<KeyValue>, index: number) => boolean) => ListItemValue<KeyValue>[];
-    has: (value: ListItemValue<KeyValue>) => boolean;
-    forEach: (callback: (value: ListItemValue<KeyValue>, index: number) => void) => void;
-    some: (predicate: (value: ListItemValue<KeyValue>) => boolean) => boolean;
-    every: (predicate: (value: ListItemValue<KeyValue>) => boolean) => boolean;
-    find: (predicate: (value: ListItemValue<KeyValue>) => boolean) => ListItemValue<KeyValue> | undefined;
-    includes: (value: ListItemValue<KeyValue>) => boolean;
-    __getViewData__: (oid: ObjectIdentifier, type: 'confirmed' | 'pending') => EntityMetadataView;
-    __getFamilyOids__: () => string[];
-}

package/dist/esm/entities/Entity.test.d.ts

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

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

@@ -1,15 +0,0 @@
-import { Entity, EntityInit } from './Entity.js';
-import { EntityFile } from '../files/EntityFile.js';
-import { ObjectIdentifier } from '@verdant-web/common';
-export declare class EntityCache {
-    private cache;
-    constructor({ initial }?: {
-        initial?: Entity[];
-    });
-    get: (init: EntityInit) => Entity;
-    has: (oid: ObjectIdentifier) => boolean;
-    getFile: (id: string, options: {
-        downloadRemote: boolean;
-    }) => EntityFile;
-    getCached: (oid: string) => Entity<any, any, any> | EntityFile | undefined;
-}

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

@@ -1,68 +0,0 @@
-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<any>[] | 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<any>[] | undefined;
-    }) => EntityChange[];
-}

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

@@ -1,80 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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;
-}