@verdant-web/store 2.7.7-next.0 → 2.7.8

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

@@ -1,36 +1,36 @@
-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;
-    readonly mode = "pull";
-    private log;
-    private _isConnected;
-    private _status;
-    private _hasSynced;
-    constructor({ endpointProvider, meta, presence, interval, log, }: {
-        endpointProvider: ServerSyncEndpointProvider;
-        meta: Metadata;
-        presence: PresenceManager;
-        interval?: number;
-        log?: (...args: any[]) => any;
-    });
-    setInterval: (interval: number) => void;
-    get interval(): number;
-    private sendRequest;
-    private handleServerMessage;
-    send: (message: ClientMessage) => Promise<void> | undefined;
-    start(): void;
-    stop(): void;
-    dispose: () => void;
-    reconnect(): void;
-    private onHeartbeat;
-    private onHeartbeatMissed;
-    get isConnected(): boolean;
-    get status(): "active" | "paused";
-}
+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;
+    readonly mode = "pull";
+    private log;
+    private _isConnected;
+    private _status;
+    private _hasSynced;
+    constructor({ endpointProvider, meta, presence, interval, log, }: {
+        endpointProvider: ServerSyncEndpointProvider;
+        meta: Metadata;
+        presence: PresenceManager;
+        interval?: number;
+        log?: (...args: any[]) => any;
+    });
+    setInterval: (interval: number) => void;
+    get interval(): number;
+    private sendRequest;
+    private handleServerMessage;
+    send: (message: ClientMessage) => Promise<void> | undefined;
+    start(): void;
+    stop(): void;
+    dispose: () => void;
+    reconnect(): void;
+    private onHeartbeat;
+    private onHeartbeatMissed;
+    get isConnected(): boolean;
+    get status(): "active" | "paused";
+}

package/dist/esm/sync/PushPullSync.js

