@mml-io/networked-dom-document 0.15.0 → 0.16.1

package/build/common.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;

package/build/diffing.d.ts

@@ -1,7 +1,7 @@
 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";
+import * as rfc6902 from "./rfc6902";
 export declare const visibleToAttrName = "visible-to";
 export declare const hiddenFromAttrName = "hidden-from";
 /**

package/build/index.js

@@ -1,8 +1,484 @@
-// src/NetworkedDOM.ts
-import { applyPatch as applyPatch2 } from "rfc6902";
+// src/rfc6902/pointer.ts
+function unescape(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function escape(token) {
+  return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+var Pointer = class _Pointer {
+  constructor(tokens = [""]) {
+    this.tokens = tokens;
+  }
+  /**
+  `path` *must* be a properly escaped string.
+  */
+  static fromJSON(path) {
+    const tokens = path.split("/").map(unescape);
+    if (tokens[0] !== "")
+      throw new Error(`Invalid JSON Pointer: ${path}`);
+    return new _Pointer(tokens);
+  }
+  toString() {
+    return this.tokens.map(escape).join("/");
+  }
+  /**
+  Returns an object with 'parent', 'key', and 'value' properties.
+  In the special case that this Pointer's path == "",
+  this object will be {parent: null, key: '', value: object}.
+  Otherwise, parent and key will have the property such that parent[key] == value.
+  */
+  evaluate(object) {
+    let parent = null;
+    let key = "";
+    let value = object;
+    for (let i = 1, l = this.tokens.length; i < l; i++) {
+      parent = value;
+      key = this.tokens[i];
+      if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        continue;
+      }
+      value = (parent || {})[key];
+    }
+    return { parent, key, value };
+  }
+  get(object) {
+    return this.evaluate(object).value;
+  }
+  set(object, value) {
+    let cursor = object;
+    for (let i = 1, l = this.tokens.length - 1, token = this.tokens[i]; i < l; i++) {
+      cursor = (cursor || {})[token];
+    }
+    if (cursor) {
+      cursor[this.tokens[this.tokens.length - 1]] = value;
+    }
+  }
+  push(token) {
+    this.tokens.push(token);
+  }
+  /**
+    `token` should be a String. It'll be coerced to one anyway.
+  
+    immutable (shallowly)
+    */
+  add(token) {
+    const tokens = this.tokens.concat(String(token));
+    return new _Pointer(tokens);
+  }
+};
+
+// src/rfc6902/deepEqual.ts
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    return a.every((elem, index) => {
+      return deepEqual(elem, b[index]);
+    });
+  }
+  if (typeof a === "object" && typeof b === "object" && a !== null && b !== null) {
+    if (Array.isArray(a) || Array.isArray(b)) {
+      return false;
+    }
+    const keys1 = Object.keys(a);
+    const keys2 = Object.keys(b);
+    if (keys1.length !== keys2.length || !keys1.every((key) => keys2.includes(key))) {
+      return false;
+    }
+    for (const key in a) {
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    if (keys1.length === 0 && a instanceof Date && b instanceof Date) {
+      return a.getTime() === b.getTime();
+    }
+    return true;
+  }
+  return false;
+}
+
+// src/rfc6902/util.ts
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function objectType(object) {
+  if (object === void 0) {
+    return "undefined";
+  }
+  if (object === null) {
+    return "null";
+  }
+  if (Array.isArray(object)) {
+    return "array";
+  }
+  return typeof object;
+}
+function isNonPrimitive(value) {
+  return value != null && typeof value === "object";
+}
+function clone(source) {
+  if (!isNonPrimitive(source)) {
+    return source;
+  }
+  if (Array.isArray(source)) {
+    const length = source.length;
+    const arrayTarget = new Array(length);
+    for (let i = 0; i < length; i++) {
+      arrayTarget[i] = clone(source[i]);
+    }
+    return arrayTarget;
+  }
+  if (source.constructor === Date) {
+    const dateTarget = /* @__PURE__ */ new Date(+source);
+    return dateTarget;
+  }
+  const objectTarget = {};
+  for (const key in source) {
+    if (hasOwnProperty.call(source, key)) {
+      objectTarget[key] = clone(source[key]);
+    }
+  }
+  return objectTarget;
+}
+
+// src/rfc6902/diff.ts
+function wrapVoidableDiff(diff) {
+  function wrappedDiff(input, output, ptr) {
+    const custom_patch = diff(input, output, ptr);
+    return Array.isArray(custom_patch) ? custom_patch : diffAny(input, output, ptr, wrappedDiff);
+  }
+  return wrappedDiff;
+}
+function createPatch(input, output, diff) {
+  const ptr = new Pointer();
+  return (diff ? wrapVoidableDiff(diff) : diffAny)(input, output, ptr);
+}
+function subtract(minuend, subtrahend) {
+  const obj = {};
+  for (const add_key in minuend) {
+    if (hasOwnProperty.call(minuend, add_key) && minuend[add_key] !== void 0) {
+      obj[add_key] = 1;
+    }
+  }
+  for (const del_key in subtrahend) {
+    if (hasOwnProperty.call(subtrahend, del_key) && subtrahend[del_key] !== void 0) {
+      delete obj[del_key];
+    }
+  }
+  return Object.keys(obj);
+}
+function intersection(objects) {
+  const length = objects.length;
+  const counter = {};
+  for (let i = 0; i < length; i++) {
+    const object = objects[i];
+    for (const key in object) {
+      if (hasOwnProperty.call(object, key) && object[key] !== void 0) {
+        counter[key] = (counter[key] || 0) + 1;
+      }
+    }
+  }
+  for (const key in counter) {
+    if (counter[key] < length) {
+      delete counter[key];
+    }
+  }
+  return Object.keys(counter);
+}
+function isArrayAdd(array_operation) {
+  return array_operation.op === "add";
+}
+function isArrayRemove(array_operation) {
+  return array_operation.op === "remove";
+}
+function buildOperations(memo, i, j) {
+  let memoized = memo[i][j];
+  if (!memoized) {
+    throw new Error("invalid memo");
+  }
+  const operations = [];
+  while (memoized && memoized.prev && memoized.operation) {
+    operations.push(memoized.operation);
+    const index = memoized.prev.split(",");
+    memoized = memo[Number(index[0])][Number(index[1])];
+  }
+  return operations.reverse();
+}
+function diffArrays(input, output, ptr, diff = diffAny) {
+  if (diff === void 0) {
+    diff = diffAny;
+  }
+  const input_length = isNaN(input.length) || input.length <= 0 ? 0 : input.length;
+  const output_length = isNaN(output.length) || output.length <= 0 ? 0 : output.length;
+  let input_end = input_length;
+  let output_end = output_length;
+  while (input_end > 0 && output_end > 0) {
+    if (deepEqual(input[input_end - 1], output[output_end - 1])) {
+      input_end--;
+      output_end--;
+    } else {
+      break;
+    }
+  }
+  const memo = new Array(input_end + 1);
+  for (let i = 0; i <= input_end; i++) {
+    memo[i] = new Array(output_end + 1);
+  }
+  memo[0][0] = { prev: null, operation: null, cost: 0 };
+  for (let i = 0; i <= input_end; i++) {
+    for (let j = 0; j <= output_end; j++) {
+      let memoized = memo[i][j];
+      if (memoized)
+        continue;
+      const add_prev_key = `${i},${j - 1}`;
+      const remove_prev_key = `${i - 1},${j}`;
+      const replace_prev_key = `${i - 1},${j - 1}`;
+      const remove_operation = {
+        op: "remove",
+        index: i - 1
+      };
+      const add_operation = {
+        op: "add",
+        index: i - 1,
+        value: output[j - 1]
+      };
+      if (j === 0) {
+        memoized = {
+          prev: remove_prev_key,
+          operation: remove_operation,
+          cost: memo[i - 1][j].cost + 1
+        };
+      } else if (i === 0) {
+        memoized = { prev: add_prev_key, operation: add_operation, cost: memo[i][j - 1].cost + 1 };
+      } else {
+        if (deepEqual(input[i - 1], output[j - 1])) {
+          memoized = memo[i - 1][j - 1];
+        } else {
+          const remove_prev = memo[i - 1][j];
+          const add_prev = memo[i][j - 1];
+          const replace_prev = memo[i - 1][j - 1];
+          const min_cost = Math.min(replace_prev.cost, add_prev.cost, remove_prev.cost);
+          if (remove_prev.cost === min_cost) {
+            memoized = {
+              prev: remove_prev_key,
+              operation: remove_operation,
+              cost: memo[i - 1][j].cost + 1
+            };
+          } else if (add_prev.cost === min_cost) {
+            memoized = {
+              prev: add_prev_key,
+              operation: add_operation,
+              cost: memo[i][j - 1].cost + 1
+            };
+          } else {
+            const replace_operation = {
+              op: "replace",
+              index: i - 1,
+              original: input[i - 1],
+              value: output[j - 1]
+            };
+            memoized = {
+              prev: replace_prev_key,
+              operation: replace_operation,
+              cost: memo[i - 1][j - 1].cost + 1
+            };
+          }
+        }
+      }
+      memo[i][j] = memoized;
+    }
+  }
+  const array_operations = buildOperations(memo, input_end, output_end);
+  const [padded_operations] = array_operations.reduce(
+    ([operations, padding], array_operation) => {
+      if (isArrayAdd(array_operation)) {
+        const padded_index = array_operation.index + 1 + padding;
+        const index_token = padded_index < input_length + padding ? String(padded_index) : "-";
+        const operation = {
+          op: array_operation.op,
+          path: ptr.add(index_token).toString(),
+          value: array_operation.value
+        };
+        return [operations.concat(operation), padding + 1];
+      } else if (isArrayRemove(array_operation)) {
+        const operation = {
+          op: array_operation.op,
+          path: ptr.add(String(array_operation.index + padding)).toString()
+        };
+        return [operations.concat(operation), padding - 1];
+      } else {
+        const replace_ptr = ptr.add(String(array_operation.index + padding));
+        const replace_operations = diff(
+          array_operation.original,
+          array_operation.value,
+          replace_ptr
+        );
+        return [operations.concat(...replace_operations), padding];
+      }
+    },
+    [[], 0]
+  );
+  return padded_operations;
+}
+function diffObjects(input, output, ptr, diff = diffAny) {
+  const operations = [];
+  subtract(input, output).forEach((key) => {
+    operations.push({ op: "remove", path: ptr.add(key).toString() });
+  });
+  subtract(output, input).forEach((key) => {
+    operations.push({ op: "add", path: ptr.add(key).toString(), value: output[key] });
+  });
+  intersection([input, output]).forEach((key) => {
+    operations.push(...diff(input[key], output[key], ptr.add(key)));
+  });
+  return operations;
+}
+function diffAny(input, output, ptr, diff = diffAny) {
+  if (input === output) {
+    return [];
+  }
+  const input_type = objectType(input);
+  const output_type = objectType(output);
+  if (input_type === "array" && output_type === "array") {
+    return diffArrays(input, output, ptr, diff);
+  }
+  if (input_type === "object" && output_type === "object") {
+    return diffObjects(input, output, ptr, diff);
+  }
+  return [{ op: "replace", path: ptr.toString(), value: output }];
+}
+
+// src/rfc6902/patch.ts
+var MissingError = class extends Error {
+  constructor(path) {
+    super(`Value required at path: ${path}`);
+    this.path = path;
+    this.name = "MissingError";
+  }
+};
+var TestError = class extends Error {
+  constructor(actual, expected) {
+    super(`Test failed: ${actual} != ${expected}`);
+    this.actual = actual;
+    this.expected = expected;
+    this.name = "TestError";
+  }
+};
+function applyPatch(object, patch) {
+  return patch.map((operation) => apply(object, operation));
+}
+function _add(object, key, value) {
+  if (Array.isArray(object)) {
+    if (key === "-") {
+      object.push(value);
+    } else {
+      const index = parseInt(key, 10);
+      object.splice(index, 0, value);
+    }
+  } else {
+    object[key] = value;
+  }
+}
+function _remove(object, key) {
+  if (Array.isArray(object)) {
+    const index = parseInt(key, 10);
+    object.splice(index, 1);
+  } else {
+    delete object[key];
+  }
+}
+function add(object, operation) {
+  const endpoint = Pointer.fromJSON(operation.path).evaluate(object);
+  if (endpoint.parent === void 0) {
+    return new MissingError(operation.path);
+  }
+  _add(endpoint.parent, endpoint.key, clone(operation.value));
+  return null;
+}
+function remove(object, operation) {
+  const endpoint = Pointer.fromJSON(operation.path).evaluate(object);
+  if (endpoint.value === void 0) {
+    return new MissingError(operation.path);
+  }
+  _remove(endpoint.parent, endpoint.key);
+  return null;
+}
+function replace(object, operation) {
+  const endpoint = Pointer.fromJSON(operation.path).evaluate(object);
+  if (endpoint.parent === null) {
+    return new MissingError(operation.path);
+  }
+  if (Array.isArray(endpoint.parent)) {
+    if (parseInt(endpoint.key, 10) >= endpoint.parent.length) {
+      return new MissingError(operation.path);
+    }
+  } else if (endpoint.value === void 0) {
+    return new MissingError(operation.path);
+  }
+  endpoint.parent[endpoint.key] = operation.value;
+  return null;
+}
+function move(object, operation) {
+  const from_endpoint = Pointer.fromJSON(operation.from).evaluate(object);
+  if (from_endpoint.value === void 0) {
+    return new MissingError(operation.from);
+  }
+  const endpoint = Pointer.fromJSON(operation.path).evaluate(object);
+  if (endpoint.parent === void 0) {
+    return new MissingError(operation.path);
+  }
+  _remove(from_endpoint.parent, from_endpoint.key);
+  _add(endpoint.parent, endpoint.key, from_endpoint.value);
+  return null;
+}
+function copy(object, operation) {
+  const from_endpoint = Pointer.fromJSON(operation.from).evaluate(object);
+  if (from_endpoint.value === void 0) {
+    return new MissingError(operation.from);
+  }
+  const endpoint = Pointer.fromJSON(operation.path).evaluate(object);
+  if (endpoint.parent === void 0) {
+    return new MissingError(operation.path);
+  }
+  _add(endpoint.parent, endpoint.key, clone(from_endpoint.value));
+  return null;
+}
+function test(object, operation) {
+  const endpoint = Pointer.fromJSON(operation.path).evaluate(object);
+  if (diffAny(endpoint.value, operation.value, new Pointer()).length) {
+    return new TestError(endpoint.value, operation.value);
+  }
+  return null;
+}
+var InvalidOperationError = class extends Error {
+  constructor(operation) {
+    super(`Invalid operation: ${operation.op}`);
+    this.operation = operation;
+    this.name = "InvalidOperationError";
+  }
+};
+function apply(object, operation) {
+  switch (operation.op) {
+    case "add":
+      return add(object, operation);
+    case "remove":
+      return remove(object, operation);
+    case "replace":
+      return replace(object, operation);
+    case "move":
+      return move(object, operation);
+    case "copy":
+      return copy(object, operation);
+    case "test":
+      return test(object, operation);
+  }
+  return new InvalidOperationError(operation);
+}
 
 // src/diffing.ts
