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

package/dist/esm/sync/FileSync.d.ts

@@ -1,24 +0,0 @@
-import { FileData } from '@verdant-web/common';
-import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
-export interface FileUploadResult {
-    success: boolean;
-    retry: boolean;
-}
-export type FilePullResult = {
-    success: true;
-    data: FileData;
-} | {
-    success: false;
-    retry: boolean;
-    error?: any;
-};
-export declare class FileSync {
-    private endpointProvider;
-    private log;
-    constructor({ endpointProvider, log, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        log: (...args: any[]) => any;
-    });
-    uploadFile: (data: FileData) => Promise<FileUploadResult>;
-    getFile: (id: string) => Promise<FilePullResult>;
-}

package/dist/esm/sync/Heartbeat.d.ts

@@ -1,25 +0,0 @@
-import { EventSubscriber } from '@verdant-web/common';
-export declare class Heartbeat extends EventSubscriber<{
-    missed: () => void;
-    beat: () => void;
-}> {
-    private _interval;
-    private deadlineLength;
-    private nextBeat;
-    private deadline;
-    get interval(): number;
-    constructor({ interval, deadlineLength, restartOnTabFocus, }?: {
-        interval?: number;
-        deadlineLength?: number;
-        restartOnTabFocus?: boolean;
-    });
-    keepAlive: () => void;
-    start: (immediate?: boolean) => void;
-    stop: () => void;
-    private beat;
-    private onDeadline;
-    /**
-     * Only takes affect after the next beat
-     */
-    setInterval: (interval: number) => void;
-}

package/dist/esm/sync/PresenceManager.d.ts

@@ -1,55 +0,0 @@
-import { ServerMessage, EventSubscriber } from '@verdant-web/common';
-import type { UserInfo } from '../index.js';
-import { LocalReplicaInfo, LocalReplicaStore } from '../metadata/LocalReplicaStore.js';
-export declare const HANDLE_MESSAGE: unique symbol;
-export declare class PresenceManager<Profile = any, Presence = any> extends EventSubscriber<{
-    /**
-     * Fired when a particular peer's presence changes
-     */
-    peerChanged: (userId: string, presence: UserInfo<Profile, Presence>) => void;
-    /**
-     * Fired immediately when a change to local presence is made. This change may not
-     * yet have been sent to the server (see: "update" event)
-     */
-    selfChanged: (presence: UserInfo<Profile, Presence>) => void;
-    /** Fired when any number of peer presences have changed */
-    peersChanged: (peers: Record<string, UserInfo<Profile, Presence>>) => void;
-    /** Fired when a peer presence goes offline */
-    peerLeft: (userId: string, lastPresence: UserInfo<Profile, Presence>) => void;
-    /** Fired after local presence changes are flushed to the server. */
-    update: (presence: Partial<Presence>) => void;
-    load: () => void;
-}> {
-    private _peers;
-    private _self;
-    private _selfReplicaIds;
-    private _peerIds;
-    private _updateBatcher;
-    private _updateBatch;
-    get self(): UserInfo<Profile, Presence>;
-    get peers(): Record<string, UserInfo<Profile, Presence>>;
-    get peerIds(): string[];
-    get everyone(): {
-        [x: string]: UserInfo<Profile, Presence>;
-    };
-    get selfReplicaIds(): Set<string>;
-    constructor({ initialPresence, updateBatchTimeout, defaultProfile, replicaStore, }: {
-        initialPresence: Presence;
-        defaultProfile: Profile;
-        updateBatchTimeout?: number;
-        replicaStore: LocalReplicaStore;
-    });
-    /**
-     * Decides if an update is for the local user or not. Even if it's a different replica
-     * than the local one.
-     *
-     * If the replicaId matches, we use that first - we may not know the local replica's User ID yet,
-     * e.g. on the first presence update.
-     *
-     * Otherwise, match the user ID to our local copy.
-     */
-    private isSelf;
-    [HANDLE_MESSAGE]: (localReplicaInfo: LocalReplicaInfo, message: ServerMessage) => Promise<void>;
-    update: (presence: Partial<Presence>) => Promise<void>;
-    flushPresenceUpdates: (presenceUpdates: Partial<Presence>[]) => void;
-}

