@mml-io/observable-dom 0.1.3 → 0.3.0

package/build/JSDOMRunner.d.ts

@@ -0,0 +1,24 @@
+import { RemoteEvent } from "@mml-io/observable-dom-common";
+import { DOMWindow } from "jsdom";
+import { DOMRunnerFactory, DOMRunnerMessage } from "./ObservableDOM";
+export declare const JSDOMRunnerFactory: DOMRunnerFactory;
+export declare class JSDOMRunner {
+    private monkeyPatchMutationRecordCallback;
+    domWindow: DOMWindow | null;
+    private jsdom;
+    private callback;
+    private mutationObserver;
+    private htmlPath;
+    private documentStartTime;
+    private isLoaded;
+    private logBuffer;
+    constructor(htmlPath: string, htmlContents: string, params: object, callback: (domRunnerMessage: DOMRunnerMessage) => void);
+    private flushLogBuffer;
+    private log;
+    getDocument(): Document;
+    getWindow(): any;
+    dispose(): void;
+    getDocumentTime(): number;
+    dispatchRemoteEventFromConnectionId(connectionId: number, domNode: Element, remoteEvent: RemoteEvent): void;
+    private createVirtualConsole;
+}

package/build/ObservableDOM.d.ts

@@ -0,0 +1,51 @@
+import { LogMessage, ObservableDOMInterface, ObservableDOMMessage, ObservableDOMParameters, RemoteEvent, StaticVirtualDOMElement } from "@mml-io/observable-dom-common";
+export type DOMRunnerMessage = {
+    loaded?: boolean;
+    mutationList?: Array<MutationRecord>;
+    logMessage?: LogMessage;
+};
+export type DOMRunnerInterface = {
+    getDocument(): Document;
+    getWindow(): Window & {
+        CustomEvent: typeof CustomEvent;
+        Text: typeof Text;
+        HTMLScriptElement: typeof HTMLScriptElement;
+        Comment: typeof Comment;
+    };
+    dispatchRemoteEventFromConnectionId(connectionId: number, realElement: Element, remoteEvent: RemoteEvent): void;
+    dispose(): void;
+    getDocumentTime(): number;
+};
+export type DOMRunnerFactory = (htmlPath: string, htmlContents: string, params: object, callback: (domRunnerMessage: DOMRunnerMessage) => void) => DOMRunnerInterface;
+export type LiveVirtualDOMElement = Omit<StaticVirtualDOMElement, "childNodes"> & {
+    realElement: Element | Text;
+    childNodes: Array<LiveVirtualDOMElement>;
+    parent: LiveVirtualDOMElement | null;
+};
+export declare class ObservableDOM implements ObservableDOMInterface {
+    private nodeToNodeId;
+    private nodeIdToNode;
+    private realElementToVirtualElement;
+    private ignoreTextNodes;
+    private callback;
+    private nextNodeId;
+    private htmlPath;
+    private domRunner;
+    private documentTimeIntervalTimer;
+    constructor(observableDOMParameters: ObservableDOMParameters, callback: (message: ObservableDOMMessage, observableDOM: ObservableDOMInterface) => void, runnerFactory: DOMRunnerFactory);
+    addConnectedUserId(connectionId: number): void;
+    removeConnectedUserId(connectionId: number): void;
+    private processModificationList;
+    private addKnownNodesInMutation;
+    private removeKnownNodesInMutation;
+    private removeVirtualDOMElement;
+    private createVirtualDOMElementWithChildren;
+    private createVirtualDOMElement;
+    private getFirstNonIgnoredPreviousSibling;
+    private getVirtualDOMElementForRealElementOrThrow;
+    private isIgnoredElement;
+    private isIgnoredAttribute;
+    dispatchRemoteEventFromConnectionId(connectionId: number, remoteEvent: RemoteEvent): void;
+    dispose(): void;
+    private getDocumentTime;
+}

package/build/index.d.ts

@@ -1 +1,2 @@
-export * from "../src/index";
+export * from "./ObservableDOM";
+export * from "./JSDOMRunner";

package/build/index.js

@@ -31,23 +31,23 @@ var src_exports = {};
 __export(src_exports, {
   JSDOMRunner: () => JSDOMRunner,
   JSDOMRunnerFactory: () => JSDOMRunnerFactory,
-  ObservableDom: () => ObservableDom
+  ObservableDOM: () => ObservableDOM
 });
 module.exports = __toCommonJS(src_exports);
 
 // src/utils.ts
