tinybase 5.0.0-beta.27 → 5.0.0-beta.28

package/@types/synchronizers/synchronizer-broadcast-channel/with-schemas/index.d.ts

@@ -0,0 +1,128 @@
+/**
+ * The synchronizer-broadcast-channel module of the TinyBase project lets you
+ * synchronize MergeableStore data to and from other MergeableStore instances
+ * via a browser's BroadcastChannel API.
+ * @see Synchronization guide
+ * @packageDocumentation
+ * @module synchronizer-broadcast-channel
+ * @since v5.0.0
+ */
+
+import type {MergeableStore} from '../../../mergeable-store/with-schemas/index.d.ts';
+import type {OptionalSchemas} from '../../../store/with-schemas/index.d.ts';
+import type {Synchronizer} from '../../with-schemas/index.d.ts';
+
+/**
+ * The BroadcastChannelSynchronizer interface represents a Synchronizer that
+ * lets you synchronize MergeableStore data to and from other MergeableStore
+ * instances via a browser's BroadcastChannel API.
+ *
+ * You should use the createBroadcastChannelSynchronizer function to create a
+ * BroadcastChannelSynchronizer object.
+ *
+ * It is a minor extension to the Synchronizer interface and simply provides an
+ * extra getChannelName method for accessing the name of the channel being used.
+ * @category Synchronizer
+ * @since v5.0.0
+ */
+export interface BroadcastChannelSynchronizer<Schemas extends OptionalSchemas>
+  extends Synchronizer<Schemas> {
+  /**
+   * The getChannelName method returns the name of the channel being used for
+   * synchronization.
+   * @returns The channel name.
+   * @example
+   * This example creates a BroadcastChannelSynchronizer object for a
+   * newly-created MergeableStore and then gets the channel name back out again.
+   *
+   * ```js
+   * import {createBroadcastChannelSynchronizer} from 'tinybase/synchronizers/synchronizer-broadcast-channel';
+   * import {createMergeableStore} from 'tinybase';
+   *
+   * const store = createMergeableStore();
+   * const synchronizer = await createBroadcastChannelSynchronizer(
+   *   store,
+   *   'channelA',
+   * );
+   *
+   * console.log(synchronizer.getChannelName());
+   * // -> 'channelA'
+   *
+   * synchronizer.destroy();
+   * ```
+   * @category Getter
+   * @since v5.0.0
+   */
+  getChannelName(): string;
+}
+
+/**
+ * The createBroadcastChannelSynchronizer function creates a
+ * BroadcastChannelSynchronizer object that can synchronize MergeableStore data
+ * to and from other MergeableStore instances via a browser's BroadcastChannel
+ * API.
+ *
+ * This has schema-based typing. The following is a simplified representation:
+ *
+ * ```ts override
+ * createBroadcastChannelSynchronizer(
+ *   store: MergeableStore,
+ *   channelName: string,
+ *   onIgnoredError?: (error: any) => void,
+ * ): BroadcastChannelSynchronizer;
+ * ```
+ *
+ * As well as providing a reference to the MergeableStore to persist, you must
+ * provide a channel name, used by all the browser tabs, workers, or contexts
+ * that need to synchronize together.
+ * @param store The MergeableStore to synchronize.
+ * @param channelName The name of the channel to use.
+ * @param onIgnoredError An optional handler for the errors that the
+ * Synchronizer would otherwise ignore when trying to synchronize data. This is
+ * suitable for debugging synchronization issues in a development environment.
+ * @returns A reference to the new BroadcastChannelSynchronizer object.
+ * @example
+ * This example creates two BroadcastChannelSynchronizer objects to synchronize
+ * one MergeableStore to another.
+ *
+ * ```js
+ * import {createBroadcastChannelSynchronizer} from 'tinybase/synchronizers/synchronizer-broadcast-channel';
+ * import {createMergeableStore} from 'tinybase';
+ *
+ * const store1 = createMergeableStore();
+ * const store2 = createMergeableStore();
+ *
+ * const synchronizer1 = createBroadcastChannelSynchronizer(
+ *   store1,
+ *   'channelA',
+ * );
+ * const synchronizer2 = createBroadcastChannelSynchronizer(
+ *   store2,
+ *   'channelA',
+ * );
+ *
+ * await synchronizer1.startSync();
+ * await synchronizer2.startSync();
+ *
+ * store1.setTables({pets: {fido: {species: 'dog'}}});
+ * store2.setTables({pets: {felix: {species: 'cat'}}});
+ *
+ * // ...
+ * console.log(store1.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
+ * console.log(store2.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
+ *
+ * synchronizer1.destroy();
+ * synchronizer2.destroy();
+ * ```
+ * @category Creation
+ * @since v5.0.0
+ */
+export function createBroadcastChannelSynchronizer<
+  Schemas extends OptionalSchemas,
+>(
+  store: MergeableStore<Schemas>,
+  channelName: string,
+  onIgnoredError?: (error: any) => void,
+): BroadcastChannelSynchronizer<Schemas>;