package/dist/esm/sync/PushPullSync.d.ts

@@ -1,39 +0,0 @@
-import { ClientMessage, EventSubscriber } from '@verdant-web/common';
-import { Metadata } from '../metadata/Metadata.js';
-import { PresenceManager } from './PresenceManager.js';
-import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
-import { SyncTransport, SyncTransportEvents } from './Sync.js';
-export declare class PushPullSync extends EventSubscriber<SyncTransportEvents> implements SyncTransport {
-    readonly meta: Metadata;
-    readonly presence: PresenceManager;
-    private endpointProvider;
-    private heartbeat;
-    private fetch;
-    readonly mode = "pull";
-    private log;
-    private _isConnected;
-    private _status;
-    private _hasSynced;
-    constructor({ endpointProvider, meta, presence, interval, log, fetch, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        meta: Metadata;
-        presence: PresenceManager;
-        interval?: number;
-        log?: (...args: any[]) => any;
-        fetch?: typeof window.fetch;
-    });
-    setInterval: (interval: number) => void;
-    get interval(): number;
-    private sendRequest;
-    private handleServerMessage;
-    send: (message: ClientMessage) => Promise<void> | undefined;
-    start(): void;
-    stop(): void;
-    destroy: () => void;
-    reconnect(): void;
-    ignoreIncoming(): void;
-    private onHeartbeat;
-    private onHeartbeatMissed;
-    get isConnected(): boolean;
-    get status(): "active" | "paused";
-}

package/dist/esm/sync/ServerSyncEndpointProvider.d.ts

@@ -1,34 +0,0 @@
-import { ReplicaType } from '@verdant-web/common';
-export interface ServerSyncEndpointProviderConfig {
-    /**
-     * The location of the endpoint used to retrieve an
-     * authorization token for the client.
-     */
-    authEndpoint?: string;
-    /**
-     * A custom function to retrieve authorization
-     * data. Use whatever fetching mechanism you want.
-     */
-    fetchAuth?: () => Promise<{
-        accessToken: string;
-    }>;
-    /**
-     * A spec-compliant fetch implementation. If not provided,
-     * the global fetch will be used. authEndpoint will
-     * be used to fetch the token.
-     */
-    fetch?: typeof fetch;
-}
-export declare class ServerSyncEndpointProvider {
-    private config;
-    private cached;
-    type: ReplicaType;
-    constructor(config: ServerSyncEndpointProviderConfig);
-    getEndpoints: () => Promise<{
-        http: string;
-        websocket: string;
-        files: string;
-        token: string;
-    }>;
-    clearCache: () => void;
-}

package/dist/esm/sync/Sync.d.ts

