occam-dom 5.0.15 → 5.2.0

package/src/transform.js

@@ -0,0 +1,184 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+import { appendNode,
+         removeNode,
+         prependNode,
+         replaceNode,
+         appendTokens,
+         removeTokens,
+         replaceTokens,
+         addNodesAfter,
+         prependTokens,
+         addTokensAfter,
+         overwriteClonedNodeTokens,
+         clonedTokensFromNodeAndTokens, } from "./utilities/transform";
+
+const { push } = arrayUtilities;
+
+export default class Transform {
+  constructor(node, tokens) {
+    this.node = node;
+    this.tokens = tokens;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTokens(tokens = []) {
+    push(tokens, this.tokens);
+
+    return this.tokens;
+  }
+
+  contract(Class, descendentNode, ...remainingArguments) {
+    if (descendentNode === undefined) {
+      descendentNode = Class; ///
+
+      Class = Transform;  ///
+    }
+
+    const node = descendentNode,  ///
+          tokens = this.tokens, ///
+          context = { ///
+            tokens
+          },
+          transform = Class.fromNode(node, ...remainingArguments, context);
+
+    return transform;
+  }
+
+  expand(Class, ascendantNode, ...remainingArguments) {
+    if (ascendantNode === undefined) {
+      ascendantNode = Class;
+
+      Class = Transform;  ///
+    }
+
+    const node = ascendantNode, ///
+          tokens = this.tokens, ///
+          context = {
+            tokens
+          },
+          transform = Class.fromNode(node, ...remainingArguments, context);
+
+    return transform;
+  }
+
+  appendTo(parentNode, context) {
+    const { tokens } = context,
+          appendedNode = this.node,  ///
+          appendedTokens = this.tokens;  ///
+
+    appendNode(appendedNode, parentNode);
+
+    appendTokens(appendedTokens, parentNode, tokens);
+  }
+
+  prependTo(parentNode, context) {
+    const { tokens } = context,
+          prependedNode = this.node,  ///
+          prependedTokens = this.tokens;  ///
+
+    prependNode(prependedNode, parentNode);
+
+    prependTokens(prependedTokens, parentNode, tokens);
+  }
+
+  addAfter(existingNode, parentNode, context) {
+    const { tokens } = context,
+          markdownNode = this.node, ///
+          removedChildNodes = markdownNode.removeChildNodes(),
+          addedTokens = this.tokens,  ///
+          addedNodes = removedChildNodes;  ///
+
+    addNodesAfter(existingNode, addedNodes, parentNode);
+
+    addTokensAfter(existingNode, addedTokens, tokens);
+  }
+
+  replace(replacedNode, parentNode, context) {
+    const { tokens } = context,
+          replacementNode = this.node, ///
+          replacementTokens = this.tokens; ///
+
+    replaceNode(replacementNode, replacedNode, parentNode);
+
+    replaceTokens(replacementTokens, replacedNode, tokens);
+  }
+
+  removeFrom(removedNode, parentNode, context) {
+    const { tokens } = context;
+
+    removeTokens(removedNode, tokens);
+
+    removeNode(removedNode, parentNode);
+  }
+
+  clone(...remainingArguments) {
+    const clonedNode = this.node.clone(),
+          clonedTokens = clonedTokensFromNodeAndTokens(this.node, this.tokens);
+
+    overwriteClonedNodeTokens(clonedNode, clonedTokens, this.tokens);
+
+    const Class = this.constructor, ///
+          node = clonedNode,  ///
+          tokens = clonedTokens, ///
+          transform = new Class(node, tokens, ...remainingArguments);
+
+    return transform
+  }
+
+  static fromNode(Class, node, ...remainingArguments) {
+    let context = remainingArguments.pop();
+
+    if (context === undefined) {
+      context = node; ///
+
+      node = Class; ///
+
+      Class = Transform;  ///
+    }
+
+    let { tokens } = context;
+
+    const firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+          clonedNode = node.clone();
+
+    let clonedTokens;
+
+    if (firstSignificantTokenIndex === null) {
+      clonedTokens = [];
+    } else {
+      const offset = firstSignificantTokenIndex;  ///
+
+      clonedTokens = clonedTokensFromNodeAndTokens(node, tokens);
+
+      overwriteClonedNodeTokens(clonedNode, clonedTokens, tokens, offset);
+    }
+
+    node = clonedNode;  ///
+
+    tokens = clonedTokens; ///
+
+    const transform = new Class(node, tokens, ...remainingArguments);
+
+    return transform;
+  }
+
+  static fromNodeAndTokens(Class, node, tokens, ...remainingArguments) {
+    if (tokens === undefined) {
+      tokens = node;  ///
+
+      node = Class; ///
+
+      Class = Transform;  ///
+    }
+
+    const transform = new Class(node, tokens, ...remainingArguments);
+
+    return transform;
+  }
+}

package/src/utilities/transform.js

@@ -0,0 +1,191 @@
+"use strict";
+
+export function appendNode(appendedNode, parentNode) {
+  const appendedChildNode = appendedNode;  ///
+
+  parentNode.appendChildNode(appendedChildNode);
+}
+
+export function prependNode(prependedNode, parentNode) {
+  const prependedChildNode = prependedNode;  ///
+
+  parentNode.prependChildNode(prependedChildNode);
+}
+
+export function removeNode(removedNode, parentNode) {
+  const removedChildNode = removedNode; ///
+
+  parentNode.removeChildNode(removedChildNode);
+}
+
+export function removeNodes(removedNodes, parentNode) {
+  const removedChildNodes = removedNodes; ///
+
+  parentNode.removeChildNodes(removedChildNodes);
+}
+
+export function replaceNode(replacementNode, replacedNode, parentNode) {
+  const replacedChildNode = replacedNode,  ///
+        replacementChildNode = replacementNode, ///
+        replacementChildNodes = [
+          replacementChildNode
+        ];
+
+  parentNode.replaceChildNode(replacedChildNode, replacementChildNodes);
+}
+
+export function replaceNodes(replacementNodes, replacedNode, parentNode) {
+  const replacedChildNode = replacedNode,  ///
+        replacementChildNodes = replacementNodes; ///
+
+  parentNode.replaceChildNodes(replacedChildNode, replacementChildNodes);
+}
+
+export function addNodeAfter(existingNode, addedNode, parentNode) {
+  const childNode = existingNode, ///
+        index = parentNode.indexOfChildNode(childNode),
+        addedChildNode = addedNode, ///
+        startIndex = index + 1;
+
+  parentNode.addChildNode(addedChildNode, startIndex);
+}
+
+export function addNodesAfter(existingNode, addedNodes, parentNode) {
+  const childNode = existingNode, ///
+        index = parentNode.indexOfChildNode(childNode),
+        addedChildNodes = addedNodes, ///
+        startIndex = index + 1;
+
+  parentNode.addChildNodes(addedChildNodes, startIndex);
+}
+
+export function appendTokens(appendedTokens, parentNode, tokens) {
+  const node = parentNode, ///
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = lastSignificantTokenIndex + 1,
+        deleteCount = 0;
+
+  tokens.splice(start, deleteCount, ...appendedTokens);
+}
+
+export function prependTokens(prependedTokens, parentNode, tokens) {
+  const node = parentNode, ///
+        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex,
+        deleteCount = 0;
+
+  tokens.splice(start, deleteCount, ...prependedTokens);
+}
+
+export function removeTokens(removedNode, tokens) {
+  const node = removedNode,  ///
+        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex, ///
+        end = lastSignificantTokenIndex + 1,
+        deleteCount = end - start;
+
+  tokens.splice(start, deleteCount);
+}
+
+export function replaceTokens(replacementTokens, replacedNode, tokens) {
+  const node = replacedNode,  ///
+        firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex, ///
+        end = lastSignificantTokenIndex + 1,
+        deleteCount = end - start;
+
+  tokens.splice(start, deleteCount, ...replacementTokens);
+}
+
+export function addTokensAfter(existingNode, addedTokens, tokens) {
+  const node = existingNode,  ///
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = lastSignificantTokenIndex + 1,
+        deleteCount = 0;
+
+  tokens.splice(start, deleteCount, ...addedTokens);
+}
+
+export function overwriteClonedNodeTokens(clonedNode, clonedTokens, tokens, offset = 0) {
+  const node = clonedNode;  ///
+
+  overwriteNodeTokens(node, clonedTokens, tokens, offset);
+}
+
+export function clonedTokensFromNodeAndTokens(node, tokens) {
+  const firstSignificantTokenIndex = node.getFirstSignificantTokenIndex(tokens),
+        lastSignificantTokenIndex = node.getLastSignificantTokenIndex(tokens),
+        start = firstSignificantTokenIndex,  ///
+        end = lastSignificantTokenIndex + 1;
+
+  tokens = tokens.slice(start, end);  ///
+
+  const clonedTokens = tokens.map((token) => {  ///
+    const clonedToken = token.clone();
+
+    return clonedToken;
+  });
+
+  return clonedTokens;
+}
+
+export default {
+  appendNode,
+  prependNode,
+  removeNode,
+  removeNodes,
+  replaceNode,
+  replaceNodes,
+  addNodeAfter,
+  addNodesAfter,
+  appendTokens,
+  prependTokens,
+  removeTokens,
+  replaceTokens,
+  addTokensAfter,
+  overwriteClonedNodeTokens,
+  clonedTokensFromNodeAndTokens
+};
+
+function overwriteNodeTokens(node, clonedTokens, tokens, offset) {
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {
+    const terminalNode = node;  ///
+
+    overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset);
+  } else {
+    const nonTerminalNode = node;  ///
+
+    overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset);
+  }
+}
+
+function overwriteTerminalNodeTokens(terminalNode, clonedTokens, tokens, offset) {
+  let index,
+      significantToken;
+
+  significantToken = terminalNode.getSignificantToken();
+
+  if (significantToken !== null) {
+    index = tokens.indexOf(significantToken);
+
+    index -= offset;
+
+    const clonedToken = clonedTokens[index];
+
+    significantToken = clonedToken;  ///
+
+    terminalNode.setSignificantToken(significantToken);
+  }
+}
+
+function overwriteNonTerminalNodeTokens(nonTerminalNode, clonedTokens, tokens, offset) {
+  nonTerminalNode.forEachChildNode((childNode) => {
+    const clonedNode = childNode; ///
+
+    overwriteNodeTokens(clonedNode, clonedTokens, tokens, offset);
+  });
+}