y-partyserver 2.1.1 → 2.1.3

package/dist/provider/index.d.cts

@@ -0,0 +1,133 @@
+import * as decoding from "lib0/decoding";
+import * as encoding from "lib0/encoding";
+import { Observable } from "lib0/observable";
+import * as awarenessProtocol from "y-protocols/awareness";
+import { Doc } from "yjs";
+
+//#region src/provider/index.d.ts
+declare const messageSync = 0;
+declare const messageQueryAwareness = 3;
+declare const messageAwareness = 1;
+declare const messageAuth = 2;
+declare const messageHandlers: Array<
+  (
+    encoder: encoding.Encoder,
+    decoder: decoding.Decoder,
+    provider: WebsocketProvider,
+    emitSynced: boolean,
+    messageType: number
+  ) => void
+>;
+type AwarenessUpdate = {
+  added: number[];
+  updated: number[];
+  removed: number[];
+};
+/**
+ * Websocket Provider for Yjs. Creates a websocket connection to sync the shared document.
+ * The document name is attached to the provided url. I.e. the following example
+ * creates a websocket connection to http://localhost:1234/my-document-name
+ *
+ * @example
+ *   import * as Y from 'yjs'
+ *   import { WebsocketProvider } from 'y-websocket'
+ *   const doc = new Y.Doc()
+ *   const provider = new WebsocketProvider('http://localhost:1234', 'my-document-name', doc)
+ *
+ * @extends {Observable<string>}
+ */
+declare class WebsocketProvider extends Observable<string> {
+  maxBackoffTime: number;
+  bcChannel: string;
+  url: string;
+  roomname: string;
+  doc: Doc;
+  _WS: typeof WebSocket;
+  awareness: awarenessProtocol.Awareness;
+  wsconnected: boolean;
+  wsconnecting: boolean;
+  bcconnected: boolean;
+  disableBc: boolean;
+  wsUnsuccessfulReconnects: number;
+  messageHandlers: typeof messageHandlers;
+  _synced: boolean;
+  ws: WebSocket | null;
+  wsLastMessageReceived: number;
+  shouldConnect: boolean;
+  _resyncInterval: ReturnType<typeof setInterval> | number;
+  _bcSubscriber: (message: Uint8Array, origin: unknown) => void;
+  _updateHandler: (update: Uint8Array, origin: unknown) => void;
+  _awarenessUpdateHandler: (update: AwarenessUpdate, origin: unknown) => void;
+  _unloadHandler: () => void;
+  constructor(
+    serverUrl: string,
+    roomname: string,
+    doc: Doc,
+    {
+      connect,
+      awareness,
+      params,
+      isPrefixedUrl,
+      WebSocketPolyfill,
+      // Optionally provide a WebSocket polyfill
+      resyncInterval,
+      // Request server state every `resyncInterval` milliseconds
+      maxBackoffTime,
+      // Maximum amount of time to wait before trying to reconnect (we try to reconnect using exponential backoff)
+      disableBc
+    }?: {
+      connect?: boolean;
+      awareness?: awarenessProtocol.Awareness;
+      params?: {
+        [s: string]: string;
+      };
+      isPrefixedUrl?: boolean;
+      WebSocketPolyfill?: typeof WebSocket | null;
+      resyncInterval?: number;
+      maxBackoffTime?: number;
+      disableBc?: boolean;
+    }
+  );
+  /**
+   * @type {boolean}
+   */
+  get synced(): boolean;
+  set synced(state: boolean);
+  destroy(): void;
+  connectBc(): void;
+  disconnectBc(): void;
+  disconnect(): void;
+  connect(): void;
+}
+type Params = Record<string, string | null | undefined>;
+type ParamsProvider = Params | (() => Params | Promise<Params>);
+type BaseProviderOptions = ConstructorParameters<typeof WebsocketProvider>[3];
+type YProviderOptions = Omit<NonNullable<BaseProviderOptions>, "params"> & {
+  connectionId?: string;
+  party?: string;
+  prefix?: string;
+  params?: ParamsProvider;
+  protocol?: "ws" | "wss";
+};
+declare class YProvider extends WebsocketProvider {
+  #private;
+  id: string;
+  constructor(
+    host: string,
+    room: string,
+    doc?: Doc,
+    options?: YProviderOptions
+  );
+  connect(): Promise<void>;
+  sendMessage(message: string): void;
+}
+//#endregion
+export {
+  WebsocketProvider,
+  YProvider as default,
+  messageAuth,
+  messageAwareness,
+  messageQueryAwareness,
+  messageSync
+};
+//# sourceMappingURL=index.d.cts.map