@mml-io/networked-dom-document 0.18.1 → 0.19.1

package/README.md

@@ -0,0 +1,10 @@
+# Networked DOM Document
+#### `@mml-io/networked-dom-document`
+
+[![npm version](https://img.shields.io/npm/v/@mml-io/networked-dom-document.svg?style=flat)](https://www.npmjs.com/package/@mml-io/networked-dom-document)
+
+This package contains classes `NetworkedDOM` and `EditableNetworkedDOM` that provide a way to accept websocket connections and synchronize a DOM document across multiple clients using WebSockets.
+
+The WebSocket protocol used by this package, `networked-dom-v0.1`, is defined in `@mml-io/networked-dom-protocol`.
+
+A client for the `networked-dom-v0.1` protocol is provided by `@mml-io/networked-dom-web`.

package/build/NetworkedDOM.d.ts

@@ -1,8 +1,8 @@
-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";
+import { NetworkedDOMV02Diff } from "@mml-io/networked-dom-protocol";
+import { LogMessage, ObservableDOMInterface, ObservableDOMMessage, ObservableDOMParameters, ObservableDOMRemoteEvent, StaticVirtualDOMElement } from "@mml-io/observable-dom-common";
+import { VirtualDOMDiffStruct } from "./diffing/calculateStaticVirtualDOMDiff";
+import { NetworkedDOMV01Connection } from "./NetworkedDOMV01Connection";
+import { NetworkedDOMV02Connection } from "./NetworkedDOMV02Connection";
 export type ObservableDOMFactory = (observableDOMParameters: ObservableDOMParameters, callback: (message: ObservableDOMMessage, observableDOM: ObservableDOMInterface) => void) => ObservableDOMInterface;
 /**
  * NetworkedDOM is the main class for the networked-dom-document package. It is responsible for managing the state of
@@ -12,47 +12,52 @@ export type ObservableDOMFactory = (observableDOMParameters: ObservableDOMParame
  * implementation that is used to run the document.
  */
 export declare class NetworkedDOM {
-    static SupportedWebsocketSubProtocolsPreferenceOrder: string[];
-    private internalNodeIdToClientNodeId;
-    private clientNodeIdToInternalNodeId;
+    private visibilityManager;
+    private nodeManager;
     private currentConnectionId;
-    private connectionIdToWebSocketContext;
-    private webSocketToConnectionId;
-    private visibleNodeIdsByConnectionId;
+    private connectionIdToNetworkedDOMConnection;
+    private networkedDOMV01Connections;
+    private networkedDOMV02Connections;
+    private webSocketToNetworkedDOMConnection;
     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?;
+    private disposed;
     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;
+    addExistingNetworkedDOMConnections(networkedDOMConnections: Set<NetworkedDOMV01Connection | NetworkedDOMV02Connection>, domDiff: VirtualDOMDiffStruct | null): void;
+    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;
+    disconnectUsers(networkedDOMConnection: NetworkedDOMV02Connection, removedExternalToInternalUserIds: Map<number, number>): Array<NetworkedDOMV02Diff>;
+    private defaultLogCallback;
+    private sendPings;
+    private getInitialV01Snapshot;
+    private getInitialV02Snapshot;
+    getDocumentTime(): number;
+    dispatchRemoteEvent(networkedDOMConnection: NetworkedDOMV01Connection | NetworkedDOMV02Connection, internalConnectionId: number, externalConnectionId: number, remoteEvent: ObservableDOMRemoteEvent): void;
     getSnapshot(): StaticVirtualDOMElement;
-    private addAndRemapNodeFromInstance;
-    getWebsocketConnectionIdMap(): Map<WebSocket, number>;
+    dispose(): void;
+    private handleAddedNodes;
+    private handleRemovedNodes;
+    private handleAttributeMutation;
+    private handleAttributeChange;
+    private handleVisibleToChange;
+    private handleHiddenFromChange;
+    private handleCharacterData;
+    private calculatePreVisibilityChangeRecords;
+    private applyVisibilityAfterChanges;
+    private reprojectStaticVirtualDOMElementWithMappings;
+    private reprojectMutationWithMappings;
+    private handleMutation;
+    private removeNodeAndChildren;
 }

package/build/NetworkedDOMV01Connection.d.ts

@@ -0,0 +1,15 @@
+import { NetworkedDOMV01ServerMessage } from "@mml-io/networked-dom-protocol";
+import { NetworkedDOM } from "./NetworkedDOM";
+export declare class NetworkedDOMV01Connection {
+    readonly webSocket: WebSocket;
+    private websocketListener;
+    internalConnectionId: number | null;
+    internalIdToExternalId: Map<number, number>;
+    networkedDOM: NetworkedDOM | null;
+    constructor(webSocket: WebSocket);
+    setNetworkedDOM(networkedDOM: NetworkedDOM | null): void;
+    initAsNewV01Connection(): void;
+    stringifyAndSendSingleMessage(message: NetworkedDOMV01ServerMessage): void;
+    sendStringifiedJSONArray(jsonArray: string): void;
+    dispose(): void;
+}

package/build/NetworkedDOMV02Connection.d.ts

@@ -0,0 +1,23 @@
+import { NetworkedDOMV02ServerMessage } from "@mml-io/networked-dom-protocol";
+import { NetworkedDOM } from "./NetworkedDOM";
+export declare class NetworkedDOMV02Connection {
+    readonly webSocket: WebSocket;
+    private websocketListener;
+    externalIdToInternalId: Map<number, number>;
+    internalIdToExternalId: Map<number, number>;
+    private batchMode;
+    private batchMessages;
+    externalConnectionIds: Set<number>;
+    networkedDOM: NetworkedDOM | null;
+    private messagesAwaitingNetworkedDOM;
+    constructor(webSocket: WebSocket);
+    setNetworkedDOM(networkedDOM: NetworkedDOM | null): void;
+    setBatchStart(): void;
+    setBatchEnd(): void;
+    sendMessage(message: NetworkedDOMV02ServerMessage): void;
+    sendMessages(messages: Array<NetworkedDOMV02ServerMessage>): void;
+    sendEncodedBytes(bytes: Uint8Array): void;
+    dispose(): void;
+    private handleClientMessage;
+    handleBufferedMessages(): void;
+}

package/build/NodeManager.d.ts

@@ -0,0 +1,19 @@
+import { StaticVirtualDOMElement } from "@mml-io/observable-dom-common";
+import { NodeWithSubjectivity } from "./NodeWithSubjectivity";
+import { VisibilityManager } from "./VisibilityManager";
+export declare class NodeManager {
+    private visibilityManager;
+    private nodeIdToNode;
+    private maximumNodeId;
+    private internalNodeIdToClientNodeId;
+    private clientNodeIdToInternalNodeId;
+    constructor(visibilityManager: VisibilityManager);
+    getNode(nodeId: number): NodeWithSubjectivity | undefined;
+    deleteNode(nodeId: number): void;
+    addNodeFromInstance(node: StaticVirtualDOMElement, parentNode: NodeWithSubjectivity | null): [NodeWithSubjectivity, boolean];
+    addRemappedNodeId(clientFacingNodeId: number, internalNodeId: number): void;
+    hasAnyRemappings(): boolean;
+    getPotentiallyRemappedNode(nodeId: number, createIfCollided?: boolean): number;
+    getStaticVirtualDOMElementByInternalNodeIdOrThrow(internalNodeId: number): NodeWithSubjectivity;
+    getInternalRemappedNodeId(nodeId: number): number | undefined;
+}

package/build/NodeWithSubjectivity.d.ts

@@ -0,0 +1,19 @@
+export type Subjectivity = {
+    visibleTo: Set<number>;
+    hiddenFrom: Set<number>;
+    ancestorSubjectivity: Subjectivity | null;
+};
+export declare function IsVisibleToAll(s: Subjectivity, applyV01Semantics: boolean): boolean;
+export declare function IsVisibleToAnyOneOfConnectionIds(s: Subjectivity, connectionIdsMap: Map<number, number>, applyV01Semantics: boolean): boolean;
+export type NodeWithSubjectivity = {
+    nodeId: number;
+    tag: string;
+    textContent?: string;
+    attributes: {
+        [key: string]: string;
+    };
+    childNodes: Array<NodeWithSubjectivity>;
+    subjectivity: Subjectivity;
+    parent: NodeWithSubjectivity | null;
+};
+export declare function applySubjectivityToChildren(node: NodeWithSubjectivity, newSubjectivity: Subjectivity, previousSubjectivity: Subjectivity): void;

package/build/VisibilityManager.d.ts

@@ -0,0 +1,6 @@
+export declare class VisibilityManager {
+    private connectionIdToSpecificallyVisibleNodes;
+    addSpecificallyVisibleNode(internalConnectionId: number, nodeId: number): void;
+    removeSpecificallyVisibleNode(internalConnectionId: number, nodeId: number): void;
+    getSpecificallyVisibleNodes(internalConnectionId: number): Set<number> | undefined;
+}

package/build/createNetworkedDOMConnectionForWebsocket.d.ts

@@ -0,0 +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 defaultWebsocketSubProtocol = "networked-dom-v0.1";
+export declare function createNetworkedDOMConnectionForWebsocket(webSocket: WebSocket): NetworkedDOMV01Connection | NetworkedDOMV02Connection | null;

package/build/{common.d.ts → diffing/calculateStaticVirtualDOMDiff.d.ts}

@@ -1,5 +1,5 @@
 import { StaticVirtualDOMElement } from "@mml-io/observable-dom-common";
-import * as rfc6902 from "./rfc6902";
+import * as rfc6902 from "../rfc6902";
 export type NodeMapping = {
     clientFacingNodeId: number;
     internalNodeId: number;
@@ -14,15 +14,4 @@ export type VirtualDOMDiffStruct = {
     nodeIdRemappings: Array<NodeMapping>;
     virtualDOMDiffs: Array<rfc6902.Operation>;
 };
-/**
- * StaticVirtualDOMMutationRecord is a plain object representation of a MutationRecord that can be serialized as it
- * contains no references to DOM elements and instead uses node IDs to refer to elements.
- */
-export type StaticVirtualDOMMutationRecord = {
-    type: "attributes" | "characterData" | "childList" | "snapshot";
-    target: StaticVirtualDOMElement;
-    addedNodes: Array<StaticVirtualDOMElement>;
-    removedNodes: Array<StaticVirtualDOMElement>;
-    previousSibling: StaticVirtualDOMElement | null;
-    attributeName: string | null;
-};
+export declare function calculateStaticVirtualDOMDiff(originalState: StaticVirtualDOMElement, latestState: StaticVirtualDOMElement): VirtualDOMDiffStruct;

package/build/diffing/describeNode.d.ts

@@ -0,0 +1,8 @@
+import { NetworkedDOMV01NodeDescription, NetworkedDOMV02NodeDescription } from "@mml-io/networked-dom-protocol";
+import { NetworkedDOMV01Connection } from "../NetworkedDOMV01Connection";
+import { NetworkedDOMV02Connection } from "../NetworkedDOMV02Connection";
+import { NodeWithSubjectivity } from "../NodeWithSubjectivity";
+export declare const visibleToAttrName = "visible-to";
+export declare const hiddenFromAttrName = "hidden-from";
+export declare function describeNodeWithChildrenForV01Connection(virtualDOMElement: NodeWithSubjectivity, networkedDOMConnection: NetworkedDOMV01Connection | null): NetworkedDOMV01NodeDescription | null;
+export declare function describeNodeWithChildrenForV02Connection(virtualDOMElement: NodeWithSubjectivity, networkedDOMConnection: NetworkedDOMV02Connection | null): NetworkedDOMV02NodeDescription | null;

package/build/diffing/listAttributeToSet.d.ts

@@ -0,0 +1 @@
+export declare function listAttributeToSet(attr?: string | null): Set<number>;

package/build/diffing/mergeMutations.d.ts

@@ -0,0 +1,2 @@
+import { StaticVirtualDOMMutationIdsRecord } from "@mml-io/observable-dom-common";
+export declare function mergeMutations(mutations: Array<StaticVirtualDOMMutationIdsRecord>): StaticVirtualDOMMutationIdsRecord[];

package/build/diffing/virtualDOMDiffToVirtualDOMMutationRecord.d.ts

@@ -0,0 +1,3 @@
+import { StaticVirtualDOMElement, StaticVirtualDOMMutationIdsRecord } from "@mml-io/observable-dom-common";
+import * as rfc6902 from "../rfc6902";
+export declare function virtualDOMDiffToVirtualDOMMutationRecord(virtualStructure: StaticVirtualDOMElement, domDiff: rfc6902.Operation): Array<StaticVirtualDOMMutationIdsRecord>;

package/build/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./EditableNetworkedDOM";
 export * from "./NetworkedDOM";
+export { NetworkedDOMV01Connection } from "./NetworkedDOMV01Connection";
+export { NetworkedDOMV02Connection } from "./NetworkedDOMV02Connection";