-function virtualDomElementToStatic(el) {
+function virtualDOMElementToStatic(el) {
   return {
     nodeId: el.nodeId,
     tag: el.tag,
     attributes: el.attributes,
-    childNodes: el.childNodes.map((child) => virtualDomElementToStatic(child)),
+    childNodes: el.childNodes.map((child) => virtualDOMElementToStatic(child)),
     textContent: el.textContent
   };
 }
 
-// src/ObservableDom.ts
-var ObservableDom = class {
+// src/ObservableDOM.ts
+var ObservableDOM = class {
   constructor(observableDOMParameters, callback, runnerFactory) {
     this.nodeToNodeId = /* @__PURE__ */ new Map();
     this.nodeIdToNode = /* @__PURE__ */ new Map();
@@ -58,9 +58,12 @@ var ObservableDom = class {
     this.ignoreTextNodes = observableDOMParameters.ignoreTextNodes;
     this.callback = callback;
     this.documentTimeIntervalTimer = setInterval(() => {
-      this.callback({
-        documentTime: this.getDocumentTime()
-      });
+      this.callback(
+        {
+          documentTime: this.getDocumentTime()
+        },
+        this
+      );
     }, observableDOMParameters.pingIntervalMilliseconds || 5e3);
     this.domRunner = runnerFactory(
       observableDOMParameters.htmlPath,
@@ -68,33 +71,36 @@ var ObservableDom = class {
       observableDOMParameters.params,
       (domRunnerMessage) => {
         if (domRunnerMessage.loaded) {
-          this.createVirtualDomElementWithChildren(
+          this.createVirtualDOMElementWithChildren(
             this.domRunner.getDocument(),
             null
           );
-          const snapshot = virtualDomElementToStatic(
-            this.getVirtualDomElementForRealElementOrThrow(
+          const snapshot = virtualDOMElementToStatic(
+            this.getVirtualDOMElementForRealElementOrThrow(
               this.domRunner.getDocument()
             )
           );
-          this.callback({
-            snapshot,
-            documentTime: this.getDocumentTime()
-          });
+          this.callback(
+            {
+              snapshot,
+              documentTime: this.getDocumentTime()
+            },
+            this
+          );
         } else if (domRunnerMessage.mutationList) {
           this.processModificationList(domRunnerMessage.mutationList);
         } else if (domRunnerMessage.logMessage) {
-          this.callback({
-            logMessage: domRunnerMessage.logMessage,
-            documentTime: this.getDocumentTime()
-          });
+          this.callback(
+            {
+              logMessage: domRunnerMessage.logMessage,
+              documentTime: this.getDocumentTime()
+            },
+            this
+          );
         }
       }
     );
   }
-  addIPCWebsocket(webSocket) {
-    return this.domRunner.addIPCWebsocket(webSocket);
-  }
   addConnectedUserId(connectionId) {
     this.domRunner.getWindow().dispatchEvent(
       new (this.domRunner.getWindow()).CustomEvent("connected", {
@@ -111,8 +117,8 @@ var ObservableDom = class {
   }
   processModificationList(mutationList) {
     const documentEl = this.domRunner.getDocument();
-    const documentVirtualDomElement = this.realElementToVirtualElement.get(documentEl);
-    if (!documentVirtualDomElement) {
+    const documentVirtualDOMElement = this.realElementToVirtualElement.get(documentEl);
+    if (!documentVirtualDOMElement) {
       throw new Error(`document not created in processModificationList`);
     }
     if (mutationList.length > 1) {
@@ -130,7 +136,7 @@ var ObservableDom = class {
       }
       this.addKnownNodesInMutation(mutation);
       const firstNonIgnoredPreviousSibling = mutation.previousSibling ? this.getFirstNonIgnoredPreviousSibling(mutation.previousSibling) : null;
-      const targetElement = this.getVirtualDomElementForRealElementOrThrow(
+      const targetElement = this.getVirtualDOMElementForRealElementOrThrow(
         mutation.target
       );
       const addedNodes = [];
@@ -138,43 +144,46 @@ var ObservableDom = class {
         if (this.isIgnoredElement(node)) {
           continue;
         }
-        const virtualDomElement = this.getVirtualDomElementForRealElementOrThrow(
+        const virtualDOMElement = this.getVirtualDOMElementForRealElementOrThrow(
           node
         );
-        addedNodes.push(virtualDomElementToStatic(virtualDomElement));
+        addedNodes.push(virtualDOMElementToStatic(virtualDOMElement));
       }
       const removedNodeIds = [];
       for (const node of mutation.removedNodes) {
         if (this.isIgnoredElement(node)) {
           continue;
         }
-        const virtualDomElement = this.getVirtualDomElementForRealElementOrThrow(
+        const virtualDOMElement = this.getVirtualDOMElementForRealElementOrThrow(
           node
         );
-        removedNodeIds.push(virtualDomElement.nodeId);
+        removedNodeIds.push(virtualDOMElement.nodeId);
       }
       const mutationRecord = {
         type: mutation.type,
         targetId: targetElement.nodeId,
         addedNodes,
         removedNodeIds,
-        previousSiblingId: firstNonIgnoredPreviousSibling !== null ? this.getVirtualDomElementForRealElementOrThrow(firstNonIgnoredPreviousSibling).nodeId : null,
+        previousSiblingId: firstNonIgnoredPreviousSibling !== null ? this.getVirtualDOMElementForRealElementOrThrow(firstNonIgnoredPreviousSibling).nodeId : null,
         attribute: mutation.attributeName ? {
           attributeName: mutation.attributeName,
           value: mutation.target.getAttribute(mutation.attributeName)
         } : null
       };
-      this.callback({
-        mutation: mutationRecord,
-        documentTime: this.getDocumentTime()
-      });
+      this.callback(
+        {
+          mutation: mutationRecord,
+          documentTime: this.getDocumentTime()
+        },
+        this
+      );
       this.removeKnownNodesInMutation(mutation);
     }
   }
   addKnownNodesInMutation(mutation) {
     const targetNode = mutation.target;
-    const virtualDomElement = this.realElementToVirtualElement.get(targetNode);
-    if (!virtualDomElement) {
+    const virtualDOMElement = this.realElementToVirtualElement.get(targetNode);
+    if (!virtualDOMElement) {
       throw new Error(
         "Unknown node in addKnownNodesInMutation:" + targetNode + "," + mutation.type
       );
@@ -192,7 +201,7 @@ var ObservableDom = class {
         if (!previousSiblingElement) {
           throw new Error("Unknown previous sibling");
         }
-        index = virtualDomElement.childNodes.indexOf(previousSiblingElement);
+        index = virtualDOMElement.childNodes.indexOf(previousSiblingElement);
         if (index === -1) {
           throw new Error("Previous sibling is not currently a child of the parent element");
         }
@@ -200,13 +209,13 @@ var ObservableDom = class {
       }
       mutation.addedNodes.forEach((node) => {
         const asElementOrText = node;
-        const childVirtualDomElement = this.createVirtualDomElementWithChildren(
+        const childVirtualDOMElement = this.createVirtualDOMElementWithChildren(
           asElementOrText,
-          virtualDomElement
+          virtualDOMElement
         );
-        if (childVirtualDomElement) {
-          if (virtualDomElement.childNodes.indexOf(childVirtualDomElement) === -1) {
-            virtualDomElement.childNodes.splice(index, 0, childVirtualDomElement);
+        if (childVirtualDOMElement) {
+          if (virtualDOMElement.childNodes.indexOf(childVirtualDOMElement) === -1) {
+            virtualDOMElement.childNodes.splice(index, 0, childVirtualDOMElement);
             index++;
           }
         }
@@ -218,18 +227,18 @@ var ObservableDom = class {
       }
       const attributeValue = targetNode.getAttribute(attributeName);
       if (attributeValue === null) {
-        delete virtualDomElement.attributes[attributeName];
+        delete virtualDOMElement.attributes[attributeName];
       } else {
-        virtualDomElement.attributes[attributeName] = attributeValue;
+        virtualDOMElement.attributes[attributeName] = attributeValue;
       }
     } else if (mutation.type === "characterData") {
-      virtualDomElement.textContent = targetNode.textContent ? targetNode.textContent : void 0;
+      virtualDOMElement.textContent = targetNode.textContent ? targetNode.textContent : void 0;
     }
   }
   removeKnownNodesInMutation(mutation) {
     const targetNode = mutation.target;
-    const virtualDomElement = this.realElementToVirtualElement.get(targetNode);
-    if (!virtualDomElement) {
+    const virtualDOMElement = this.realElementToVirtualElement.get(targetNode);
+    if (!virtualDOMElement) {
       throw new Error("Unknown node in mutation list:" + targetNode + ", " + mutation.type);
     }
     if (mutation.type === "childList") {
@@ -238,36 +247,36 @@ var ObservableDom = class {
         if (this.isIgnoredElement(asElementOrText)) {
           continue;
         }
-        const childDomElement = this.realElementToVirtualElement.get(asElementOrText);
-        if (!childDomElement) {
+        const childDOMElement = this.realElementToVirtualElement.get(asElementOrText);
+        if (!childDOMElement) {
           console.warn(this.htmlPath, "Unknown node in removeKnownNodesInMutation");
           continue;
         } else {
-          this.removeVirtualDomElement(childDomElement);
-          const index = virtualDomElement.childNodes.indexOf(childDomElement);
-          virtualDomElement.childNodes.splice(index, 1);
+          this.removeVirtualDOMElement(childDOMElement);
+          const index = virtualDOMElement.childNodes.indexOf(childDOMElement);
+          virtualDOMElement.childNodes.splice(index, 1);
         }
       }
       return;
     }
   }
-  removeVirtualDomElement(virtualDomElement) {
-    this.nodeIdToNode.delete(virtualDomElement.nodeId);
-    this.nodeToNodeId.delete(virtualDomElement);
-    this.realElementToVirtualElement.delete(virtualDomElement.realElement);
-    for (const child of virtualDomElement.childNodes) {
-      this.removeVirtualDomElement(child);
+  removeVirtualDOMElement(virtualDOMElement) {
+    this.nodeIdToNode.delete(virtualDOMElement.nodeId);
+    this.nodeToNodeId.delete(virtualDOMElement);
+    this.realElementToVirtualElement.delete(virtualDOMElement.realElement);
+    for (const child of virtualDOMElement.childNodes) {
+      this.removeVirtualDOMElement(child);
     }
   }
-  createVirtualDomElementWithChildren(node, parent) {
-    const virtualElement = this.createVirtualDomElement(node, parent);
+  createVirtualDOMElementWithChildren(node, parent) {
+    const virtualElement = this.createVirtualDOMElement(node, parent);
     if (!virtualElement) {
       return null;
     }
     if (node.childNodes) {
       for (let i = 0; i < node.childNodes.length; i++) {
         const child = node.childNodes[i];
-        const childVirtualElement = this.createVirtualDomElementWithChildren(
+        const childVirtualElement = this.createVirtualDOMElementWithChildren(
           child,
           virtualElement
         );
@@ -278,7 +287,7 @@ var ObservableDom = class {
     }
     return virtualElement;
   }
-  createVirtualDomElement(node, parent) {
+  createVirtualDOMElement(node, parent) {
     if (this.isIgnoredElement(node)) {
       return null;
     }
@@ -332,7 +341,7 @@ var ObservableDom = class {
     }
     return null;
   }
-  getVirtualDomElementForRealElementOrThrow(realElement) {
+  getVirtualDOMElementForRealElementOrThrow(realElement) {
     const virtualElement = this.realElementToVirtualElement.get(realElement);
     if (!virtualElement) {
       throw new Error(`Virtual element not found for real element`);
@@ -382,7 +391,7 @@ var import_vm = __toESM(require("vm"));
 var import_jsdom = require("jsdom");
 var nodeFetch = __toESM(require("node-fetch"));
 var import_node_fetch = __toESM(require("node-fetch"));
-var ErrDomWindowNotInitialized = "DOMWindow not initialized";
+var ErrDOMWindowNotInitialized = "DOMWindow not initialized";
 var monkeyPatchedMutationRecordCallbacks = /* @__PURE__ */ new Set();
 function installMutationObserverMonkeyPatch() {
   const MutationRecordExports = require("jsdom/lib/jsdom/living/generated/MutationRecord");
@@ -406,10 +415,8 @@ var RejectionResourceLoader = class extends import_jsdom.ResourceLoader {
 };
 var JSDOMRunner = class {
   constructor(htmlPath, htmlContents, params, callback) {
-    this.ipcWebsockets = /* @__PURE__ */ new Set();
     this.domWindow = null;
     this.mutationObserver = null;
-    this.ipcListeners = /* @__PURE__ */ new Set();
     this.documentStartTime = Date.now();
     this.isLoaded = false;
     this.logBuffer = [];
@@ -433,7 +440,7 @@ var JSDOMRunner = class {
       }
     };
     monkeyPatchedMutationRecordCallbacks.add(this.monkeyPatchMutationRecordCallback);
-    this.jsDom = new import_jsdom.JSDOM(htmlContents, {
+    this.jsdom = new import_jsdom.JSDOM(htmlContents, {
       runScripts: "dangerously",
       resources: new RejectionResourceLoader(),
       url: this.htmlPath,
@@ -452,22 +459,6 @@ var JSDOMRunner = class {
         });
         window.document.timeline = timeline;
         window.params = JSON.parse(JSON.stringify(params));
-        const oldDocumentAddEventListener = window.document.addEventListener;
-        window.document.addEventListener = (...args) => {
-          const [eventName, listener] = args;
-          if (eventName === "ipc") {
-            this.ipcListeners.add(listener);
-          }
-          return oldDocumentAddEventListener.call(window.document, ...args);
-        };
-        const oldDocumentRemoveEventListener = window.document.addEventListener;
-        window.document.removeEventListener = (...args) => {
-          const [eventName, listener] = args;
-          if (eventName === "ipc") {
-            this.ipcListeners.delete(listener);
-          }
-          return oldDocumentRemoveEventListener.call(window.document, ...args);
-        };
         this.mutationObserver = new window.MutationObserver((mutationList) => {
           this.callback({
             mutationList
@@ -509,36 +500,13 @@ var JSDOMRunner = class {
   }
   getDocument() {
     if (!this.domWindow) {
-      throw new Error(ErrDomWindowNotInitialized);
+      throw new Error(ErrDOMWindowNotInitialized);
     }
     return this.domWindow.document;
   }
   getWindow() {
     return this.domWindow;
   }
-  addIPCWebsocket(webSocket) {
-    if (!this.domWindow) {
-      throw new Error(ErrDomWindowNotInitialized);
-    }
-    if (this.ipcListeners.size === 0) {
-      console.error("ipc requested, but no ipc listeners registered on document:", this.htmlPath);
-      webSocket.close();
-      return;
-    }
-    this.ipcWebsockets.add(webSocket);
-    const event = new this.domWindow.CustomEvent("ipc", {
-      detail: {
-        webSocket
-      }
-    });
-    for (const ipcListener of this.ipcListeners) {
-      ipcListener(event);
-    }
-    webSocket.addEventListener("close", () => {
-      this.ipcWebsockets.delete(webSocket);
-    });
-    return;
-  }
   dispose() {
     var _a, _b;
     const records = (_a = this.mutationObserver) == null ? void 0 : _a.takeRecords();
@@ -547,14 +515,14 @@ var JSDOMRunner = class {
     });
     monkeyPatchedMutationRecordCallbacks.delete(this.monkeyPatchMutationRecordCallback);
     (_b = this.mutationObserver) == null ? void 0 : _b.disconnect();
-    this.jsDom.window.close();
+    this.jsdom.window.close();
   }
   getDocumentTime() {
     return Date.now() - this.documentStartTime;
   }
   dispatchRemoteEventFromConnectionId(connectionId, domNode, remoteEvent) {
     if (!this.domWindow) {
-      throw new Error(ErrDomWindowNotInitialized);
+      throw new Error(ErrDOMWindowNotInitialized);
     }
     const bubbles = remoteEvent.bubbles || false;
     const remoteEventObject = new this.domWindow.CustomEvent(remoteEvent.name, {
@@ -567,7 +535,7 @@ var JSDOMRunner = class {
       const handlerAttributeValue = domNode.getAttribute(handlerAttributeName);
       if (handlerAttributeValue) {
         const script = handlerAttributeValue;
-        const vmContext = this.jsDom.getInternalVMContext();
+        const vmContext = this.jsdom.getInternalVMContext();
         try {
           const invoke = import_vm.default.runInContext(`(function(event){ ${script} })`, vmContext);
           Reflect.apply(invoke, domNode, [remoteEventObject]);
@@ -617,6 +585,6 @@ var JSDOMRunner = class {
 0 && (module.exports = {
   JSDOMRunner,
   JSDOMRunnerFactory,
-  ObservableDom
+  ObservableDOM
 });
 //# sourceMappingURL=index.js.map