y-partyserver 2.1.0 → 2.1.2

package/dist/server/index.js

@@ -4,7 +4,16 @@ import debounce from "lodash.debounce";
 import { Server } from "partyserver";
 import * as awarenessProtocol from "y-protocols/awareness";
 import * as syncProtocol from "y-protocols/sync";
-import { Doc, UndoManager, XmlElement, XmlFragment, XmlText, applyUpdate, encodeStateAsUpdate, encodeStateVector } from "yjs";
+import {
+  Doc,
+  UndoManager,
+  XmlElement,
+  XmlFragment,
+  XmlText,
+  applyUpdate,
+  encodeStateAsUpdate,
+  encodeStateVector
+} from "yjs";
 
 //#region src/server/index.ts
 const snapshotOrigin = Symbol("snapshot-origin");
@@ -13,243 +22,340 @@ const wsReadyStateOpen = 1;
 const messageSync = 0;
 const messageAwareness = 1;
 /**
-* Internal key used in connection.setState() to track which awareness
-* client IDs are controlled by each connection. This survives hibernation
-* because connection state is persisted to WebSocket attachments.
-*/
+ * Internal key used in connection.setState() to track which awareness
+ * client IDs are controlled by each connection. This survives hibernation
+ * because connection state is persisted to WebSocket attachments.
+ */
 const AWARENESS_IDS_KEY = "__ypsAwarenessIds";
 function getAwarenessIds(conn) {
-	try {
-		return conn.state?.[AWARENESS_IDS_KEY] ?? [];
-	} catch {
-		return [];
-	}
+  try {
+    return conn.state?.[AWARENESS_IDS_KEY] ?? [];
+  } catch {
+    return [];
+  }
 }
 function setAwarenessIds(conn, ids) {
-	try {
-		conn.setState((prev) => ({
-			...prev,
-			[AWARENESS_IDS_KEY]: ids
-		}));
-	} catch {}
+  try {
+    conn.setState((prev) => ({
+      ...prev,
+      [AWARENESS_IDS_KEY]: ids
+    }));
+  } catch {}
 }
 var WSSharedDoc = class extends Doc {
-	awareness;
-	constructor() {
-		super({ gc: true });
-		this.awareness = new awarenessProtocol.Awareness(this);
-		this.awareness.setLocalState(null);
-		clearInterval(this.awareness._checkInterval);
-	}
+  awareness;
+  constructor() {
+    super({ gc: true });
+    this.awareness = new awarenessProtocol.Awareness(this);
+    this.awareness.setLocalState(null);
+    clearInterval(this.awareness._checkInterval);
+  }
 };
 const CALLBACK_DEFAULTS = {
-	debounceWait: 2e3,
-	debounceMaxWait: 1e4,
-	timeout: 5e3
+  debounceWait: 2e3,
+  debounceMaxWait: 1e4,
+  timeout: 5e3
 };
