@verdant-web/store 2.0.1 → 2.0.3

package/dist/esm/sync/ServerSyncEndpointProvider.js

@@ -1,58 +1,58 @@
-import { assert, ReplicaType } from '@verdant-web/common';
-import { default as jwtDecode } from 'jwt-decode';
-export class ServerSyncEndpointProvider {
-    constructor(config) {
-        this.config = config;
-        this.cached = null;
-        this.type = ReplicaType.Realtime;
-        this.getEndpoints = async () => {
-            if (this.cached) {
-                return this.cached;
-            }
-            let result;
-            if (this.config.fetchAuth) {
-                result = await this.config.fetchAuth();
-            }
-            else {
-                result = await fetch(this.config.authEndpoint, {
-                    credentials: 'include',
-                }).then((res) => {
-                    if (!res.ok) {
-                        throw new Error(`Auth endpoint returned non-200 response: ${res.status}`);
-                    }
-                    else {
-                        return res.json();
-                    }
-                });
-            }
-            assert(result.accessToken, 'No access token provided from auth endpoint');
-            const decoded = jwtDecode(result.accessToken);
-            assert(decoded.url, 'No sync endpoint provided from auth endpoint');
-            assert(decoded.type !== undefined, 'No replica type provided from auth endpoint');
-            this.type = parseInt(decoded.type + '');
-            const url = new URL(decoded.url);
-            url.protocol = url.protocol.replace('ws', 'http');
-            const httpEndpoint = url.toString();
-            url.protocol = url.protocol.replace('http', 'ws');
-            const websocketEndpoint = url.toString();
-            let fileEndpoint = decoded.file;
-            if (!fileEndpoint) {
-                // default to http endpoint + '/files';
-                const fileUrl = new URL(httpEndpoint);
-                fileUrl.pathname = fileUrl.pathname + '/files';
-                fileEndpoint = fileUrl.toString();
-            }
-            this.cached = {
-                http: httpEndpoint,
-                websocket: websocketEndpoint,
-                files: fileEndpoint,
-                token: result.accessToken,
-            };
-            return this.cached;
-        };
-        if (!config.authEndpoint && !config.fetchAuth) {
-            throw new Error('Either authEndpoint or fetchAuth must be provided to ServerSyncEndpointProvider');
-        }
-    }
-}
+import { assert, ReplicaType } from '@verdant-web/common';
+import { default as jwtDecode } from 'jwt-decode';
+export class ServerSyncEndpointProvider {
+    constructor(config) {
+        this.config = config;
+        this.cached = null;
+        this.type = ReplicaType.Realtime;
+        this.getEndpoints = async () => {
+            if (this.cached) {
+                return this.cached;
+            }
+            let result;
+            if (this.config.fetchAuth) {
+                result = await this.config.fetchAuth();
+            }
+            else {
+                result = await fetch(this.config.authEndpoint, {
+                    credentials: 'include',
+                }).then((res) => {
+                    if (!res.ok) {
+                        throw new Error(`Auth endpoint returned non-200 response: ${res.status}`);
+                    }
+                    else {
+                        return res.json();
+                    }
+                });
+            }
+            assert(result.accessToken, 'No access token provided from auth endpoint');
+            const decoded = jwtDecode(result.accessToken);
+            assert(decoded.url, 'No sync endpoint provided from auth endpoint');
+            assert(decoded.type !== undefined, 'No replica type provided from auth endpoint');
+            this.type = parseInt(decoded.type + '');
+            const url = new URL(decoded.url);
+            url.protocol = url.protocol.replace('ws', 'http');
+            const httpEndpoint = url.toString();
+            url.protocol = url.protocol.replace('http', 'ws');
+            const websocketEndpoint = url.toString();
+            let fileEndpoint = decoded.file;
+            if (!fileEndpoint) {
+                // default to http endpoint + '/files';
+                const fileUrl = new URL(httpEndpoint);
+                fileUrl.pathname = fileUrl.pathname + '/files';
+                fileEndpoint = fileUrl.toString();
+            }
+            this.cached = {
+                http: httpEndpoint,
+                websocket: websocketEndpoint,
+                files: fileEndpoint,
+                token: result.accessToken,
+            };
+            return this.cached;
+        };
+        if (!config.authEndpoint && !config.fetchAuth) {
+            throw new Error('Either authEndpoint or fetchAuth must be provided to ServerSyncEndpointProvider');
+        }
+    }
+}
 //# sourceMappingURL=ServerSyncEndpointProvider.js.map

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