package/@types/synchronizers/synchronizer-local/index.d.cts

@@ -2,7 +2,7 @@
  * The synchronizer-local module of the TinyBase project lets you synchronize
  * MergeableStore data to and from other MergeableStore instances on the same
  * local machine.
- * @see Synchronizing Data guide
+ * @see Synchronization guide
  * @packageDocumentation
  * @module synchronizer-local
  * @since v5.0.0
@@ -16,15 +16,15 @@ import type {Synchronizer} from '../index.d.cts';
  * synchronize MergeableStore data to and from other MergeableStore instances on
  * the same local machine.
  *
+ * You should use the createLocalSynchronizer function to create a
+ * LocalSynchronizer object.
+ *
  * Having no specialized methods, it is a synonym for the Synchronizer
  * interface. This is also something of a showcase Synchronizer, rather than
  * something you would use in a production environment. If you _do_ need to
  * synchronize two in-memory MergeableStore instances, you may prefer to use the
  * merge function on either one of them instead of going to the effort of
  * setting up this Synchronizer.
- *
- * You should use the createLocalSynchronizer function to create a
- * LocalSynchronizer object.
  * @category Synchronizer
  * @since v5.0.0
  */
@@ -49,31 +49,30 @@ export interface LocalSynchronizer extends Synchronizer {}
  * suitable for debugging synchronization issues in a development environment.
  * @returns A reference to the new LocalSynchronizer object.
  * @example
- * This example creates a LocalSynchronizer object and synchronizes one
+ * This example creates two LocalSynchronizer objects to synchronize one
  * MergeableStore to another.
  *
  * ```js
  * import {createLocalSynchronizer} from 'tinybase/synchronizers/synchronizer-local';
  * import {createMergeableStore} from 'tinybase';
  *
- * const store1 = createMergeableStore('store1').setTables({
- *   pets: {fido: {species: 'dog'}},
- * });
- * const synchronizer1 = createLocalSynchronizer(store1);
+ * const store1 = createMergeableStore();
+ * const store2 = createMergeableStore();
  *
- * const store2 = createMergeableStore('store2');
+ * const synchronizer1 = createLocalSynchronizer(store1);
  * const synchronizer2 = createLocalSynchronizer(store2);
+ *
+ * await synchronizer1.startSync();
  * await synchronizer2.startSync();
  *
- * await synchronizer1.save();
- * // ...
- * // Store2 will be synced with Store1.
+ * store1.setTables({pets: {fido: {species: 'dog'}}});
+ * store2.setTables({pets: {felix: {species: 'cat'}}});
  *
+ * // ...
+ * console.log(store1.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
  * console.log(store2.getTables());
- * // -> {pets: {fido: {species: 'dog'}}}
- *
- * await synchronizer1.load();
- * // Store1 will be synced with Store2.
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
  *
  * synchronizer1.destroy();
  * synchronizer2.destroy();

package/@types/synchronizers/synchronizer-local/index.d.ts

@@ -2,7 +2,7 @@
  * The synchronizer-local module of the TinyBase project lets you synchronize
  * MergeableStore data to and from other MergeableStore instances on the same
  * local machine.
- * @see Synchronizing Data guide
+ * @see Synchronization guide
  * @packageDocumentation
  * @module synchronizer-local
  * @since v5.0.0
@@ -16,15 +16,15 @@ import type {Synchronizer} from '../index.d.ts';
  * synchronize MergeableStore data to and from other MergeableStore instances on
  * the same local machine.
  *
+ * You should use the createLocalSynchronizer function to create a
+ * LocalSynchronizer object.
+ *
  * Having no specialized methods, it is a synonym for the Synchronizer
  * interface. This is also something of a showcase Synchronizer, rather than
  * something you would use in a production environment. If you _do_ need to
  * synchronize two in-memory MergeableStore instances, you may prefer to use the
  * merge function on either one of them instead of going to the effort of
  * setting up this Synchronizer.
- *
- * You should use the createLocalSynchronizer function to create a
- * LocalSynchronizer object.
  * @category Synchronizer
  * @since v5.0.0
  */
@@ -49,31 +49,30 @@ export interface LocalSynchronizer extends Synchronizer {}
  * suitable for debugging synchronization issues in a development environment.
  * @returns A reference to the new LocalSynchronizer object.
  * @example
- * This example creates a LocalSynchronizer object and synchronizes one
+ * This example creates two LocalSynchronizer objects to synchronize one
  * MergeableStore to another.
  *
  * ```js
  * import {createLocalSynchronizer} from 'tinybase/synchronizers/synchronizer-local';
  * import {createMergeableStore} from 'tinybase';
  *