@@ -1,140 +1,140 @@
-import { EventSubscriber, } from '@verdant-web/common';
-import { Heartbeat } from './Heartbeat.js';
-export class PushPullSync extends EventSubscriber {
-    constructor({ endpointProvider, meta, presence, interval = 15 * 1000, log = () => { }, }) {
-        super();
-        this.mode = 'pull';
-        this._isConnected = false;
-        this._status = 'paused';
-        this._hasSynced = false;
-        this.setInterval = (interval) => {
-            this.heartbeat.setInterval(interval);
-        };
-        this.sendRequest = async (messages) => {
-            this.log('Sending sync request', messages);
-            try {
-                const { http: host, token } = await this.endpointProvider.getEndpoints();
-                const response = await fetch(host, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        Authorization: `Bearer ${token}`,
-                    },
-                    body: JSON.stringify({
-                        messages,
-                    }),
-                    credentials: 'include',
-                });
-                if (response.ok) {
-                    this.heartbeat.keepAlive();
-                    const json = (await response.json());
-                    for (const message of json.messages) {
-                        this.handleServerMessage(message);
-                    }
-                    if (!this._isConnected) {
-                        this._isConnected = true;
-                        this.emit('onlineChange', true);
-                    }
-                }
-                else {
-                    this.log('Sync request failed', response.status, await response.text());
-                    if (this._isConnected) {
-                        this._isConnected = false;
-                        this.emit('onlineChange', false);
-                    }
-                    // only keep trying if the error was not 4xx
-                    if (response.status >= 500) {
-                        this.heartbeat.keepAlive();
-                    }
-                }
-            }
-            catch (error) {
-                if (this._isConnected) {
-                    this._isConnected = false;
-                    this.emit('onlineChange', false);
-                }
-                this.log(error);
-                this.heartbeat.keepAlive();
-            }
-        };
-        this.handleServerMessage = async (message) => {
-            if (message.type === 'sync-resp') {
-                if (message.ackThisNonce) {
-                    // we need to ack the nonce to confirm that we received the sync-resp
-                    this.log('Sending sync ack', message.ackThisNonce);
-                    this.sendRequest([
-                        await this.meta.messageCreator.createAck(message.ackThisNonce),
-                    ]);
-                }
-                // but we can go ahead and preemptively allow ops to be sent
-                this._hasSynced = true;
-            }
-            this.emit('message', message);
-        };
-        this.send = (message) => {
-            // only certain messages are sent for pull-based sync.
-            switch (message.type) {
-                case 'presence-update':
-                case 'sync':
-                case 'heartbeat':
-                    return this.sendRequest([message]);
-                case 'op':
-                    if (this._hasSynced) {
-                        return this.sendRequest([message]);
-                    }
-                    break;
-            }
-        };
-        this.dispose = () => { };
-        // on a heartbeat, do a sync
-        this.onHeartbeat = async () => {
-            // for HTTP sync we send presence first, so that the sync-resp message
-            // will include the client's own presence info and fill in missing profile
-            // data on the first request. otherwise it would have to wait for the second.
-            this.sendRequest([
-                await this.meta.messageCreator.createPresenceUpdate(this.presence.self.presence),
-                await this.meta.messageCreator.createSyncStep1(),
-            ]);
-        };
-        // if the server fails to respond in a certain amount of time, we assume
-        // the connection is lost and go offline.
-        this.onHeartbeatMissed = async () => {
-            this.emit('onlineChange', false);
-            this.log('Missed heartbeat');
-            this._isConnected = false;
-        };
-        this.log = log;
-        this.meta = meta;
-        this.presence = presence;
-        this.endpointProvider = endpointProvider;
-        this.heartbeat = new Heartbeat({
-            interval,
-        });
-        this.heartbeat.subscribe('beat', this.onHeartbeat);
-        this.heartbeat.subscribe('missed', this.onHeartbeatMissed);
-    }
-    get interval() {
-        return this.heartbeat.interval;
-    }
-    start() {
-        if (this.status === 'active') {
-            return;
-        }
-        this.heartbeat.start(true);
-        this._status = 'active';
-    }
-    stop() {
-        this.heartbeat.stop();
-        this._status = 'paused';
-    }
-    reconnect() {
-        this.heartbeat.start(true);
-    }
-    get isConnected() {
-        return this._isConnected;
-    }
-    get status() {
-        return this._status;
-    }
-}
+import { EventSubscriber, } from '@verdant-web/common';
+import { Heartbeat } from './Heartbeat.js';
+export class PushPullSync extends EventSubscriber {
+    constructor({ endpointProvider, meta, presence, interval = 15 * 1000, log = () => { }, }) {
+        super();
+        this.mode = 'pull';
+        this._isConnected = false;
+        this._status = 'paused';
+        this._hasSynced = false;
+        this.setInterval = (interval) => {
+            this.heartbeat.setInterval(interval);
+        };
+        this.sendRequest = async (messages) => {
+            this.log('Sending sync request', messages);
+            try {
+                const { http: host, token } = await this.endpointProvider.getEndpoints();
+                const response = await fetch(host, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${token}`,
+                    },
+                    body: JSON.stringify({
+                        messages,
+                    }),
+                    credentials: 'include',
+                });
+                if (response.ok) {
+                    this.heartbeat.keepAlive();
+                    const json = (await response.json());
+                    for (const message of json.messages) {
+                        this.handleServerMessage(message);
+                    }
+                    if (!this._isConnected) {
+                        this._isConnected = true;
+                        this.emit('onlineChange', true);
+                    }
+                }
+                else {
+                    this.log('Sync request failed', response.status, await response.text());
+                    if (this._isConnected) {
+                        this._isConnected = false;
+                        this.emit('onlineChange', false);
+                    }
+                    // only keep trying if the error was not 4xx
+                    if (response.status >= 500) {
+                        this.heartbeat.keepAlive();
+                    }
+                }
+            }
+            catch (error) {
+                if (this._isConnected) {
+                    this._isConnected = false;
+                    this.emit('onlineChange', false);
+                }
+                this.log(error);
+                this.heartbeat.keepAlive();
+            }
+        };
+        this.handleServerMessage = async (message) => {
+            if (message.type === 'sync-resp') {
+                if (message.ackThisNonce) {
+                    // we need to ack the nonce to confirm that we received the sync-resp
+                    this.log('Sending sync ack', message.ackThisNonce);
+                    this.sendRequest([
+                        await this.meta.messageCreator.createAck(message.ackThisNonce),
+                    ]);
+                }
+                // but we can go ahead and preemptively allow ops to be sent
+                this._hasSynced = true;
+            }
+            this.emit('message', message);
+        };
+        this.send = (message) => {
+            // only certain messages are sent for pull-based sync.
+            switch (message.type) {
+                case 'presence-update':
+                case 'sync':
+                case 'heartbeat':
+                    return this.sendRequest([message]);
+                case 'op':
+                    if (this._hasSynced) {
+                        return this.sendRequest([message]);
+                    }
+                    break;
+            }
+        };
+        this.dispose = () => { };
+        // on a heartbeat, do a sync
+        this.onHeartbeat = async () => {
+            // for HTTP sync we send presence first, so that the sync-resp message
+            // will include the client's own presence info and fill in missing profile
+            // data on the first request. otherwise it would have to wait for the second.
+            this.sendRequest([
+                await this.meta.messageCreator.createPresenceUpdate(this.presence.self.presence),
+                await this.meta.messageCreator.createSyncStep1(),
+            ]);
+        };
+        // if the server fails to respond in a certain amount of time, we assume
+        // the connection is lost and go offline.
+        this.onHeartbeatMissed = async () => {
+            this.emit('onlineChange', false);
+            this.log('Missed heartbeat');
+            this._isConnected = false;
+        };
+        this.log = log;
+        this.meta = meta;
+        this.presence = presence;
+        this.endpointProvider = endpointProvider;
+        this.heartbeat = new Heartbeat({
+            interval,
+        });
+        this.heartbeat.subscribe('beat', this.onHeartbeat);
+        this.heartbeat.subscribe('missed', this.onHeartbeatMissed);
+    }
+    get interval() {
+        return this.heartbeat.interval;
+    }
+    start() {
+        if (this.status === 'active') {
+            return;
+        }
+        this.heartbeat.start(true);
+        this._status = 'active';
+    }
+    stop() {
+        this.heartbeat.stop();
+        this._status = 'paused';
+    }
+    reconnect() {
+        this.heartbeat.start(true);
+    }
+    get isConnected() {
+        return this._isConnected;
+    }
+    get status() {
+        return this._status;
+    }
+}
 //# sourceMappingURL=PushPullSync.js.map

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

@@ -1,27 +1,27 @@
-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 fetch function to retrieve authorization
-     * data.
-     */
-    fetchAuth?: () => Promise<{
-        accessToken: string;
-    }>;
-}
-export declare class ServerSyncEndpointProvider {
-    private config;
-    private cached;
-    type: ReplicaType;
-    constructor(config: ServerSyncEndpointProviderConfig);
-    getEndpoints: () => Promise<{
-        http: string;
-        websocket: string;
-        files: string;
-        token: string;
-    }>;
-}
+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 fetch function to retrieve authorization
+     * data.
+     */
+    fetchAuth?: () => Promise<{
+        accessToken: string;
+    }>;
+}
+export declare class ServerSyncEndpointProvider {
+    private config;
+    private cached;
+    type: ReplicaType;
+    constructor(config: ServerSyncEndpointProviderConfig);
+    getEndpoints: () => Promise<{
+        http: string;
+        websocket: string;
+        files: string;
+        token: string;
+    }>;
+}

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