@@ -1,160 +0,0 @@
-import { ClientMessage, DocumentBaseline, EventSubscriber, FileData, Operation, ServerMessage } from '@verdant-web/common';
-import { Metadata } from '../metadata/Metadata.js';
-import { PresenceManager } from './PresenceManager.js';
-import { FilePullResult, FileUploadResult } from './FileSync.js';
-import { ServerSyncEndpointProviderConfig } from './ServerSyncEndpointProvider.js';
-type SyncEvents = {
-    onlineChange: (isOnline: boolean) => void;
-    syncingChange: (syncing: boolean) => void;
-};
-export type SyncTransportEvents = SyncEvents & {
-    message: (message: ServerMessage) => void;
-};
-export interface SyncTransport extends EventSubscriber<SyncTransportEvents> {
-    readonly presence: PresenceManager;
-    readonly mode: SyncTransportMode;
-    send(message: ClientMessage): void;
-    start(): void;
-    ignoreIncoming(): void;
-    stop(): void;
-    destroy(): void;
-    reconnect(): void;
-    readonly isConnected: boolean;
-    readonly status: 'active' | 'paused';
-}
-export interface Sync<Presence = any, Profile = any> extends EventSubscriber<SyncEvents> {
-    setMode(mode: SyncTransportMode): void;
-    setPullInterval(interval: number): void;
-    readonly pullInterval: number;
-    uploadFile(data: FileData): Promise<FileUploadResult>;
-    getFile(fileId: string): Promise<FilePullResult>;
-    readonly presence: PresenceManager<Profile, Presence>;
-    send(message: ClientMessage): void;
-    start(): void;
-    stop(): void;
-    ignoreIncoming(): void;
-    destroy(): void;
-    reconnect(): void;
-    readonly isConnected: boolean;
-    readonly status: 'active' | 'paused';
-    readonly mode: SyncTransportMode;
-}
-export declare class NoSync<Presence = any, Profile = any> extends EventSubscriber<SyncEvents> implements Sync<Presence, Profile> {
-    readonly mode = "pull";
-    send(): void;
-    start(): void;
-    stop(): void;
-    ignoreIncoming(): void;
-    destroy: () => void;
-    reconnect(): void;
-    setMode(): void;
-    setPullInterval(): void;
-    readonly isConnected = false;
-    readonly status = "paused";
-    readonly pullInterval = 0;
-    readonly presence: PresenceManager<any, any>;
-    constructor({ meta }: {
-        meta: Metadata;
-    });
-    uploadFile: () => Promise<{
-        success: boolean;
-        retry: boolean;
-    }>;
-    getFile: () => Promise<FilePullResult>;
-}
-export type SyncTransportMode = 'realtime' | 'pull';
-export interface ServerSyncOptions<Profile = any, Presence = any> extends ServerSyncEndpointProviderConfig {
-    /**
-     * When a client first connects, it will use this presence value.
-     */
-    initialPresence: Presence;
-    /**
-     * Before connecting to the server, the local client will have
-     * this value for their profile data. You can either cache and store
-     * profile data from a previous connection or provide defaults like
-     * empty strings.
-     */
-    defaultProfile: Profile;
-    /**
-     * Provide `false` to disable transport selection. Transport selection
-     * automatically switches between HTTP and WebSocket based sync depending
-     * on the number of peers connected. If a user is alone, they will use
-     * HTTP push/pull to sync changes. If another user joins, both users will
-     * be upgraded to websockets.
-     *
-     * Provide `peers-only` to only automatically use websockets if other
-     * users connect, but not if another device for the current user connects.
-     * By default, automatic transport selection will upgrade to websockets if
-     * another device from the current user connects, but if realtime sync is
-     * not necessary for such cases, you can save bandwidth by disabling this.
-     *
-     * Turning off this feature allows you more control over the transport
-     * which can be useful for low-power devices or to save server traffic.
-     * To modify transport modes manually, utilize `client.sync.setMode`.
-     * The built-in behavior is essentially switching modes based on
-     * the number of peers detected by client.sync.presence.
-     */
-    automaticTransportSelection?: boolean | 'peers-only';
-    initialTransport?: SyncTransportMode;
-    autoStart?: boolean;
-    /**
-     * Optionally specify an interval, in milliseconds, to poll the server
-     * when in pull mode.
-     */
-    pullInterval?: number;
-    /**
-     * Presence updates are batched to reduce number of requests / messages
-     * sent to the server. You can specify the batching time slice, in milliseconds,
-     */
-    presenceUpdateBatchTimeout?: number;
-    /**
-     * Experimental: sync messages over a broadcast channel between tabs.
-     * Fixes tabs not reactively updating to changes when other tabs are open,
-     * but is not yet thoroughly vetted.
-     */
-    useBroadcastChannel?: boolean;
-}
-export declare class ServerSync<Presence = any, Profile = any> extends EventSubscriber<SyncEvents> implements Sync<Presence, Profile> {
-    private webSocketSync;
-    private pushPullSync;
-    private fileSync;
-    private activeSync;
-    private endpointProvider;
-    private onData;
-    private broadcastChannel;
-    private _activelySyncing;
-    private meta;
-    readonly presence: PresenceManager<Profile, Presence>;
-    private log;
-    constructor({ authEndpoint, fetchAuth, fetch, initialPresence, automaticTransportSelection, autoStart, initialTransport, pullInterval, presenceUpdateBatchTimeout, defaultProfile, useBroadcastChannel, }: ServerSyncOptions<Profile, Presence>, { meta, log, onData, }: {
-        meta: Metadata;
-        log?: (...args: any[]) => void;
-        onData: (data: {
-            operations: Operation[];
-            baselines: DocumentBaseline[];
-            reset?: boolean;
-        }) => Promise<void>;
-    });
-    get canDoRealtime(): boolean;
-    get syncing(): boolean;
-    private handleBroadcastChannelMessage;
-    private onTokenExpired;
-    private handleMessage;
-    private handleOnlineChange;
-    private handlePresenceUpdate;
-    setMode: (transport: SyncTransportMode) => void;
-    setPullInterval: (interval: number) => void;
-    get pullInterval(): number;
-    send: (message: ClientMessage) => void;
-    uploadFile: (info: FileData) => Promise<FileUploadResult>;
-    getFile: (id: string) => Promise<FilePullResult>;
-    start: () => void;
-    stop: () => void;
-    ignoreIncoming(): void;
-    destroy: () => void;
-    reconnect: () => void;
-    get isConnected(): boolean;
-    get status(): "active" | "paused";
-    get mode(): SyncTransportMode;
-}
-export {};