-import * as rfc6902 from "rfc6902";
 var visibleToAttrName = "visible-to";
 var hiddenFromAttrName = "hidden-from";
 function diffFromApplicationOfStaticVirtualDOMMutationRecordToConnection(mutation, parentNode, connectionId, visibleNodesForConnection) {
@@ -249,12 +725,12 @@ function findParentNodeOfNodeId(virtualDOMElement, targetNodeId) {
   return null;
 }
 function virtualDOMDiffToVirtualDOMMutationRecord(virtualStructure, domDiff) {
-  const pointer = rfc6902.Pointer.fromJSON(domDiff.path);
+  const pointer = Pointer.fromJSON(domDiff.path);
   const grandParentTokens = pointer.tokens.slice(0, pointer.tokens.length - 2);
   const lastToken = pointer.tokens[pointer.tokens.length - 1];
   const secondLastToken = pointer.tokens[pointer.tokens.length - 2];
   if (lastToken === "textContent") {
-    const nodePointer = new rfc6902.Pointer(pointer.tokens.slice(0, pointer.tokens.length - 1));
+    const nodePointer = new Pointer(pointer.tokens.slice(0, pointer.tokens.length - 1));
     const node = nodePointer.get(virtualStructure);
     return [
       {
@@ -268,7 +744,7 @@ function virtualDOMDiffToVirtualDOMMutationRecord(virtualStructure, domDiff) {
     ];
   }
   if (secondLastToken === "attributes") {
-    const nodePointer = new rfc6902.Pointer(grandParentTokens);
+    const nodePointer = new Pointer(grandParentTokens);
     const node = nodePointer.get(virtualStructure);
     return [
       {
@@ -282,7 +758,7 @@ function virtualDOMDiffToVirtualDOMMutationRecord(virtualStructure, domDiff) {
     ];
   }
   if (secondLastToken === "childNodes") {
-    const nodePointer = new rfc6902.Pointer(grandParentTokens);
+    const nodePointer = new Pointer(grandParentTokens);
     const node = nodePointer.get(virtualStructure);
     let previousSibling = null;
     if (lastToken === "-") {
@@ -366,7 +842,7 @@ function virtualDOMDiffToVirtualDOMMutationRecord(virtualStructure, domDiff) {
   throw new Error("Unhandled diff type");
 }
 function calculateStaticVirtualDOMDiff(originalState, latestState) {
-  const jsonPatchDiffs = rfc6902.createPatch(
+  const jsonPatchDiffs = createPatch(
     originalState,
     latestState,
     (a, b, ptr) => {
@@ -380,7 +856,7 @@ function calculateStaticVirtualDOMDiff(originalState, latestState) {
   const virtualDOMDiffs = [];
   for (const diff of jsonPatchDiffs) {
     if (diff.op === "replace" && diff.path.endsWith("/nodeId")) {
-      const pointer = rfc6902.Pointer.fromJSON(diff.path);
+      const pointer = Pointer.fromJSON(diff.path);
       const originalValue = pointer.get(originalState);
       nodeIdRemappings.push({
         internalNodeId: diff.value,
@@ -415,7 +891,7 @@ function getRemovedNodeIds(before, diff) {
     }
   }
   if (diff.op === "replace" || diff.op === "remove") {
-    const removedNode = rfc6902.Pointer.fromJSON(diff.path).get(before);
+    const removedNode = Pointer.fromJSON(diff.path).get(before);
     addNode(removedNode);
   }
   return removedIds;
@@ -457,7 +933,7 @@ function remapDuplicatedNodeIdsInOperations(virtualDOMDiffStruct, latestState) {
   }
   const existingNodeIds = getNodeIdsFromNodeAndChildren(before);
   for (const diff of virtualDOMDiffs) {
-    const pointer = rfc6902.Pointer.fromJSON(diff.path);
+    const pointer = Pointer.fromJSON(diff.path);
     const secondLastToken = pointer.tokens[pointer.tokens.length - 2];
     if (secondLastToken !== "childNodes") {
       continue;
@@ -473,7 +949,7 @@ function remapDuplicatedNodeIdsInOperations(virtualDOMDiffStruct, latestState) {
     addingNodeIds.forEach((addingNodeId) => {
       existingNodeIds.add(addingNodeId);
     });
-    const patchErrors = rfc6902.applyPatch(before, [diff]);
+    const patchErrors = applyPatch(before, [diff]);
     if (patchErrors.length !== 1 || patchErrors[0] !== null) {
       throw new Error("Patch failed");
     }
@@ -648,7 +1124,7 @@ var _NetworkedDOM = class _NetworkedDOM {
         );
         if (virtualDOMDiff.path === "" && virtualDOMDiff.op === "replace") {
         } else {
-          const patchResults = applyPatch2(domDiff.originalState, [virtualDOMDiff]);
+          const patchResults = applyPatch(domDiff.originalState, [virtualDOMDiff]);
           for (const patchResult of patchResults) {
             if (patchResult !== null) {
               console.error("Patching virtual dom structure resulted in error", patchResult);
@@ -686,7 +1162,7 @@ var _NetworkedDOM = class _NetworkedDOM {
         const asServerMessages = diffs;
         const firstDiff = diffs[0];
         firstDiff.documentTime = this.getDocumentTime();
-        const serializedDiffs = JSON.stringify(asServerMessages, null, 4);
+        const serializedDiffs = JSON.stringify(asServerMessages);
         const webSocketContext = this.connectionIdToWebSocketContext.get(connectionId);
         if (!webSocketContext) {
           throw new Error(`webSocketContext not found in addExistingWebsockets`);
@@ -868,7 +1344,7 @@ var _NetworkedDOM = class _NetworkedDOM {
     diffsByConnectionId.forEach((diffs, connectionId) => {
       if (diffs.length > 0) {
         const asServerMessages = diffs;
-        const serializedDiffs = JSON.stringify(asServerMessages, null, 4);
+        const serializedDiffs = JSON.stringify(asServerMessages);
         const webSocketContext = this.connectionIdToWebSocketContext.get(connectionId);
         if (!webSocketContext) {
           throw new Error(`webSocketContext not found in processModificationList`);