@mml-io/networked-dom-document 0.2.0 → 0.4.0

package/build/EditableNetworkedDOM.d.ts

@@ -0,0 +1,18 @@
+import { LogMessage } from "@mml-io/observable-dom-common";
+import { ObservableDOMFactory } from "./NetworkedDOM";
+export declare class EditableNetworkedDOM {
+    private htmlPath;
+    private params;
+    private websockets;
+    private loadedState;
+    private observableDOMFactory;
+    private ignoreTextNodes;
+    private logCallback?;
+    constructor(htmlPath: string, observableDOMFactory: ObservableDOMFactory, ignoreTextNodes?: boolean, logCallback?: (message: LogMessage) => void);
+    isLoaded(): boolean;
+    load(htmlContents: string, params?: object): void;
+    reload(): void;
+    dispose(): void;
+    addWebSocket(webSocket: WebSocket): void;
+    removeWebSocket(webSocket: WebSocket): void;
+}

package/build/NetworkedDOM.d.ts

@@ -0,0 +1,51 @@
+import { ClientMessage, PongMessage } from "@mml-io/networked-dom-protocol";
+import { LogMessage, ObservableDOMInterface, ObservableDOMMessage, ObservableDOMParameters, StaticVirtualDOMElement } from "@mml-io/observable-dom-common";
+import { VirtualDOMDiffStruct } from "./common";
+export declare const networkedDOMProtocolSubProtocol_v0_1 = "networked-dom-v0.1";
+export declare const defaultWebsocketSubProtocol = "networked-dom-v0.1";
+export type ObservableDOMFactory = (observableDOMParameters: ObservableDOMParameters, callback: (message: ObservableDOMMessage, observableDOM: ObservableDOMInterface) => void) => ObservableDOMInterface;
+export declare class NetworkedDOM {
+    static SupportedWebsocketSubProtocolsPreferenceOrder: string[];
+    private internalNodeIdToClientNodeId;
+    private clientNodeIdToInternalNodeId;
+    private currentConnectionId;
+    private connectionIdToWebSocketContext;
+    private webSocketToConnectionId;
+    private visibleNodeIdsByConnectionId;
+    private initialLoad;
+    private readonly htmlPath;
+    private disposed;
+    private ignoreTextNodes;
+    private documentRoot;
+    private nodeIdToNode;
+    private nodeIdToParentNodeId;
+    private observableDOM;
+    private documentEffectiveStartTime;
+    private latestDocumentTime;
+    private pingCounter;
+    private maximumNodeId;
+    private logCallback?;
+    constructor(observableDOMFactory: ObservableDOMFactory, htmlPath: string, htmlContents: string, oldInstanceDocumentRoot: StaticVirtualDOMElement | null, onLoad: (domDiff: VirtualDOMDiffStruct | null, networkedDOM: NetworkedDOM) => void, params?: {}, ignoreTextNodes?: boolean, logCallback?: (message: LogMessage) => void);
+    private defaultLogCallback;
+    private addRemappedNodeId;
+    private sendPings;
+    private getInitialSnapshot;
+    getDocumentTime(): number;
+    addExistingWebsockets(websockets: Array<WebSocket>, existingWebsocketMap: Map<WebSocket, number> | null, domDiff: VirtualDOMDiffStruct | null): void;
+    private findParentNodeOfNodeId;
+    private registerWebsocket;
+    static handleWebsocketSubprotocol(protocols: Set<string> | Array<string>): string | false;
+    addWebSocket(webSocket: WebSocket): void;
+    removeWebSocket(webSocket: WebSocket): void;
+    dispose(): void;
+    private processModification;
+    private removeKnownNodesInMutation;
+    private removeVirtualDOMElement;
+    static IsPongMessage(message: ClientMessage): message is PongMessage;
+    private dispatchRemoteEvent;
+    private getStaticVirtualDOMElementByInternalNodeIdOrThrow;
+    private addKnownNodesInMutation;
+    getSnapshot(): StaticVirtualDOMElement;
+    private addAndRemapNodeFromInstance;
+    getWebsocketConnectionIdMap(): Map<WebSocket, number>;
+}