package/dist/esm/sync/WebSocketSync.d.ts

@@ -1,44 +0,0 @@
-import { ClientMessage, EventSubscriber } from '@verdant-web/common';
-import { Metadata } from '../metadata/Metadata.js';
-import { PresenceManager } from './PresenceManager.js';
-import { ServerSyncEndpointProvider } from './ServerSyncEndpointProvider.js';
-import { SyncTransport, SyncTransportEvents } from './Sync.js';
-export declare class WebSocketSync extends EventSubscriber<SyncTransportEvents> implements SyncTransport {
-    private meta;
-    readonly presence: PresenceManager;
-    private socket;
-    private connectQueue;
-    private syncQueue;
-    private incomingQueue;
-    private endpointProvider;
-    private _status;
-    private synced;
-    private hasStartedSync;
-    private _ignoreIncoming;
-    readonly mode = "realtime";
-    private log;
-    private heartbeat;
-    private reconnectScheduler;
-    constructor({ endpointProvider, meta, presence, log, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        meta: Metadata;
-        presence: PresenceManager;
-        log?: (...args: any[]) => any;
-    });
-    private onOpen;
-    private onOnlineChange;
-    private onMessage;
-    private onError;
-    private onClose;
-    private initializeSocket;
-    private sendHeartbeat;
-    reconnect: () => void;
-    private canSkipSyncWait;
-    send: (message: ClientMessage) => void;
-    destroy: () => void;
-    start: () => void;
-    stop: () => void;
-    ignoreIncoming(): void;
-    get isConnected(): boolean;
-    get status(): "active" | "paused";
-}

package/dist/esm/types.d.ts

@@ -1,12 +0,0 @@
-import { Operation } from '@verdant-web/common';
-export type LogFunction = (...args: any[]) => void;
-/**
- * Operations moving through the client system are
- * tagged with whether or not they are stored in
- * the database (confirmed) or only in memory,
- * which might mean they are lost if the client
- * crashes.
- */
-export interface TaggedOperation extends Operation {
-    confirmed?: boolean;
-}

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

@@ -1,6 +0,0 @@
-export declare class Disposable {
-    private _disposes;
-    protected disposed: boolean;
-    dispose: () => void;
-    protected addDispose: (dispose: () => void) => void;
-}

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

@@ -1,8 +0,0 @@
-export declare class Resolvable<T> {
-    readonly promise: Promise<T>;
-    private _resolve;
-    private _reject;
-    constructor();
-    resolve(value: T): void;
-    reject(reason?: any): void;
-}

package/dist/esm/vanilla.d.ts

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