@@ -1,127 +1,127 @@
-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;
-};
-export type SyncTransportEvents = SyncEvents & {
-    message: (message: ServerMessage) => void;
-};
-export interface SyncTransport {
-    subscribe(event: 'onlineChange', handler: (online: boolean) => void): () => void;
-    readonly presence: PresenceManager;
-    readonly mode: SyncTransportMode;
-    send(message: ClientMessage): void;
-    start(): void;
-    stop(): void;
-    dispose(): void;
-    reconnect(): void;
-    readonly isConnected: boolean;
-    readonly status: 'active' | 'paused';
-}
-export interface Sync extends SyncTransport {
-    setMode(mode: SyncTransportMode): void;
-    setPullInterval(interval: number): void;
-    readonly pullInterval: number;
-    uploadFile(data: FileData): Promise<FileUploadResult>;
-    getFile(fileId: string): Promise<FilePullResult>;
-}
-export declare class NoSync extends EventSubscriber<SyncEvents> implements Sync {
-    readonly mode = "pull";
-    send(): void;
-    start(): void;
-    stop(): void;
-    dispose: () => void;
-    reconnect(): void;
-    setMode(): void;
-    setPullInterval(): void;
-    readonly isConnected = false;
-    readonly status = "paused";
-    readonly pullInterval = 0;
-    readonly presence: PresenceManager<{}, {}>;
-    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.
-     *
-     * 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;
-    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;
-}
-export declare class ServerSync<Profile = any, Presence = any> extends EventSubscriber<SyncEvents> implements Sync {
-    private webSocketSync;
-    private pushPullSync;
-    private fileSync;
-    private activeSync;
-    private endpointProvider;
-    private onData;
-    private meta;
-    readonly presence: PresenceManager<Profile, Presence>;
-    private log;
-    constructor({ authEndpoint, fetchAuth, initialPresence, automaticTransportSelection, autoStart, initialTransport, pullInterval, presenceUpdateBatchTimeout, defaultProfile, }: 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;
-    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;
-    dispose: () => void;
-    reconnect: () => void;
-    get isConnected(): boolean;
-    get status(): "active" | "paused";
-    get mode(): SyncTransportMode;
-}
-export {};
+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;
+};
+export type SyncTransportEvents = SyncEvents & {
+    message: (message: ServerMessage) => void;
+};
+export interface SyncTransport {
+    subscribe(event: 'onlineChange', handler: (online: boolean) => void): () => void;
+    readonly presence: PresenceManager;
+    readonly mode: SyncTransportMode;
+    send(message: ClientMessage): void;
+    start(): void;
+    stop(): void;
+    dispose(): void;
+    reconnect(): void;
+    readonly isConnected: boolean;
+    readonly status: 'active' | 'paused';
+}
+export interface Sync extends SyncTransport {
+    setMode(mode: SyncTransportMode): void;
+    setPullInterval(interval: number): void;
+    readonly pullInterval: number;
+    uploadFile(data: FileData): Promise<FileUploadResult>;
+    getFile(fileId: string): Promise<FilePullResult>;
+}
+export declare class NoSync extends EventSubscriber<SyncEvents> implements Sync {
+    readonly mode = "pull";
+    send(): void;
+    start(): void;
+    stop(): void;
+    dispose: () => void;
+    reconnect(): void;
+    setMode(): void;
+    setPullInterval(): void;
+    readonly isConnected = false;
+    readonly status = "paused";
+    readonly pullInterval = 0;
+    readonly presence: PresenceManager<{}, {}>;
+    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.
+     *
+     * 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;
+    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;
+}
+export declare class ServerSync<Profile = any, Presence = any> extends EventSubscriber<SyncEvents> implements Sync {
+    private webSocketSync;
+    private pushPullSync;
+    private fileSync;
+    private activeSync;
+    private endpointProvider;
+    private onData;
+    private meta;
+    readonly presence: PresenceManager<Profile, Presence>;
+    private log;
+    constructor({ authEndpoint, fetchAuth, initialPresence, automaticTransportSelection, autoStart, initialTransport, pullInterval, presenceUpdateBatchTimeout, defaultProfile, }: 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;
+    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;
+    dispose: () => void;
+    reconnect: () => void;
+    get isConnected(): boolean;
+    get status(): "active" | "paused";
+    get mode(): SyncTransportMode;
+}
+export {};