package/build/common.d.ts

@@ -0,0 +1,19 @@
+import { StaticVirtualDOMElement } from "@mml-io/observable-dom-common";
+import * as rfc6902 from "rfc6902";
+export type NodeMapping = {
+    clientFacingNodeId: number;
+    internalNodeId: number;
+};
+export type VirtualDOMDiffStruct = {
+    originalState: StaticVirtualDOMElement;
+    nodeIdRemappings: Array<NodeMapping>;
+    virtualDOMDiffs: Array<rfc6902.Operation>;
+};
+export type StaticVirtualDOMMutationRecord = {
+    type: "attributes" | "characterData" | "childList" | "snapshot";
+    target: StaticVirtualDOMElement;
+    addedNodes: Array<StaticVirtualDOMElement>;
+    removedNodes: Array<StaticVirtualDOMElement>;
+    previousSibling: StaticVirtualDOMElement | null;
+    attributeName: string | null;
+};

package/build/diffing.d.ts

@@ -0,0 +1,11 @@
+import { Diff, NodeDescription } from "@mml-io/networked-dom-protocol";
+import { StaticVirtualDOMElement } from "@mml-io/observable-dom-common";
+import * as rfc6902 from "rfc6902";
+import { StaticVirtualDOMMutationRecord, VirtualDOMDiffStruct } from "./common";
+export declare const visibleToAttrName = "visible-to";
+export declare const hiddenFromAttrName = "hidden-from";
+export declare function diffFromApplicationOfStaticVirtualDOMMutationRecordToConnection(mutation: StaticVirtualDOMMutationRecord, parentNode: StaticVirtualDOMElement | null, connectionId: number, visibleNodesForConnection: Set<number>): Diff | null;
+export declare function describeNodeWithChildrenForConnectionId(virtualDOMElement: StaticVirtualDOMElement, connectionId: number, visibleNodesForConnection: Set<number>): NodeDescription | null;
+export declare function findParentNodeOfNodeId(virtualDOMElement: StaticVirtualDOMElement, targetNodeId: number): StaticVirtualDOMElement | null;
+export declare function virtualDOMDiffToVirtualDOMMutationRecord(virtualStructure: StaticVirtualDOMElement, domDiff: rfc6902.Operation): Array<StaticVirtualDOMMutationRecord>;
+export declare function calculateStaticVirtualDOMDiff(originalState: StaticVirtualDOMElement, latestState: StaticVirtualDOMElement): VirtualDOMDiffStruct;

package/build/index.d.ts

@@ -1 +1,2 @@
-export * from "../src/index";
+export * from "./NetworkedDOM";
+export * from "./EditableNetworkedDOM";

package/build/index.js