-function readSyncMessage(decoder, encoder, doc, transactionOrigin, readOnly = false) {
-	const messageType = decoding.readVarUint(decoder);
-	switch (messageType) {
-		case syncProtocol.messageYjsSyncStep1:
-			syncProtocol.readSyncStep1(decoder, encoder, doc);
-			break;
-		case syncProtocol.messageYjsSyncStep2:
-			if (!readOnly) syncProtocol.readSyncStep2(decoder, doc, transactionOrigin);
-			break;
-		case syncProtocol.messageYjsUpdate:
-			if (!readOnly) syncProtocol.readUpdate(decoder, doc, transactionOrigin);
-			break;
-		default: throw new Error("Unknown message type");
-	}
-	return messageType;
+function readSyncMessage(
+  decoder,
+  encoder,
+  doc,
+  transactionOrigin,
+  readOnly = false
+) {
+  const messageType = decoding.readVarUint(decoder);
+  switch (messageType) {
+    case syncProtocol.messageYjsSyncStep1:
+      syncProtocol.readSyncStep1(decoder, encoder, doc);
+      break;
+    case syncProtocol.messageYjsSyncStep2:
+      if (!readOnly)
+        syncProtocol.readSyncStep2(decoder, doc, transactionOrigin);
+      break;
+    case syncProtocol.messageYjsUpdate:
+      if (!readOnly) syncProtocol.readUpdate(decoder, doc, transactionOrigin);
+      break;
+    default:
+      throw new Error("Unknown message type");
+  }
+  return messageType;
 }
 function send(conn, m) {
-	if (conn.readyState !== void 0 && conn.readyState !== wsReadyStateConnecting && conn.readyState !== wsReadyStateOpen) return;
-	try {
-		conn.send(m);
-	} catch {}
+  if (
+    conn.readyState !== void 0 &&
+    conn.readyState !== wsReadyStateConnecting &&
+    conn.readyState !== wsReadyStateOpen
+  )
+    return;
+  try {
+    conn.send(m);
+  } catch {}
 }
-var YServer = class extends Server {
-	static callbackOptions = {};
-	#ParentClass = Object.getPrototypeOf(this).constructor;
-	document = new WSSharedDoc();
-	async onLoad() {}
-	async onSave() {}
-	/**
-	* Replaces the document with a different state using Yjs UndoManager key remapping.
-	*
-	* @param snapshotUpdate - The snapshot update to replace the document with.
-	* @param getMetadata (optional) - A function that returns the type of the root for a given key.
-	*/
-	unstable_replaceDocument(snapshotUpdate, getMetadata = () => "Map") {
-		try {
-			const doc = this.document;
-			const snapshotDoc = new Doc();
-			applyUpdate(snapshotDoc, snapshotUpdate, snapshotOrigin);
-			const currentStateVector = encodeStateVector(doc);
-			const changesSinceSnapshotUpdate = encodeStateAsUpdate(doc, encodeStateVector(snapshotDoc));
-			const undoManager = new UndoManager([...snapshotDoc.share.keys()].map((key) => {
-				const type = getMetadata(key);
-				if (type === "Text") return snapshotDoc.getText(key);
-				else if (type === "Map") return snapshotDoc.getMap(key);
-				else if (type === "Array") return snapshotDoc.getArray(key);
-				else if (type === "XmlText") return snapshotDoc.get(key, XmlText);
-				else if (type === "XmlElement") return snapshotDoc.get(key, XmlElement);
-				else if (type === "XmlFragment") return snapshotDoc.get(key, XmlFragment);
-				throw new Error(`Unknown root type: ${type} for key: ${key}`);
-			}), { trackedOrigins: new Set([snapshotOrigin]) });
-			applyUpdate(snapshotDoc, changesSinceSnapshotUpdate, snapshotOrigin);
-			undoManager.undo();
-			const documentChangesSinceSnapshotUpdate = encodeStateAsUpdate(snapshotDoc, currentStateVector);
-			applyUpdate(this.document, documentChangesSinceSnapshotUpdate);
-		} catch (error) {
-			throw new Error(`Failed to replace document: ${error instanceof Error ? error.message : "Unknown error"}`);
-		}
-	}
-	async onStart() {
-		const src = await this.onLoad();
-		if (src != null) {
-			const state = encodeStateAsUpdate(src);
-			applyUpdate(this.document, state);
-		}
-		this.document.on("update", (update) => {
-			const encoder = encoding.createEncoder();
-			encoding.writeVarUint(encoder, messageSync);
-			syncProtocol.writeUpdate(encoder, update);
-			const message = encoding.toUint8Array(encoder);
-			for (const conn of this.getConnections()) send(conn, message);
-		});
-		this.document.awareness.on("update", ({ added, updated, removed }, conn) => {
-			if (conn !== null) try {
-				const currentIds = new Set(getAwarenessIds(conn));
-				for (const clientID of added) currentIds.add(clientID);
-				for (const clientID of removed) currentIds.delete(clientID);
-				setAwarenessIds(conn, [...currentIds]);
-			} catch (_e) {}
-			else {
-				const changedClients = added.concat(updated, removed);
-				const encoder = encoding.createEncoder();
-				encoding.writeVarUint(encoder, messageAwareness);
-				encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.document.awareness, changedClients));
-				const buff = encoding.toUint8Array(encoder);
-				for (const c of this.getConnections()) send(c, buff);
-			}
-		});
-		this.document.on("update", debounce((_update, _origin, _doc) => {
-			try {
-				this.onSave().catch((err) => {
-					console.error("failed to persist:", err);
-				});
-			} catch (err) {
-				console.error("failed to persist:", err);
-			}
-		}, this.#ParentClass.callbackOptions.debounceWait || CALLBACK_DEFAULTS.debounceWait, { maxWait: this.#ParentClass.callbackOptions.debounceMaxWait || CALLBACK_DEFAULTS.debounceMaxWait }));
-		const syncEncoder = encoding.createEncoder();
-		encoding.writeVarUint(syncEncoder, messageSync);
-		syncProtocol.writeSyncStep1(syncEncoder, this.document);
-		const syncMessage = encoding.toUint8Array(syncEncoder);
-		for (const conn of this.getConnections()) send(conn, syncMessage);
-	}
-	isReadOnly(connection) {
-		return false;
-	}
-	/**
-	* Handle custom string messages from the client.
-	* Override this method to implement custom message handling.
-	* @param connection - The connection that sent the message
-	* @param message - The custom message string (without the __YPS: prefix)
-	*/
-	onCustomMessage(connection, message) {
-		console.warn(`Received custom message but onCustomMessage is not implemented in ${this.#ParentClass.name}:`, message);
-	}
-	/**
-	* Send a custom string message to a specific connection.
-	* @param connection - The connection to send the message to
-	* @param message - The custom message string to send
-	*/
-	sendCustomMessage(connection, message) {
-		if (connection.readyState !== void 0 && connection.readyState !== wsReadyStateConnecting && connection.readyState !== wsReadyStateOpen) return;
-		try {
-			connection.send(`__YPS:${message}`);
-		} catch (e) {
-			console.warn("Failed to send custom message", e);
-		}
-	}
-	/**
-	* Broadcast a custom string message to all connected clients.
-	* @param message - The custom message string to broadcast
-	* @param excludeConnection - Optional connection to exclude from the broadcast
-	*/
-	broadcastCustomMessage(message, excludeConnection) {
-		const formattedMessage = `__YPS:${message}`;
-		for (const conn of this.getConnections()) {
-			if (excludeConnection && conn === excludeConnection) continue;
-			if (conn.readyState !== void 0 && conn.readyState !== wsReadyStateConnecting && conn.readyState !== wsReadyStateOpen) continue;
-			try {
-				conn.send(formattedMessage);
-			} catch (e) {
-				console.warn("Failed to broadcast custom message", e);
-			}
-		}
-	}
-	handleMessage(connection, message) {
-		if (typeof message === "string") {
-			if (message.startsWith("__YPS:")) {
-				const customMessage = message.slice(6);
-				this.onCustomMessage(connection, customMessage);
-				return;
-			}
-			console.warn(`Received non-prefixed string message. Custom messages should be sent using sendMessage() on the provider.`);
-			return;
-		}
-		try {
-			const encoder = encoding.createEncoder();
-			const uint8Array = message instanceof Uint8Array ? message : message instanceof ArrayBuffer ? new Uint8Array(message) : new Uint8Array(message.buffer, message.byteOffset, message.byteLength);
-			const decoder = decoding.createDecoder(uint8Array);
-			switch (decoding.readVarUint(decoder)) {
-				case messageSync:
-					encoding.writeVarUint(encoder, messageSync);
-					readSyncMessage(decoder, encoder, this.document, connection, this.isReadOnly(connection));
-					if (encoding.length(encoder) > 1) send(connection, encoding.toUint8Array(encoder));
-					break;
-				case messageAwareness: {
-					const awarenessData = decoding.readVarUint8Array(decoder);
-					awarenessProtocol.applyAwarenessUpdate(this.document.awareness, awarenessData, connection);
-					const awarenessEncoder = encoding.createEncoder();
-					encoding.writeVarUint(awarenessEncoder, messageAwareness);
-					encoding.writeVarUint8Array(awarenessEncoder, awarenessData);
-					const awarenessBuff = encoding.toUint8Array(awarenessEncoder);
-					for (const c of this.getConnections()) send(c, awarenessBuff);
-					break;
-				}
-			}
-		} catch (err) {
-			console.error(err);
-			this.document.emit("error", [err]);
-		}
-	}
-	onMessage(conn, message) {
-		this.handleMessage(conn, message);
-	}
-	onClose(connection, _code, _reason, _wasClean) {
-		const controlledIds = getAwarenessIds(connection);
-		if (controlledIds.length > 0) awarenessProtocol.removeAwarenessStates(this.document.awareness, controlledIds, null);
-	}
-	onConnect(conn, _ctx) {
-		const encoder = encoding.createEncoder();
-		encoding.writeVarUint(encoder, messageSync);
-		syncProtocol.writeSyncStep1(encoder, this.document);
-		send(conn, encoding.toUint8Array(encoder));
-		const awarenessStates = this.document.awareness.getStates();
-		if (awarenessStates.size > 0) {
-			const encoder = encoding.createEncoder();
-			encoding.writeVarUint(encoder, messageAwareness);
-			encoding.writeVarUint8Array(encoder, awarenessProtocol.encodeAwarenessUpdate(this.document.awareness, Array.from(awarenessStates.keys())));
-			send(conn, encoding.toUint8Array(encoder));
-		}
-	}
-};
+function withYjs(Base) {
+  class YjsMixin extends Base {
+    static callbackOptions = {};
+    document = new WSSharedDoc();
+    async onLoad() {}
+    async onSave() {}
+    /**
+     * Replaces the document with a different state using Yjs UndoManager key remapping.
+     *
+     * @param snapshotUpdate - The snapshot update to replace the document with.
+     * @param getMetadata (optional) - A function that returns the type of the root for a given key.
+     */
+    unstable_replaceDocument(snapshotUpdate, getMetadata = () => "Map") {
+      try {
+        const doc = this.document;
+        const snapshotDoc = new Doc();
+        applyUpdate(snapshotDoc, snapshotUpdate, snapshotOrigin);
+        const currentStateVector = encodeStateVector(doc);
+        const changesSinceSnapshotUpdate = encodeStateAsUpdate(
+          doc,
+          encodeStateVector(snapshotDoc)
+        );
+        const undoManager = new UndoManager(
+          [...snapshotDoc.share.keys()].map((key) => {
+            const type = getMetadata(key);
+            if (type === "Text") return snapshotDoc.getText(key);
+            else if (type === "Map") return snapshotDoc.getMap(key);
+            else if (type === "Array") return snapshotDoc.getArray(key);
+            else if (type === "XmlText") return snapshotDoc.get(key, XmlText);
+            else if (type === "XmlElement")
+              return snapshotDoc.get(key, XmlElement);
+            else if (type === "XmlFragment")
+              return snapshotDoc.get(key, XmlFragment);
+            throw new Error(`Unknown root type: ${type} for key: ${key}`);
+          }),
+          { trackedOrigins: new Set([snapshotOrigin]) }
+        );
+        applyUpdate(snapshotDoc, changesSinceSnapshotUpdate, snapshotOrigin);
+        undoManager.undo();
+        const documentChangesSinceSnapshotUpdate = encodeStateAsUpdate(
+          snapshotDoc,
+          currentStateVector
+        );
+        applyUpdate(this.document, documentChangesSinceSnapshotUpdate);
+      } catch (error) {
+        throw new Error(
+          `Failed to replace document: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+    async onStart() {
+      const src = await this.onLoad();
+      if (src != null) {
+        const state = encodeStateAsUpdate(src);
+        applyUpdate(this.document, state);
+      }
+      this.document.on("update", (update) => {
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, messageSync);
+        syncProtocol.writeUpdate(encoder, update);
+        const message = encoding.toUint8Array(encoder);
+        for (const conn of this.getConnections()) send(conn, message);
+      });
+      this.document.awareness.on(
+        "update",
+        ({ added, updated, removed }, conn) => {
+          if (conn !== null)
+            try {
+              const currentIds = new Set(getAwarenessIds(conn));
+              for (const clientID of added) currentIds.add(clientID);
+              for (const clientID of removed) currentIds.delete(clientID);
+              setAwarenessIds(conn, [...currentIds]);
+            } catch (_e) {}
+          else {
+            const changedClients = added.concat(updated, removed);
+            const encoder = encoding.createEncoder();
+            encoding.writeVarUint(encoder, messageAwareness);
+            encoding.writeVarUint8Array(
+              encoder,
+              awarenessProtocol.encodeAwarenessUpdate(
+                this.document.awareness,
+                changedClients
+              )
+            );
+            const buff = encoding.toUint8Array(encoder);
+            for (const c of this.getConnections()) send(c, buff);
+          }
+        }
+      );
+      const ctor = this.constructor;
+      this.document.on(
+        "update",
+        debounce(
+          (_update, _origin, _doc) => {
+            try {
+              this.onSave().catch((err) => {
+                console.error("failed to persist:", err);
+              });
+            } catch (err) {
+              console.error("failed to persist:", err);
+            }
+          },
+          ctor.callbackOptions.debounceWait || CALLBACK_DEFAULTS.debounceWait,
+          {
+            maxWait:
+              ctor.callbackOptions.debounceMaxWait ||
+              CALLBACK_DEFAULTS.debounceMaxWait
+          }
+        )
+      );
+      const syncEncoder = encoding.createEncoder();
+      encoding.writeVarUint(syncEncoder, messageSync);
+      syncProtocol.writeSyncStep1(syncEncoder, this.document);
+      const syncMessage = encoding.toUint8Array(syncEncoder);
+      for (const conn of this.getConnections()) send(conn, syncMessage);
+    }
+    isReadOnly(connection) {
+      return false;
+    }
+    /**
+     * Handle custom string messages from the client.
+     * Override this method to implement custom message handling.
+     * @param connection - The connection that sent the message
+     * @param message - The custom message string (without the __YPS: prefix)
+     */
+    onCustomMessage(connection, message) {
+      console.warn(
+        `Received custom message but onCustomMessage is not implemented in ${this.constructor.name}:`,
+        message
+      );
+    }
+    /**
+     * Send a custom string message to a specific connection.
+     * @param connection - The connection to send the message to
+     * @param message - The custom message string to send
+     */
+    sendCustomMessage(connection, message) {
+      if (
+        connection.readyState !== void 0 &&
+        connection.readyState !== wsReadyStateConnecting &&
+        connection.readyState !== wsReadyStateOpen
+      )
+        return;
+      try {
+        connection.send(`__YPS:${message}`);
+      } catch (e) {
+        console.warn("Failed to send custom message", e);
+      }
+    }
+    /**
+     * Broadcast a custom string message to all connected clients.
+     * @param message - The custom message string to broadcast
+     * @param excludeConnection - Optional connection to exclude from the broadcast
+     */
+    broadcastCustomMessage(message, excludeConnection) {
+      const formattedMessage = `__YPS:${message}`;
+      for (const conn of this.getConnections()) {
+        if (excludeConnection && conn === excludeConnection) continue;
+        if (
+          conn.readyState !== void 0 &&
+          conn.readyState !== wsReadyStateConnecting &&
+          conn.readyState !== wsReadyStateOpen
+        )
+          continue;
+        try {
+          conn.send(formattedMessage);
+        } catch (e) {
+          console.warn("Failed to broadcast custom message", e);
+        }
+      }
+    }
+    handleMessage(connection, message) {
+      if (typeof message === "string") {
+        if (message.startsWith("__YPS:")) {
+          const customMessage = message.slice(6);
+          this.onCustomMessage(connection, customMessage);
+          return;
+        }
+        console.warn(
+          `Received non-prefixed string message. Custom messages should be sent using sendMessage() on the provider.`
+        );
+        return;
+      }
+      try {
+        const encoder = encoding.createEncoder();
+        const uint8Array =
+          message instanceof Uint8Array
+            ? message
+            : message instanceof ArrayBuffer
+              ? new Uint8Array(message)
+              : new Uint8Array(
+                  message.buffer,
+                  message.byteOffset,
+                  message.byteLength
+                );
+        const decoder = decoding.createDecoder(uint8Array);
+        switch (decoding.readVarUint(decoder)) {
+          case messageSync:
+            encoding.writeVarUint(encoder, messageSync);
+            readSyncMessage(
+              decoder,
+              encoder,
+              this.document,
+              connection,
+              this.isReadOnly(connection)
+            );
+            if (encoding.length(encoder) > 1)
+              send(connection, encoding.toUint8Array(encoder));
+            break;
+          case messageAwareness: {
+            const awarenessData = decoding.readVarUint8Array(decoder);
+            awarenessProtocol.applyAwarenessUpdate(
+              this.document.awareness,
+              awarenessData,
+              connection
+            );
+            const awarenessEncoder = encoding.createEncoder();
+            encoding.writeVarUint(awarenessEncoder, messageAwareness);
+            encoding.writeVarUint8Array(awarenessEncoder, awarenessData);
+            const awarenessBuff = encoding.toUint8Array(awarenessEncoder);
+            for (const c of this.getConnections()) send(c, awarenessBuff);
+            break;
+          }
+        }
+      } catch (err) {
+        console.error(err);
+        this.document.emit("error", [err]);
+      }
+    }
+    onMessage(conn, message) {
+      this.handleMessage(conn, message);
+    }
+    onClose(connection, _code, _reason, _wasClean) {
+      const controlledIds = getAwarenessIds(connection);
+      if (controlledIds.length > 0)
+        awarenessProtocol.removeAwarenessStates(
+          this.document.awareness,
+          controlledIds,
+          null
+        );
+    }
+    onConnect(conn, _ctx) {
+      const encoder = encoding.createEncoder();
+      encoding.writeVarUint(encoder, messageSync);
+      syncProtocol.writeSyncStep1(encoder, this.document);
+      send(conn, encoding.toUint8Array(encoder));
+      const awarenessStates = this.document.awareness.getStates();
+      if (awarenessStates.size > 0) {
+        const encoder = encoding.createEncoder();
+        encoding.writeVarUint(encoder, messageAwareness);
+        encoding.writeVarUint8Array(
+          encoder,
+          awarenessProtocol.encodeAwarenessUpdate(
+            this.document.awareness,
+            Array.from(awarenessStates.keys())
+          )
+        );
+        send(conn, encoding.toUint8Array(encoder));
+      }
+    }
+  }
+  return YjsMixin;
+}
+const YServer = withYjs(Server);
 
 //#endregion
-export { YServer };
-//# sourceMappingURL=index.js.map
+export { YServer, withYjs };
+//# sourceMappingURL=index.js.map