@mml-io/networked-dom-document 0.20.0 → 0.21.1

package/build/NetworkedDOM.d.ts

@@ -38,7 +38,7 @@ export declare class NetworkedDOM {
     addNetworkedDOMConnection(networkedDOMConnection: NetworkedDOMV01Connection | NetworkedDOMV02Connection): void;
     removeNetworkedDOMConnection(networkedDOMConnection: NetworkedDOMV01Connection | NetworkedDOMV02Connection): void;
     connectUsers(networkedDOMConnection: NetworkedDOMV01Connection | NetworkedDOMV02Connection, addedExternalUserIds: Set<number>): Map<number, number>;
-    announceConnectedUsers(userIds: Set<number>): void;
+    announceConnectedUsers(userIds: Map<number, string | null>): void;
     disconnectUsers(networkedDOMConnection: NetworkedDOMV02Connection, removedExternalToInternalUserIds: Map<number, number>): Array<NetworkedDOMV02Diff>;
     private defaultLogCallback;
     private sendPings;

package/build/NetworkedDOMV02Connection.d.ts

@@ -5,6 +5,7 @@ export declare class NetworkedDOMV02Connection {
     private websocketListener;
     externalIdToInternalId: Map<number, number>;
     internalIdToExternalId: Map<number, number>;
+    internalIdToToken: Map<number, string | null>;
     private batchMode;
     private batchMessages;
     externalConnectionIds: Set<number>;

package/build/createNetworkedDOMConnectionForWebsocket.d.ts

@@ -1,5 +1,5 @@
 import { NetworkedDOMV01Connection } from "./NetworkedDOMV01Connection";
 import { NetworkedDOMV02Connection } from "./NetworkedDOMV02Connection";
-export declare const SupportedWebsocketSubProtocolsPreferenceOrder: readonly ["networked-dom-v0.2", "networked-dom-v0.1"];
+export declare const SupportedWebsocketSubProtocolsPreferenceOrder: readonly ["networked-dom-v0.2.1", "networked-dom-v0.2", "networked-dom-v0.1"];
 export declare const defaultWebsocketSubProtocol = "networked-dom-v0.1";
 export declare function createNetworkedDOMConnectionForWebsocket(webSocket: WebSocket): NetworkedDOMV01Connection | NetworkedDOMV02Connection | null;

package/build/index.js

@@ -1,7 +1,8 @@
 // src/createNetworkedDOMConnectionForWebsocket.ts
 import {
+  isNetworkedDOMProtocolSubProtocol_v0_2 as isNetworkedDOMProtocolSubProtocol_v0_22,
   networkedDOMProtocolSubProtocol_v0_1,
-  networkedDOMProtocolSubProtocol_v0_2
+  networkedDOMProtocolSubProtocol_v0_2_SubVersionsList
 } from "@mml-io/networked-dom-protocol";
 
 // src/NetworkedDOMV01Connection.ts
@@ -57,7 +58,9 @@ var NetworkedDOMV01Connection = class {
     const internalConnectionIds = this.networkedDOM.connectUsers(this, /* @__PURE__ */ new Set([1]));
     this.internalConnectionId = internalConnectionIds.entries().next().value[0];
     this.internalIdToExternalId.set(this.internalConnectionId, 1);
-    this.networkedDOM.announceConnectedUsers(/* @__PURE__ */ new Set([this.internalConnectionId]));
+    this.networkedDOM.announceConnectedUsers(
+      /* @__PURE__ */ new Map([[this.internalConnectionId, null]])
+    );
   }
   stringifyAndSendSingleMessage(message) {
     this.webSocket.send("[" + JSON.stringify(message) + "]");
@@ -77,21 +80,31 @@ import {
   decodeClientMessages,
   encodeBatchEnd,
   encodeBatchStart,
-  encodeServerMessage
+  encodeServerMessage,
+  getNetworkedDOMProtocolSubProtocol_v0_2SubversionOrThrow,
+  isNetworkedDOMProtocolSubProtocol_v0_2
 } from "@mml-io/networked-dom-protocol";
 var NetworkedDOMV02Connection = class {
   constructor(webSocket) {
     this.webSocket = webSocket;
     this.externalIdToInternalId = /* @__PURE__ */ new Map();
     this.internalIdToExternalId = /* @__PURE__ */ new Map();
+    this.internalIdToToken = /* @__PURE__ */ new Map();
     this.batchMode = false;
     this.batchMessages = [];
     this.externalConnectionIds = /* @__PURE__ */ new Set();
     this.networkedDOM = null;
     this.messagesAwaitingNetworkedDOM = [];
+    const protocol = webSocket.protocol;
+    if (!isNetworkedDOMProtocolSubProtocol_v0_2(protocol)) {
+      throw new Error(
+        `WebSocket protocol ${protocol} is not a supported networked-dom-v0.2 sub-protocol`
+      );
+    }
+    const protocolSubversion = getNetworkedDOMProtocolSubProtocol_v0_2SubversionOrThrow(protocol);
     this.websocketListener = (messageEvent) => {
       const buffer = new Uint8Array(messageEvent.data);
-      const messages = decodeClientMessages(new BufferReader(buffer));
+      const messages = decodeClientMessages(new BufferReader(buffer), protocolSubversion);
       for (const parsed of messages) {
         if (this.networkedDOM) {
           this.handleClientMessage(parsed);
@@ -161,8 +174,12 @@ var NetworkedDOMV02Connection = class {
   handleClientMessage(parsed) {
     switch (parsed.type) {
       case "connectUsers": {
+        const externalIdsToToken = /* @__PURE__ */ new Map();
         const addedExternalUserIds = /* @__PURE__ */ new Set();
-        for (const addingExternalId of parsed.connectionIds) {
+        for (let i = 0; i < parsed.connectionIds.length; i++) {
+          const addingExternalId = parsed.connectionIds[i];
+          const correspondingToken = parsed.connectionTokens[i];
+          externalIdsToToken.set(addingExternalId, correspondingToken);
           if (!Number.isInteger(addingExternalId) || addingExternalId < 0) {
             this.sendMessage({
               type: "error",
@@ -195,12 +212,15 @@ var NetworkedDOMV02Connection = class {
             this,
             addedExternalUserIds
           );
-          const internalIds = new Set(Array.from(connectionIdToExternalId.keys()));
+          const addingInternalIdsWithToken = /* @__PURE__ */ new Map();
           for (const [addingInternalId, addingExternalId] of connectionIdToExternalId) {
+            const token = externalIdsToToken.get(addingExternalId) ?? null;
+            addingInternalIdsWithToken.set(addingInternalId, token);
             this.externalIdToInternalId.set(addingExternalId, addingInternalId);
             this.internalIdToExternalId.set(addingInternalId, addingExternalId);
+            this.internalIdToToken.set(addingInternalId, token);
           }
-          this.networkedDOM.announceConnectedUsers(internalIds);
+          this.networkedDOM.announceConnectedUsers(addingInternalIdsWithToken);
         }
         return;
       }
@@ -246,6 +266,7 @@ var NetworkedDOMV02Connection = class {
             this.externalConnectionIds.delete(removingExternalId);
             this.externalIdToInternalId.delete(removingExternalId);
             this.internalIdToExternalId.delete(removingInternalId);
+            this.internalIdToToken.delete(removingInternalId);
           }
         } else {
           const removalDiffs = this.networkedDOM.disconnectUsers(
@@ -301,7 +322,7 @@ var NetworkedDOMV02Connection = class {
 
 // src/createNetworkedDOMConnectionForWebsocket.ts
 var SupportedWebsocketSubProtocolsPreferenceOrder = [
-  networkedDOMProtocolSubProtocol_v0_2,
+  ...networkedDOMProtocolSubProtocol_v0_2_SubVersionsList,
   networkedDOMProtocolSubProtocol_v0_1
 ];
 var defaultWebsocketSubProtocol = networkedDOMProtocolSubProtocol_v0_1;
@@ -336,7 +357,7 @@ function createNetworkedDOMConnectionForWebsocket(webSocket) {
     webSocket.send(JSON.stringify(warningMessage));
     assumedProtocol = defaultWebsocketSubProtocol;
   }
-  const isV02 = assumedProtocol === networkedDOMProtocolSubProtocol_v0_2;
+  const isV02 = isNetworkedDOMProtocolSubProtocol_v0_22(assumedProtocol);
   if (isV02) {
     return new NetworkedDOMV02Connection(webSocket);
   }
@@ -1030,7 +1051,7 @@ function describeNodeWithChildrenForV01Connection(virtualDOMElement, networkedDO
     return null;
   }
   let emittedTagName = virtualDOMElement.tag;
-  if (emittedTagName === "#document") {
+  if (emittedTagName === "#DOCUMENT") {
     emittedTagName = "DIV";
   }
   if (emittedTagName === "#text") {
@@ -1070,7 +1091,7 @@ function describeNodeWithChildrenForV02Connection(virtualDOMElement, networkedDO
     return null;
   }
   let emittedTagName = virtualDOMElement.tag;
-  if (emittedTagName === "#document") {
+  if (emittedTagName === "#DOCUMENT") {
     emittedTagName = "DIV";
   }
   if (emittedTagName === "#text") {
@@ -1353,6 +1374,12 @@ var NodeManager = class {
     return [nodeWithSubjectivity, hasSubjectivity];
   }
   addRemappedNodeId(clientFacingNodeId, internalNodeId) {
+    if (this.internalNodeIdToClientNodeId.has(internalNodeId)) {
+      throw new Error("Node already exists with internal node id " + internalNodeId);
+    }
+    if (this.clientNodeIdToInternalNodeId.has(clientFacingNodeId)) {
+      throw new Error("Node already exists with client id " + clientFacingNodeId);
+    }
     this.internalNodeIdToClientNodeId.set(internalNodeId, clientFacingNodeId);
     this.clientNodeIdToInternalNodeId.set(clientFacingNodeId, internalNodeId);
     this.maximumNodeId = Math.max(this.maximumNodeId, Math.max(clientFacingNodeId, internalNodeId));
@@ -1366,9 +1393,9 @@ var NodeManager = class {
       return newId;
     }
     if (createIfCollided) {
-      if (this.nodeIdToNode.has(nodeId)) {
+      if (this.nodeIdToNode.has(nodeId) || this.clientNodeIdToInternalNodeId.has(nodeId)) {
         const newId2 = ++this.maximumNodeId;
-        this.internalNodeIdToClientNodeId.set(nodeId, newId2);
+        this.addRemappedNodeId(newId2, nodeId);
         return newId2;
       }
       return nodeId;
@@ -1564,18 +1591,18 @@ var NetworkedDOM = class {
       }
     }
     for (const networkedDOMConnection of this.networkedDOMV02Connections) {
-      for (const connectionId of networkedDOMConnection.internalIdToExternalId.keys()) {
+      for (const [connectionId, token] of networkedDOMConnection.internalIdToToken) {
         if (connectionId >= this.currentConnectionId) {
           this.currentConnectionId = connectionId + 1;
         }
-        this.observableDOM.addConnectedUserId(connectionId);
+        this.observableDOM.addConnectedUserId(connectionId, token);
       }
     }
     for (const networkedDOMConnection of this.networkedDOMV01Connections) {
       if (networkedDOMConnection.internalConnectionId === null) {
         networkedDOMConnection.initAsNewV01Connection();
       }
-      this.observableDOM.addConnectedUserId(networkedDOMConnection.internalConnectionId);
+      this.observableDOM.addConnectedUserId(networkedDOMConnection.internalConnectionId, null);
     }
     for (const networkedDOMConnection of this.networkedDOMV02Connections) {
       networkedDOMConnection.handleBufferedMessages();
@@ -1684,8 +1711,8 @@ var NetworkedDOM = class {
         networkedDOMConnection.webSocket,
         networkedDOMConnection
       );
-      for (const connectionId of networkedDOMConnection.internalIdToExternalId.keys()) {
-        this.observableDOM.addConnectedUserId(connectionId);
+      for (const [connectionId, token] of networkedDOMConnection.internalIdToToken) {
+        this.observableDOM.addConnectedUserId(connectionId, token);
       }
       networkedDOMConnection.sendMessage(
         this.getInitialV02Snapshot(networkedDOMConnection, documentVirtualDOMElement)
@@ -1730,8 +1757,8 @@ var NetworkedDOM = class {
   }
   // Called by the connections after storing the mapping of connected users ids
   announceConnectedUsers(userIds) {
-    for (const userId of userIds) {
-      this.observableDOM.addConnectedUserId(userId);
+    for (const [userId, token] of userIds) {
+      this.observableDOM.addConnectedUserId(userId, token);
     }
   }
   disconnectUsers(networkedDOMConnection, removedExternalToInternalUserIds) {
@@ -1763,6 +1790,7 @@ var NetworkedDOM = class {
       networkedDOMConnection.externalConnectionIds.delete(removingExternalId);
       networkedDOMConnection.externalIdToInternalId.delete(removingExternalId);
       networkedDOMConnection.internalIdToExternalId.delete(removingInternalId);
+      networkedDOMConnection.internalIdToToken.delete(removingInternalId);
       this.connectionIdToNetworkedDOMConnection.delete(removingInternalId);
     }
     const removedMessagesByParent = /* @__PURE__ */ new Map();
@@ -2684,7 +2712,7 @@ var NetworkedDOM = class {
       tag: staticVirtualDOMElement.tag,
       attributes: staticVirtualDOMElement.attributes,
       childNodes: staticVirtualDOMElement.childNodes.map(
-        (child) => this.reprojectStaticVirtualDOMElementWithMappings(child)
+        (child) => this.reprojectStaticVirtualDOMElementWithMappings(child, createIfCollided)
       ),
       textContent: staticVirtualDOMElement.textContent
     };