tinybase 6.1.0-beta.0 → 6.1.0-beta.2

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

@@ -1,137 +0,0 @@
-/**
- * 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.cts';
-import type {OptionalSchemas} from '../../../store/with-schemas/index.d.cts';
-import type {Receive, Send, Synchronizer} from '../../with-schemas/index.d.cts';
-
-/**
- * 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 {createMergeableStore} from 'tinybase';
-   * import {createBroadcastChannelSynchronizer} from 'tinybase/synchronizers/synchronizer-broadcast-channel';
-   *
-   * const store = createMergeableStore();
-   * const synchronizer = 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,
- *   onSend?: Send,
- *   onReceive?: Receive,
- *   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.
- *
- * A final set of optional handlers can be provided to help debug sends,
- * receives, and errors respectively.
- * @param store The MergeableStore to synchronize.
- * @param channelName The name of the channel to use.
- * @param onSend An optional handler for the messages that this Synchronizer
- * sends. This is suitable for debugging synchronization issues in a development
- * environment, since v5.1.
- * @param onReceive An optional handler for the messages that this Synchronizer
- * receives. This is suitable for debugging synchronization issues in a
- * development environment, since v5.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 BroadcastChannelSynchronizer object.
- * @example
- * This example creates two BroadcastChannelSynchronizer objects to synchronize
- * one MergeableStore to another.
- *
- * ```js
- * import {createMergeableStore} from 'tinybase';
- * import {createBroadcastChannelSynchronizer} from 'tinybase/synchronizers/synchronizer-broadcast-channel';
- *
- * 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,
-  onSend?: Send,
-  onReceive?: Receive,
-  onIgnoredError?: (error: any) => void,
-): BroadcastChannelSynchronizer<Schemas>;

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

@@ -1,95 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/**
- * 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 Synchronization guide
- * @packageDocumentation
- * @module synchronizer-local
- * @since v5.0.0
- */
-import type {MergeableStore} from '../../mergeable-store/index.d.cts';
-import type {Receive, Send, Synchronizer} from '../index.d.cts';
-
-/**
- * The LocalSynchronizer interface represents a Synchronizer that lets you
- * 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.
- * @category Synchronizer
- * @since v5.0.0
- */
-export interface LocalSynchronizer extends Synchronizer {}
-
-/**
- * The createLocalSynchronizer function creates a LocalSynchronizer object that
- * can synchronize MergeableStore data to and from other MergeableStore
- * instances on the same local machine.
- *
- * This is 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.
- *
- * As well as providing a reference to the MergeableStore to persist, a final
- * set of optional handlers can be provided to help debug sends, receives, and
- * errors respectively.
- * @param store The MergeableStore to synchronize.
- * @param onSend An optional handler for the messages that this Synchronizer
- * sends. This is suitable for debugging synchronization issues in a development
- * environment, since v5.1.
- * @param onReceive An optional handler for the messages that this Synchronizer
- * receives. This is suitable for debugging synchronization issues in a
- * development environment, since v5.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 LocalSynchronizer object.
- * @example
- * This example creates two LocalSynchronizer objects to synchronize one
- * MergeableStore to another.
- *
- * ```js
- * import {createMergeableStore} from 'tinybase';
- * import {createLocalSynchronizer} from 'tinybase/synchronizers/synchronizer-local';
- *
- * const store1 = createMergeableStore();
- * const store2 = createMergeableStore();
- *
- * const synchronizer1 = createLocalSynchronizer(store1);
- * const synchronizer2 = createLocalSynchronizer(store2);
- *
- * 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 createLocalSynchronizer(
-  store: MergeableStore,
-  onSend?: Send,
-  onReceive?: Receive,
-  onIgnoredError?: (error: any) => void,
-): LocalSynchronizer;

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

@@ -1,114 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/**
- * 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 Synchronization guide
- * @packageDocumentation
- * @module synchronizer-local
- * @since v5.0.0
- */
-import type {MergeableStore} from '../../../mergeable-store/with-schemas/index.d.cts';
-import type {OptionalSchemas} from '../../../store/with-schemas/index.d.cts';
-import type {Receive, Send, Synchronizer} from '../../with-schemas/index.d.cts';
-
-/**
- * The LocalSynchronizer interface represents a Synchronizer that lets you
- * synchronize MergeableStore data to and from other MergeableStore instances on
- * the same local machine.
- *
- * This has schema-based typing. The following is a simplified representation:
- *
- * ```ts override
- * 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.
- * @category Synchronizer
- * @since v5.0.0
- */
-export interface LocalSynchronizer<Schemas extends OptionalSchemas>
-  extends Synchronizer<Schemas> {}
-
-/**
- * The createLocalSynchronizer function creates a LocalSynchronizer object that
- * can synchronize MergeableStore data to and from other MergeableStore
- * instances on the same local machine.
- *
- * This has schema-based typing. The following is a simplified representation:
- *
- * ```ts override
- * createLocalSynchronizer(
- *   store: MergeableStore,
- *   onSend?: Send,
- *   onReceive?: Receive,
- *   onIgnoredError?: (error: any) => void,
- * ): LocalSynchronizer;
- * ```
- *
- * This is 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.
- *
- * As well as providing a reference to the MergeableStore to persist, a final
- * set of optional handlers can be provided to help debug sends, receives, and
- * errors respectively.
- * @param store The MergeableStore to synchronize.
- * @param onSend An optional handler for the messages that this Synchronizer
- * sends. This is suitable for debugging synchronization issues in a development
- * environment, since v5.1.
- * @param onReceive An optional handler for the messages that this Synchronizer
- * receives. This is suitable for debugging synchronization issues in a
- * development environment, since v5.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 LocalSynchronizer object.
- * @example
- * This example creates two LocalSynchronizer objects to synchronize one
- * MergeableStore to another.
- *
- * ```js
- * import {createMergeableStore} from 'tinybase';
- * import {createLocalSynchronizer} from 'tinybase/synchronizers/synchronizer-local';
- *
- * const store1 = createMergeableStore();
- * const store2 = createMergeableStore();
- *
- * const synchronizer1 = createLocalSynchronizer(store1);
- * const synchronizer2 = createLocalSynchronizer(store2);
- *
- * 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 createLocalSynchronizer<Schemas extends OptionalSchemas>(
-  store: MergeableStore<Schemas>,
-  onSend?: Send,
-  onReceive?: Receive,
-  onIgnoredError?: (error: any) => void,
-): LocalSynchronizer<Schemas>;

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

@@ -1,160 +0,0 @@
-/**
- * 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 Synchronization guide
- * @see Todo App v6 (collaboration) demo
- * @packageDocumentation
- * @module synchronizer-ws-client
- * @since v5.0.0
- */
-import type {MergeableStore} from '../../mergeable-store/index.d.cts';
-import type {Receive, Send, Synchronizer} from '../index.d.cts';
-import type {WebSocket as WsWebSocket} from 'ws';
-
-/**
- * The WebSocketTypes type represents the valid types of WebSocket that can be
- * used with the WsSynchronizer.
- *
- * 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;
-
-/**
- * The WsSynchronizer interface represents a Synchronizer that lets you
- * 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.
- * @category Synchronizer
- * @since v5.0.0
- */
-export interface WsSynchronizer<WebSocketType extends WebSocketTypes>
-  extends Synchronizer {
-  /**
-   * The getWebSocket method returns a reference to the WebSocket being used for
-   * synchronization.
-   * @returns The WebSocket reference.
-   * @example
-   * This example creates a server and WsSynchronizer object for a newly-created
-   * MergeableStore and then gets the WebSocket reference back out again.
-   *
-   * ```js
-   * import {createMergeableStore} from 'tinybase';
-   * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
-   * import {createWsServer} from 'tinybase/synchronizers/synchronizer-ws-server';
-   * import {WebSocket, WebSocketServer} from 'ws';
-   *
-   * const server = createWsServer(new WebSocketServer({port: 8046}));
-   *
-   * const store = createMergeableStore();
-   * const webSocket = new WebSocket('ws://localhost:8046');
-   * const synchronizer = await createWsSynchronizer(store, webSocket);
-   *
-   * console.log(synchronizer.getWebSocket() == webSocket);
-   * // -> true
-   *
-   * synchronizer.destroy();
-   * server.destroy();
-   * ```
-   * @category Getter
-   * @since v5.0.0
-   */
-  getWebSocket(): WebSocketType;
-}
-
-/**
- * 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.
- *
- * Instead of the raw browser implementation of WebSocket, you may prefer to use
- * the [Reconnecting
- * WebSocket](https://github.com/pladaria/reconnecting-websocket) wrapper so
- * that if a client goes offline, it can easily re-establish a connection when
- * it comes back online. Its API is compatible with this Synchronizer.
- *
- * You can indicate how long the Synchronizer will wait for responses to message
- * requests before timing out. A final set of optional handlers can be provided
- * to help debug sends, receives, and errors respectively.
- *
- * 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 onSend An optional handler for the messages that this Synchronizer
- * sends. This is suitable for debugging synchronization issues in a development
- * environment, since v5.1.
- * @param onReceive An optional handler for the messages that this Synchronizer
- * receives. This is suitable for debugging synchronization issues in a
- * development environment, since v5.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 {createMergeableStore} from 'tinybase';
- * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
- * import {createWsServer} from 'tinybase/synchronizers/synchronizer-ws-server';
- * import {WebSocket, WebSocketServer} from 'ws';
- *
- * 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,
-  webSocket: WebSocketType,
-  requestTimeoutSeconds?: number,
-  onSend?: Send,
-  onReceive?: Receive,
-  onIgnoredError?: (error: any) => void,
-): Promise<WsSynchronizer<WebSocketType>>;

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

@@ -1,179 +0,0 @@
-/**
- * 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 Synchronization guide
- * @see Todo App v6 (collaboration) demo
- * @packageDocumentation
- * @module synchronizer-ws-client
- * @since v5.0.0
- */
-import type {MergeableStore} from '../../../mergeable-store/with-schemas/index.d.cts';
-import type {OptionalSchemas} from '../../../store/with-schemas/index.d.cts';
-import type {Receive, Send, Synchronizer} from '../../with-schemas/index.d.cts';
-import type {WebSocket as WsWebSocket} from 'ws';
-
-/**
- * The WebSocketTypes type represents the valid types of WebSocket that can be
- * used with the WsSynchronizer.
- *
- * 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;
-
-/**
- * The WsSynchronizer interface represents a Synchronizer that lets you
- * 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.
- * @category Synchronizer
- * @since v5.0.0
- */
-export interface WsSynchronizer<
-  Schemas extends OptionalSchemas,
-  WebSocketType extends WebSocketTypes,
-> extends Synchronizer<Schemas> {
-  /**
-   * The getWebSocket method returns a reference to the WebSocket being used for
-   * synchronization.
-   * @returns The WebSocket reference.
-   * @example
-   * This example creates a server and WsSynchronizer object for a newly-created
-   * MergeableStore and then gets the WebSocket reference back out again.
-   *
-   * ```js
-   * import {createMergeableStore} from 'tinybase';
-   * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
-   * import {createWsServer} from 'tinybase/synchronizers/synchronizer-ws-server';
-   * import {WebSocket, WebSocketServer} from 'ws';
-   *
-   * const server = createWsServer(new WebSocketServer({port: 8046}));
-   *
-   * const store = createMergeableStore();
-   * const webSocket = new WebSocket('ws://localhost:8046');
-   * const synchronizer = await createWsSynchronizer(store, webSocket);
-   *
-   * console.log(synchronizer.getWebSocket() == webSocket);
-   * // -> true
-   *
-   * synchronizer.destroy();
-   * server.destroy();
-   * ```
-   * @category Getter
-   * @since v5.0.0
-   */
-  getWebSocket(): WebSocketType;
-}
-
-/**
- * The createWsSynchronizer function creates a WsSynchronizer object that can
- * synchronize MergeableStore data to and from other MergeableStore instances
- * via WebSockets facilitated by a WsServer.
- *
- * This has schema-based typing. The following is a simplified representation:
- *
- * ```ts override
- * createWsSynchronizer<WebSocketType extends WebSocketTypes>(
- *   store: MergeableStore,
- *   webSocket: WebSocketType,
- *   requestTimeoutSeconds?: number,
- *   onSend?: Send,
- *   onReceive?: Receive,
- *   onIgnoredError?: (error: any) => void,
- * ): Promise<WsSynchronizer<WebSocketType>>;
- * ```
- *
- * As well as providing a reference to the MergeableStore to persist, you must
- * provide a configured WebSocket to send synchronization messages over.
- *
- * Instead of the raw browser implementation of WebSocket, you may prefer to use
- * the [Reconnecting
- * WebSocket](https://github.com/pladaria/reconnecting-websocket) wrapper so
- * that if a client goes offline, it can easily re-establish a connection when
- * it comes back online. Its API is compatible with this Synchronizer.
- *
- * You can indicate how long the Synchronizer will wait for responses to message
- * requests before timing out. A final set of optional handlers can be provided
- * to help debug sends, receives, and errors respectively.
- *
- * 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 onSend An optional handler for the messages that this Synchronizer
- * sends. This is suitable for debugging synchronization issues in a development
- * environment, since v5.1.
- * @param onReceive An optional handler for the messages that this Synchronizer
- * receives. This is suitable for debugging synchronization issues in a
- * development environment, since v5.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 {createMergeableStore} from 'tinybase';
- * import {createWsSynchronizer} from 'tinybase/synchronizers/synchronizer-ws-client';
- * import {createWsServer} from 'tinybase/synchronizers/synchronizer-ws-server';
- * import {WebSocket, WebSocketServer} from 'ws';
- *
- * 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<
-  Schemas extends OptionalSchemas,
-  WebSocketType extends WebSocketTypes,
->(
-  store: MergeableStore<Schemas>,
-  webSocket: WebSocketType,
-  requestTimeoutSeconds?: number,
-  onSend?: Send,
-  onReceive?: Receive,
-  onIgnoredError?: (error: any) => void,
-): Promise<WsSynchronizer<Schemas, WebSocketType>>;