- * const store1 = createMergeableStore('store1').setTables({
- *   pets: {fido: {species: 'dog'}},
- * });
- * const synchronizer1 = createLocalSynchronizer(store1);
+ * const store1 = createMergeableStore();
+ * const store2 = createMergeableStore();
  *
- * const store2 = createMergeableStore('store2');
+ * const synchronizer1 = createLocalSynchronizer(store1);
  * const synchronizer2 = createLocalSynchronizer(store2);
+ *
+ * await synchronizer1.startSync();
  * await synchronizer2.startSync();
  *
- * await synchronizer1.save();
- * // ...
- * // Store2 will be synced with Store1.
+ * store1.setTables({pets: {fido: {species: 'dog'}}});
+ * store2.setTables({pets: {felix: {species: 'cat'}}});
  *
+ * // ...
+ * console.log(store1.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
  * console.log(store2.getTables());
- * // -> {pets: {fido: {species: 'dog'}}}
- *
- * await synchronizer1.load();
- * // Store1 will be synced with Store2.
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
  *
  * synchronizer1.destroy();
  * synchronizer2.destroy();

package/@types/synchronizers/synchronizer-local/with-schemas/index.d.cts

@@ -2,7 +2,7 @@
  * The synchronizer-local module of the TinyBase project lets you synchronize
  * MergeableStore data to and from other MergeableStore instances on the same
  * local machine.
- * @see Synchronizing Data guide
+ * @see Synchronization guide
  * @packageDocumentation
  * @module synchronizer-local
  * @since v5.0.0
@@ -23,15 +23,15 @@ import type {Synchronizer} from '../../with-schemas/index.d.cts';
  * export interface LocalSynchronizer extends Synchronizer {}
  * ```
  *
+ * You should use the createLocalSynchronizer function to create a
+ * LocalSynchronizer object.
+ *
  * Having no specialized methods, it is a synonym for the Synchronizer
  * interface. This is also something of a showcase Synchronizer, rather than
  * something you would use in a production environment. If you _do_ need to
  * synchronize two in-memory MergeableStore instances, you may prefer to use the
  * merge function on either one of them instead of going to the effort of
  * setting up this Synchronizer.
- *
- * You should use the createLocalSynchronizer function to create a
- * LocalSynchronizer object.
  * @category Synchronizer
  * @since v5.0.0
  */
@@ -66,31 +66,30 @@ export interface LocalSynchronizer<Schemas extends OptionalSchemas>
  * suitable for debugging synchronization issues in a development environment.
  * @returns A reference to the new LocalSynchronizer object.
  * @example
- * This example creates a LocalSynchronizer object and synchronizes one
+ * This example creates two LocalSynchronizer objects to synchronize one
  * MergeableStore to another.
  *
  * ```js
  * import {createLocalSynchronizer} from 'tinybase/synchronizers/synchronizer-local';
  * import {createMergeableStore} from 'tinybase';
  *
- * const store1 = createMergeableStore('store1').setTables({
- *   pets: {fido: {species: 'dog'}},
- * });
- * const synchronizer1 = createLocalSynchronizer(store1);
+ * const store1 = createMergeableStore();
+ * const store2 = createMergeableStore();
  *
- * const store2 = createMergeableStore('store2');
+ * const synchronizer1 = createLocalSynchronizer(store1);
  * const synchronizer2 = createLocalSynchronizer(store2);
+ *
+ * await synchronizer1.startSync();
  * await synchronizer2.startSync();
  *
- * await synchronizer1.save();
- * // ...
- * // Store2 will be synced with Store1.
+ * store1.setTables({pets: {fido: {species: 'dog'}}});
+ * store2.setTables({pets: {felix: {species: 'cat'}}});
  *
+ * // ...
+ * console.log(store1.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
  * console.log(store2.getTables());
- * // -> {pets: {fido: {species: 'dog'}}}
- *
- * await synchronizer1.load();
- * // Store1 will be synced with Store2.
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
  *
  * synchronizer1.destroy();
  * synchronizer2.destroy();

package/@types/synchronizers/synchronizer-local/with-schemas/index.d.ts

@@ -2,7 +2,7 @@
  * The synchronizer-local module of the TinyBase project lets you synchronize
  * MergeableStore data to and from other MergeableStore instances on the same
  * local machine.
- * @see Synchronizing Data guide
+ * @see Synchronization guide
  * @packageDocumentation
  * @module synchronizer-local
  * @since v5.0.0
@@ -23,15 +23,15 @@ import type {Synchronizer} from '../../with-schemas/index.d.ts';
  * export interface LocalSynchronizer extends Synchronizer {}
  * ```
  *
+ * You should use the createLocalSynchronizer function to create a
+ * LocalSynchronizer object.
+ *
  * Having no specialized methods, it is a synonym for the Synchronizer
  * interface. This is also something of a showcase Synchronizer, rather than
  * something you would use in a production environment. If you _do_ need to
  * synchronize two in-memory MergeableStore instances, you may prefer to use the
  * merge function on either one of them instead of going to the effort of
  * setting up this Synchronizer.
- *
- * You should use the createLocalSynchronizer function to create a
- * LocalSynchronizer object.
  * @category Synchronizer
  * @since v5.0.0
  */
@@ -66,31 +66,30 @@ export interface LocalSynchronizer<Schemas extends OptionalSchemas>
  * suitable for debugging synchronization issues in a development environment.
  * @returns A reference to the new LocalSynchronizer object.
  * @example
- * This example creates a LocalSynchronizer object and synchronizes one
+ * This example creates two LocalSynchronizer objects to synchronize one
  * MergeableStore to another.
  *
  * ```js
  * import {createLocalSynchronizer} from 'tinybase/synchronizers/synchronizer-local';
  * import {createMergeableStore} from 'tinybase';
  *
- * const store1 = createMergeableStore('store1').setTables({
- *   pets: {fido: {species: 'dog'}},
- * });
- * const synchronizer1 = createLocalSynchronizer(store1);
+ * const store1 = createMergeableStore();
+ * const store2 = createMergeableStore();
  *
- * const store2 = createMergeableStore('store2');
+ * const synchronizer1 = createLocalSynchronizer(store1);
  * const synchronizer2 = createLocalSynchronizer(store2);
+ *
+ * await synchronizer1.startSync();
  * await synchronizer2.startSync();
  *
- * await synchronizer1.save();
- * // ...
- * // Store2 will be synced with Store1.
+ * store1.setTables({pets: {fido: {species: 'dog'}}});
+ * store2.setTables({pets: {felix: {species: 'cat'}}});
  *
+ * // ...
+ * console.log(store1.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
  * console.log(store2.getTables());
- * // -> {pets: {fido: {species: 'dog'}}}
- *
- * await synchronizer1.load();
- * // Store1 will be synced with Store2.
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
  *
  * synchronizer1.destroy();
  * synchronizer2.destroy();

package/@types/synchronizers/synchronizer-ws-client/index.d.cts

@@ -2,7 +2,7 @@
  * The synchronizer-ws module of the TinyBase project lets you synchronize
  * MergeableStore data to and from other MergeableStore instances via WebSockets
  * facilitated by a server.
- * @see Synchronizing Data guide
+ * @see Synchronization guide
  * @see Todo App v6 (collaboration) demo
  * @packageDocumentation
  * @module synchronizer-ws-client
@@ -20,6 +20,8 @@ import type {WebSocket as WsWebSocket} from 'ws';
  * This includes the browser-native WebSocket type, as well as the WebSocket
  * type from the well-known `ws` package (such that the Synchronizer can be used
  * in a server environment).
+ * @category Creation
+ * @since v5.0.0
  */
 export type WebSocketTypes = WebSocket | WsWebSocket;
 
@@ -28,19 +30,19 @@ export type WebSocketTypes = WebSocket | WsWebSocket;
  * synchronize MergeableStore data to and from other MergeableStore instances
  * via WebSockets facilitated by a server.
  *
+ * You should use the createWsSynchronizer function to create a WsSynchronizer
+ * object.
+ *
  * It is a minor extension to the Synchronizer interface and simply provides an
  * extra getWebSocket method for accessing a reference to the WebSocket being
  * used.
- *
- * You should use the createWsSynchronizer function to create a WsSynchronizer
- * object.
  * @category Synchronizer
  * @since v5.0.0
  */
 export interface WsSynchronizer<WebSocketType extends WebSocketTypes>
   extends Synchronizer {
   /**
-   * The getWebSocket method returns reference to the WebSocket being used for
+   * The getWebSocket method returns a reference to the WebSocket being used for
    * synchronization.
    * @returns The WebSocket reference.
    * @example
@@ -72,8 +74,66 @@ export interface WsSynchronizer<WebSocketType extends WebSocketTypes>
 }
 
 /**
- * The createWsSynchronizer function.
+ * The createWsSynchronizer function creates a WsSynchronizer object that can
+ * synchronize MergeableStore data to and from other MergeableStore instances
+ * via WebSockets facilitated by a WsServer.
+ *
+ * As well as providing a reference to the MergeableStore to persist, you must
+ * provide a configured WebSocket to send synchronization messages over.
+ *
+ * This method is asynchronous because it will await the websocket's connection
+ * to the server. You will need to `await` a call to this function or handle the
+ * return type natively as a Promise.
+ * @param store The MergeableStore to synchronize.
+ * @param webSocket The WebSocket to send synchronization messages over.
+ * @param requestTimeoutSeconds An optional time in seconds that the
+ * Synchronizer will wait for responses to request messages, defaulting to 1.
+ * @param onIgnoredError An optional handler for the errors that the
+ * Synchronizer would otherwise ignore when trying to synchronize data. This is
+ * suitable for debugging synchronization issues in a development environment.
+ * @returns A reference to the new WsSynchronizer object.
+ * @example
+ * This example creates two WsSynchronizer objects to synchronize one
+ * MergeableStore to another via a server.
+ *
+ * ```js
+ * import {WebSocket, WebSocketServer} from 'ws';
+ * import {createMergeableStore} from 'tinybase';
+ * import {createWsServer} from 'tinybase/synchronizers/synchronizer-ws-server';
+ * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
+ *
+ * const server = createWsServer(new WebSocketServer({port: 8047}));
+ *
+ * const store1 = createMergeableStore();
+ * const store2 = createMergeableStore();
+ *
+ * const synchronizer1 = await createWsSynchronizer(
+ *   store1,
+ *   new WebSocket('ws://localhost:8047'),
+ * );
+ * const synchronizer2 = await createWsSynchronizer(
+ *   store2,
+ *   new WebSocket('ws://localhost:8047'),
+ * );
+ *
+ * await synchronizer1.startSync();
+ * await synchronizer2.startSync();
+ *
+ * store1.setTables({pets: {fido: {species: 'dog'}}});
+ * store2.setTables({pets: {felix: {species: 'cat'}}});
+ *
+ * // ...
+ * console.log(store1.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
+ * console.log(store2.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
+ *
+ * synchronizer1.destroy();
+ * synchronizer2.destroy();
+ * server.destroy();
+ * ```
  * @category Creation
+ * @since v5.0.0
  */
 export function createWsSynchronizer<WebSocketType extends WebSocketTypes>(
   store: MergeableStore,

package/@types/synchronizers/synchronizer-ws-client/index.d.ts

@@ -2,7 +2,7 @@
  * The synchronizer-ws module of the TinyBase project lets you synchronize
  * MergeableStore data to and from other MergeableStore instances via WebSockets
  * facilitated by a server.
- * @see Synchronizing Data guide
+ * @see Synchronization guide
  * @see Todo App v6 (collaboration) demo
  * @packageDocumentation
  * @module synchronizer-ws-client
@@ -20,6 +20,8 @@ import type {WebSocket as WsWebSocket} from 'ws';
  * This includes the browser-native WebSocket type, as well as the WebSocket
  * type from the well-known `ws` package (such that the Synchronizer can be used
  * in a server environment).
+ * @category Creation
+ * @since v5.0.0
  */
 export type WebSocketTypes = WebSocket | WsWebSocket;
 
@@ -28,19 +30,19 @@ export type WebSocketTypes = WebSocket | WsWebSocket;
  * synchronize MergeableStore data to and from other MergeableStore instances
  * via WebSockets facilitated by a server.
  *
+ * You should use the createWsSynchronizer function to create a WsSynchronizer
+ * object.
+ *
  * It is a minor extension to the Synchronizer interface and simply provides an
  * extra getWebSocket method for accessing a reference to the WebSocket being
  * used.
- *
- * You should use the createWsSynchronizer function to create a WsSynchronizer
- * object.
  * @category Synchronizer
  * @since v5.0.0
  */
 export interface WsSynchronizer<WebSocketType extends WebSocketTypes>
   extends Synchronizer {
   /**
-   * The getWebSocket method returns reference to the WebSocket being used for
+   * The getWebSocket method returns a reference to the WebSocket being used for
    * synchronization.
    * @returns The WebSocket reference.
    * @example
@@ -72,8 +74,66 @@ export interface WsSynchronizer<WebSocketType extends WebSocketTypes>
 }
 
 /**
- * The createWsSynchronizer function.
+ * The createWsSynchronizer function creates a WsSynchronizer object that can
+ * synchronize MergeableStore data to and from other MergeableStore instances
+ * via WebSockets facilitated by a WsServer.
+ *
+ * As well as providing a reference to the MergeableStore to persist, you must
+ * provide a configured WebSocket to send synchronization messages over.
+ *
+ * This method is asynchronous because it will await the websocket's connection
+ * to the server. You will need to `await` a call to this function or handle the
+ * return type natively as a Promise.
+ * @param store The MergeableStore to synchronize.
+ * @param webSocket The WebSocket to send synchronization messages over.
+ * @param requestTimeoutSeconds An optional time in seconds that the
+ * Synchronizer will wait for responses to request messages, defaulting to 1.
+ * @param onIgnoredError An optional handler for the errors that the
+ * Synchronizer would otherwise ignore when trying to synchronize data. This is
+ * suitable for debugging synchronization issues in a development environment.
+ * @returns A reference to the new WsSynchronizer object.
+ * @example
+ * This example creates two WsSynchronizer objects to synchronize one
+ * MergeableStore to another via a server.
+ *
+ * ```js
+ * import {WebSocket, WebSocketServer} from 'ws';
+ * import {createMergeableStore} from 'tinybase';
+ * import {createWsServer} from 'tinybase/synchronizers/synchronizer-ws-server';
+ * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
+ *
+ * const server = createWsServer(new WebSocketServer({port: 8047}));
+ *
+ * const store1 = createMergeableStore();
+ * const store2 = createMergeableStore();
+ *
+ * const synchronizer1 = await createWsSynchronizer(
+ *   store1,
+ *   new WebSocket('ws://localhost:8047'),
+ * );
+ * const synchronizer2 = await createWsSynchronizer(
+ *   store2,
+ *   new WebSocket('ws://localhost:8047'),
+ * );
+ *
+ * await synchronizer1.startSync();
+ * await synchronizer2.startSync();
+ *
+ * store1.setTables({pets: {fido: {species: 'dog'}}});
+ * store2.setTables({pets: {felix: {species: 'cat'}}});
+ *
+ * // ...
+ * console.log(store1.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
+ * console.log(store2.getTables());
+ * // -> {pets: {fido: {species: 'dog'}, felix: {species: 'cat'}}}
+ *
+ * synchronizer1.destroy();
+ * synchronizer2.destroy();
+ * server.destroy();
+ * ```
  * @category Creation
+ * @since v5.0.0
  */
 export function createWsSynchronizer<WebSocketType extends WebSocketTypes>(
   store: MergeableStore,