@@ -45,125 +45,143 @@ var visibleToAttrName = "visible-to";
 var hiddenFromAttrName = "hidden-from";
 function diffFromApplicationOfStaticVirtualDOMMutationRecordToConnection(mutation, parentNode, connectionId, visibleNodesForConnection) {
   const virtualDOMElement = mutation.target;
-  if (mutation.type === "attributes") {
-    const visible = visibleNodesForConnection.has(virtualDOMElement.nodeId);
-    if (!parentNode) {
-      throw new Error("Node has no parent");
-    }
-    const parentNodeId = parentNode.nodeId;
-    const shouldBeVisible = shouldShowNodeToConnectionId(virtualDOMElement, connectionId) && visibleNodesForConnection.has(parentNodeId);
-    const attributeName = mutation.attributeName;
-    if (visible && shouldBeVisible) {
-      let newValue = null;
-      if (virtualDOMElement.attributes[attributeName] !== void 0) {
-        newValue = virtualDOMElement.attributes[attributeName];
-      }
-      const diff = {
-        type: "attributeChange",
-        nodeId: virtualDOMElement.nodeId,
-        attribute: attributeName,
-        newValue
-      };
-      return diff;
-    } else if (!visible && shouldBeVisible) {
-      visibleNodesForConnection.add(virtualDOMElement.nodeId);
-      const index = parentNode.childNodes.indexOf(virtualDOMElement);
-      if (index === -1) {
-        throw new Error("Node not found in parent's children");
-      }
-      let previousNodeId = null;
-      if (index > 0) {
-        previousNodeId = getNodeIdOfPreviousVisibleSibling(
-          parentNode,
-          index - 1,
-          visibleNodesForConnection
-        );
-      }
+  switch (mutation.type) {
+    case "snapshot": {
       const nodeDescription = describeNodeWithChildrenForConnectionId(
         virtualDOMElement,
         connectionId,
         visibleNodesForConnection
       );
       if (!nodeDescription) {
-        throw new Error("Node description not found");
+        return null;
       }
       const diff = {
-        type: "childrenChanged",
-        nodeId: parentNodeId,
-        previousNodeId,
-        addedNodes: [nodeDescription],
-        removedNodes: []
+        type: "snapshot",
+        snapshot: nodeDescription,
+        documentTime: 0
       };
       return diff;
-    } else if (visible && !shouldBeVisible) {
-      removeNodeAndChildrenFromVisibleNodes(virtualDOMElement, visibleNodesForConnection);
+    }
+    case "attributes": {
+      const visible = visibleNodesForConnection.has(virtualDOMElement.nodeId);
+      if (!parentNode) {
+        throw new Error("Node has no parent");
+      }
+      const parentNodeId = parentNode.nodeId;
+      const shouldBeVisible = shouldShowNodeToConnectionId(virtualDOMElement, connectionId) && visibleNodesForConnection.has(parentNodeId);
+      const attributeName = mutation.attributeName;
+      if (visible && shouldBeVisible) {
+        let newValue = null;
+        if (virtualDOMElement.attributes[attributeName] !== void 0) {
+          newValue = virtualDOMElement.attributes[attributeName];
+        }
+        const diff = {
+          type: "attributeChange",
+          nodeId: virtualDOMElement.nodeId,
+          attribute: attributeName,
+          newValue
+        };
+        return diff;
+      } else if (!visible && shouldBeVisible) {
+        visibleNodesForConnection.add(virtualDOMElement.nodeId);
+        const index = parentNode.childNodes.indexOf(virtualDOMElement);
+        if (index === -1) {
+          throw new Error("Node not found in parent's children");
+        }
+        let previousNodeId = null;
+        if (index > 0) {
+          previousNodeId = getNodeIdOfPreviousVisibleSibling(
+            parentNode,
+            index - 1,
+            visibleNodesForConnection
+          );
+        }
+        const nodeDescription = describeNodeWithChildrenForConnectionId(
+          virtualDOMElement,
+          connectionId,
+          visibleNodesForConnection
+        );
+        if (!nodeDescription) {
+          throw new Error("Node description not found");
+        }
+        const diff = {
+          type: "childrenChanged",
+          nodeId: parentNodeId,
+          previousNodeId,
+          addedNodes: [nodeDescription],
+          removedNodes: []
+        };
+        return diff;
+      } else if (visible && !shouldBeVisible) {
+        removeNodeAndChildrenFromVisibleNodes(virtualDOMElement, visibleNodesForConnection);
+        const diff = {
+          type: "childrenChanged",
+          nodeId: parentNodeId,
+          previousNodeId: null,
+          addedNodes: [],
+          removedNodes: [virtualDOMElement.nodeId]
+        };
+        return diff;
+      } else if (!visible && !shouldBeVisible) {
+        return null;
+      }
+      break;
+    }
+    case "characterData": {
       const diff = {
-        type: "childrenChanged",
-        nodeId: parentNodeId,
-        previousNodeId: null,
-        addedNodes: [],
-        removedNodes: [virtualDOMElement.nodeId]
+        type: "textChanged",
+        nodeId: virtualDOMElement.nodeId,
+        text: virtualDOMElement.textContent || ""
       };
       return diff;
-    } else if (!visible && !shouldBeVisible) {
-      return null;
     }
-  }
-  if (!visibleNodesForConnection.has(virtualDOMElement.nodeId)) {
-    return null;
-  }
-  if (mutation.type === "characterData") {
-    const diff = {
-      type: "textChanged",
-      nodeId: virtualDOMElement.nodeId,
-      text: virtualDOMElement.textContent || ""
-    };
-    return diff;
-  }
-  if (mutation.type === "childList") {
-    let previousSibling = mutation.previousSibling;
-    let previousNodeId = null;
-    if (previousSibling) {
-      let previousIndex = virtualDOMElement.childNodes.indexOf(previousSibling);
-      while (previousIndex !== -1) {
-        previousSibling = virtualDOMElement.childNodes[previousIndex];
-        if (visibleNodesForConnection.has(previousSibling.nodeId)) {
-          previousNodeId = previousSibling.nodeId;
-          break;
+    case "childList": {
+      let previousSibling = mutation.previousSibling;
+      let previousNodeId = null;
+      if (previousSibling) {
+        let previousIndex = virtualDOMElement.childNodes.indexOf(previousSibling);
+        while (previousIndex !== -1) {
+          previousSibling = virtualDOMElement.childNodes[previousIndex];
+          if (visibleNodesForConnection.has(previousSibling.nodeId)) {
+            previousNodeId = previousSibling.nodeId;
+            break;
+          }
+          previousIndex--;
         }
-        previousIndex--;
       }
-    }
-    const diff = {
-      type: "childrenChanged",
-      nodeId: virtualDOMElement.nodeId,
-      previousNodeId,
-      addedNodes: [],
-      removedNodes: []
-    };
-    mutation.addedNodes.forEach((childVirtualDOMElement) => {
-      const describedNode = describeNodeWithChildrenForConnectionId(
-        childVirtualDOMElement,
-        connectionId,
-        visibleNodesForConnection
-      );
-      if (!describedNode) {
-        return;
-      }
-      diff.addedNodes.push(describedNode);
-    });
-    mutation.removedNodes.forEach((childVirtualDOMElement) => {
-      if (visibleNodesForConnection.has(childVirtualDOMElement.nodeId)) {
-        removeNodeAndChildrenFromVisibleNodes(childVirtualDOMElement, visibleNodesForConnection);
-        diff.removedNodes.push(childVirtualDOMElement.nodeId);
+      const diff = {
+        type: "childrenChanged",
+        nodeId: virtualDOMElement.nodeId,
+        previousNodeId,
+        addedNodes: [],
+        removedNodes: []
+      };
+      mutation.addedNodes.forEach((childVirtualDOMElement) => {
+        const describedNode = describeNodeWithChildrenForConnectionId(
+          childVirtualDOMElement,
+          connectionId,
+          visibleNodesForConnection
+        );
+        if (!describedNode) {
+          return;
+        }
+        diff.addedNodes.push(describedNode);
+      });
+      mutation.removedNodes.forEach((childVirtualDOMElement) => {
+        if (visibleNodesForConnection.has(childVirtualDOMElement.nodeId)) {
+          removeNodeAndChildrenFromVisibleNodes(childVirtualDOMElement, visibleNodesForConnection);
+          diff.removedNodes.push(childVirtualDOMElement.nodeId);
+        }
+      });
+      if (diff.addedNodes.length > 0 || diff.removedNodes.length > 0) {
+        return diff;
       }
-    });
-    if (diff.addedNodes.length > 0 || diff.removedNodes.length > 0) {
-      return diff;
+      return null;
     }
-    return null;
+    default:
+      console.error("Unknown mutation type: " + mutation.type);
+      break;
   }
-  console.error("Unknown mutation type: " + mutation.type);
   return null;
 }
 function getNodeIdOfPreviousVisibleSibling(parentVirtualElement, candidateIndex, visibleNodesForConnection) {
@@ -308,55 +326,72 @@ function virtualDOMDiffToVirtualDOMMutationRecord(virtualStructure, domDiff) {
     }
     const addedNodes = [];
     const removedNodes = [];
-    if (domDiff.op === "add") {
-      addedNodes.push(domDiff.value);
-      return [
-        {
-          type: "childList",
-          target: node,
-          addedNodes,
-          removedNodes,
-          previousSibling,
-          attributeName: null
-        }
-      ];
-    } else if (domDiff.op === "remove") {
-      const removedNode = pointer.get(virtualStructure);
-      removedNodes.push(removedNode);
-      return [
-        {
-          type: "childList",
-          target: node,
-          addedNodes,
-          removedNodes,
-          previousSibling,
-          attributeName: null
-        }
-      ];
-    } else if (domDiff.op === "replace") {
-      const removedNode = pointer.get(virtualStructure);
-      removedNodes.push(removedNode);
-      addedNodes.push(domDiff.value);
-      return [
-        {
-          type: "childList",
-          target: node,
-          addedNodes: [],
-          removedNodes,
-          previousSibling,
-          attributeName: null
-        },
-        {
-          type: "childList",
-          target: node,
-          addedNodes,
-          removedNodes: [],
-          previousSibling,
-          attributeName: null
-        }
-      ];
+    switch (domDiff.op) {
+      case "add": {
+        addedNodes.push(domDiff.value);
+        return [
+          {
+            type: "childList",
+            target: node,
+            addedNodes,
+            removedNodes,
+            previousSibling,
+            attributeName: null
+          }
+        ];
+      }
+      case "remove": {
+        const removedNode = pointer.get(virtualStructure);
+        removedNodes.push(removedNode);
+        return [
+          {
+            type: "childList",
+            target: node,
+            addedNodes,
+            removedNodes,
+            previousSibling,
+            attributeName: null
+          }
+        ];
+      }
+      case "replace": {
+        const removedNode = pointer.get(virtualStructure);
+        removedNodes.push(removedNode);
+        addedNodes.push(domDiff.value);
+        return [
+          {
+            type: "childList",
+            target: node,
+            addedNodes: [],
+            removedNodes,
+            previousSibling,
+            attributeName: null
+          },
+          {
+            type: "childList",
+            target: node,
+            addedNodes,
+            removedNodes: [],
+            previousSibling,
+            attributeName: null
+          }
+        ];
+      }
     }
   }
+  if (domDiff.op === "replace" && domDiff.path === "") {
+    const node = domDiff.value;
+    return [
+      {
+        type: "snapshot",
+        target: node,
+        addedNodes: [],
+        removedNodes: [],
+        previousSibling: null,
+        attributeName: null
+      }
+    ];
+  }
   console.error("Unhandled JSON diff:", JSON.stringify(domDiff, null, 2));
   throw new Error("Unhandled diff type");
 }
@@ -641,19 +676,19 @@ var _NetworkedDOM = class {
           domDiff.originalState,
           virtualDOMDiff
         );
-        const patchResults = (0, import_rfc6902.applyPatch)(domDiff.originalState, [virtualDOMDiff]);
-        for (const patchResult of patchResults) {
-          if (patchResult !== null) {
-            console.error("Patching virtual dom structure resulted in error", patchResult);
-            throw patchResult;
+        if (virtualDOMDiff.path === "" && virtualDOMDiff.op === "replace") {
+        } else {
+          const patchResults = (0, import_rfc6902.applyPatch)(domDiff.originalState, [virtualDOMDiff]);
+          for (const patchResult of patchResults) {
+            if (patchResult !== null) {
+              console.error("Patching virtual dom structure resulted in error", patchResult);
+              throw patchResult;
+            }
           }
         }
         for (const mutationRecordLike of mutationRecordLikes) {
           const targetNodeId = mutationRecordLike.target.nodeId;
           const virtualElementParent = findParentNodeOfNodeId(domDiff.originalState, targetNodeId);
-          if (!virtualElementParent) {
-            throw new Error(`could not find parent node of nodeId ${targetNodeId}`);
-          }
           diffsByConnectionId.forEach((diffs, connectionId) => {
             const mutationDiff = diffFromApplicationOfStaticVirtualDOMMutationRecordToConnection(
               mutationRecordLike,
@@ -817,9 +852,6 @@ var _NetworkedDOM = class {
   }
   dispose() {
     this.disposed = true;
-    for (const [, connectionId] of this.webSocketToConnectionId) {
-      this.observableDOM.removeConnectedUserId(connectionId);
-    }
     this.observableDOM.dispose();
     for (const [webSocket, connectionId] of this.webSocketToConnectionId) {
       const webSocketContext = this.connectionIdToWebSocketContext.get(connectionId);