@remote-dom/polyfill 1.5.1 → 1.6.0

package/build/cjs/ParentNode.cjs

@@ -7,69 +7,112 @@ const ChildNode = require('./ChildNode.cjs');
 const NodeList = require('./NodeList.cjs');
 const selectors = require('./selectors.cjs');
 const shared = require('./shared.cjs');
+const MutationObserver = require('./MutationObserver.cjs');
+const customElementReactions = require('./custom-element-reactions.cjs');
+const hookEffects = require('./hook-effects.cjs');
+const domException = require('./dom-exception.cjs');
 
 class ParentNode extends ChildNode.ChildNode {
-  childNodes = (() => new NodeList.NodeList())();
-  children = (() => new NodeList.NodeList())();
+  childNodes = new NodeList.NodeList();
+  children = new NodeList.NodeList();
   appendChild(child) {
-    this.insertInto(child, null);
+    return customElementReactions.performWithCustomElementReactions(() => this[ChildNode.INSERT_NODE](child, null));
   }
   insertBefore(child, ref) {
-    this.insertInto(child, ref || null);
+    return customElementReactions.performWithCustomElementReactions(() => this[ChildNode.INSERT_NODE](child, ref || null));
   }
   append(...nodes) {
-    for (const child of nodes) {
-      if (child == null) continue;
-      this.appendChild(ChildNode.toNode(this, child));
-    }
+    return customElementReactions.performWithCustomElementReactions(() => {
+      const staged = ChildNode.stageNodes(nodes.filter(node => node != null));
+      if (staged.length > 1) ChildNode.validateInsertionNodes(this, staged);
+      for (const child of staged) {
+        this[ChildNode.INSERT_NODE](ChildNode.toNode(this, child), null);
+      }
+    });
   }
   prepend(...nodes) {
-    const before = this.firstChild;
-    for (const child of nodes) {
-      if (child == null) continue;
-      this.insertBefore(ChildNode.toNode(this, child), before);
-    }
+    return customElementReactions.performWithCustomElementReactions(() => {
+      const staged = ChildNode.stageNodes(nodes.filter(node => node != null));
+      if (staged.length > 1) ChildNode.validateInsertionNodes(this, staged);
+      const before = this.firstChild;
+      for (const child of staged) {
+        this[ChildNode.INSERT_NODE](ChildNode.toNode(this, child), before);
+      }
+    });
   }
   replaceChildren(...nodes) {
-    let child;
-    while (child = this.firstChild) {
-      this.removeChild(child);
-    }
-    this.append(...nodes);
+    return customElementReactions.performWithCustomElementReactions(() => {
+      const staged = ChildNode.stageNodes(nodes.filter(node => node != null));
+      ChildNode.validateInsertionNodes(this, staged);
+      let child;
+      while (child = this.firstChild) {
+        this.removeChildImmediately(child);
+      }
+      for (const node of staged) {
+        this[ChildNode.INSERT_NODE](ChildNode.toNode(this, node), null);
+      }
+    });
   }
   removeChild(child) {
-    if (child.parentNode !== this) throw Error(`not a child of this node`);
-    const prev = child[constants.PREV];
-    const next = child[constants.NEXT];
-    if (prev) prev[constants.NEXT] = next;else this[constants.CHILD] = next;
-    if (next) next[constants.PREV] = prev;
-    const childNodes = this.childNodes;
-    const childNodesIndex = childNodes.indexOf(child);
-    childNodes.splice(childNodesIndex, 1);
-    if (child.nodeType === 1) {
-      const children = this.children;
-      children.splice(children.indexOf(child), 1);
-    }
-    child[constants.PARENT] = null;
-    child[constants.NEXT] = null;
-    child[constants.PREV] = null;
-    if (this[constants.IS_CONNECTED]) {
-      for (const node of shared.selfAndDescendants(child)) {
-        node[constants.IS_CONNECTED] = false;
-        node.disconnectedCallback?.();
-      }
+    return customElementReactions.performWithCustomElementReactions(() => {
+      this.removeChildImmediately(child);
+      return child;
+    });
+  }
+  removeChildImmediately(child) {
+    if (child.parentNode !== this) {
+      throw domException.createDOMException('The node is not a child of this node', 'NotFoundError');
+    }
+    const disconnectedNodes = this[constants.IS_CONNECTED] ? shared.selfAndDescendants(child) : undefined;
+    const previousSibling = child[constants.PREV];
+    const nextSibling = child[constants.NEXT];
+    const childNodesIndex = detachChild(this, child);
+    if (disconnectedNodes) {
+      for (const node of disconnectedNodes) node[constants.IS_CONNECTED] = false;
     }
-    if (this.nodeType === constants.NodeType.ELEMENT_NODE) {
-      this[constants.HOOKS].removeChild?.(this, child, childNodesIndex);
+    this.queueRemovalMutationRecord(this, child, previousSibling, nextSibling);
+    if (disconnectedNodes) {
+      this.enqueueTreeReactions(disconnectedNodes, 'disconnectedCallback');
     }
+    hookEffects.performHookEffects(this.collectRemovalHookEffects(child, childNodesIndex));
   }
   replaceChild(newChild, oldChild) {
+    return customElementReactions.performWithCustomElementReactions(() => this[ChildNode.REPLACE_NODE](newChild, oldChild));
+  }
+  [ChildNode.REPLACE_NODE](newChild, oldChild, hookEffects) {
+    ChildNode.validateInsertionNodes(this, [newChild]);
     if (oldChild.parentNode !== this) {
-      throw Error('reference node is not a child of this parent');
+      throw domException.createDOMException('The reference node is not a child of this parent', 'NotFoundError');
     }
+    const previous = oldChild[constants.PREV];
     const next = oldChild[constants.NEXT];
-    this.removeChild(oldChild);
-    this.insertInto(newChild, next);
+    const insertion = this.prepareInsertion(newChild);
+    const removedNodes = this[constants.IS_CONNECTED] ? shared.selfAndDescendants(oldChild) : undefined;
+    const insertionRoots = new Set(insertion.map(({
+      node
+    }) => node));
+    let before = next;
+    while (before && insertionRoots.has(before)) before = before[constants.NEXT];
+    const oldChildIndex = detachChild(this, oldChild);
+    if (removedNodes) {
+      for (const node of removedNodes) node[constants.IS_CONNECTED] = false;
+      const removedNodeSet = new Set(removedNodes);
+      for (const prepared of insertion) {
+        if (removedNodeSet.has(prepared.node)) {
+          prepared.shouldDisconnect = false;
+        }
+      }
+    }
+    this.commitInsertion(insertion, before);
+    const destinationIsConnected = this[constants.IS_CONNECTED];
+    this.queueRemovalMutationRecord(this, oldChild, previous, next);
+    this.queueInsertionMutationRecords(insertion);
+    if (removedNodes) {
+      this.enqueueTreeReactions(removedNodes, 'disconnectedCallback');
+    }
+    this.enqueueInsertionReactions(insertion, destinationIsConnected);
+    this.performOrCollectHookEffects([...this.collectRemovalHookEffects(oldChild, oldChildIndex), ...this.collectInsertionHookEffects(insertion)], hookEffects);
+    return oldChild;
   }
   querySelectorAll(selector) {
     return selectors.querySelectorAll(this, selector);
@@ -77,27 +120,111 @@ class ParentNode extends ChildNode.ChildNode {
   querySelector(selector) {
     return selectors.querySelector(this, selector);
   }
-  insertInto(child, before) {
-    // append the children of a DocumentFragment:
-    if (child.nodeType === constants.NodeType.DOCUMENT_FRAGMENT_NODE) {
+  [ChildNode.INSERT_NODE](child, before, hookEffects) {
+    this.validateInsertion(child, before);
+    this.insertIntoValidated(child, before, hookEffects);
+    return child;
+  }
+  [ChildNode.PREFLIGHT_INSERTIONS](children) {
+    for (const child of children) {
+      this.validateInsertion(child, null);
+      this.prepareInsertion(child);
+    }
+  }
+  validateInsertion(child, before) {
+    ChildNode.validateInsertionNodes(this, [child]);
+    if (before && before.parentNode !== this) {
+      throw domException.createDOMException('The reference node is not a child of this parent', 'NotFoundError');
+    }
+  }
+  insertIntoValidated(child, before, hookEffects) {
+    if (child === before) before = child[constants.NEXT];
+    const insertion = this.prepareInsertion(child);
+    this.commitInsertion(insertion, before);
+    const destinationIsConnected = this[constants.IS_CONNECTED];
+    this.queueInsertionMutationRecords(insertion);
+    this.enqueueInsertionReactions(insertion, destinationIsConnected);
+    this.performOrCollectHookEffects(this.collectInsertionHookEffects(insertion), hookEffects);
+  }
+  performOrCollectHookEffects(effects, hookEffects$1) {
+    if (hookEffects$1) hookEffects$1.push(...effects);else hookEffects.performHookEffects(effects);
+  }
+  prepareInsertion(child) {
+    const roots = [];
+    if (child.nodeType === constants.NODE_TYPE_DOCUMENT_FRAGMENT) {
       let node = child[constants.CHILD];
       while (node) {
-        const next = node[constants.NEXT];
-        this.insertInto(node, before);
-        node = next;
+        roots.push(node);
+        node = node[constants.NEXT];
       }
-      return;
+    } else {
+      roots.push(child);
     }
-    if (child.parentNode !== null) {
-      child.parentNode.removeChild(child);
+    const destinationIsConnected = this[constants.IS_CONNECTED];
+    const ownerDocument = this[constants.OWNER_DOCUMENT];
+    const insertion = [];
+    for (const node of roots) {
+      const wasConnected = node[constants.IS_CONNECTED];
+      const shouldTraverse = wasConnected || destinationIsConnected;
+      let nodes;
+      let adoption;
+      if (node[constants.OWNER_DOCUMENT] === ownerDocument) {
+        if (shouldTraverse) nodes = shared.selfAndDescendants(node);
+      } else {
+        const snapshot = shared.collectAdoptionSnapshot(node);
+        adoption = snapshot.nodes;
+        if (shouldTraverse) nodes = snapshot.treeNodes;
+      }
+      insertion.push({
+        node,
+        nodes,
+        adoption,
+        shouldDisconnect: wasConnected
+      });
     }
-    if (before) {
-      if (before.parentNode !== this) {
-        throw Error('reference node is not a child of this parent');
+    return insertion;
+  }
+  commitInsertion(insertion, before) {
+    for (const prepared of insertion) {
+      const sourceParent = prepared.node[constants.PARENT];
+      if (sourceParent) {
+        const previousSibling = prepared.node[constants.PREV];
+        const nextSibling = prepared.node[constants.NEXT];
+        prepared.source = {
+          parent: sourceParent,
+          index: detachChild(sourceParent, prepared.node),
+          previousSibling,
+          nextSibling
+        };
       }
+    }
+    for (const prepared of insertion) {
+      const attached = this.attachChild(prepared.node, before);
+      prepared.insertIndex = attached.index;
+      prepared.previousSibling = attached.previousSibling;
+      prepared.nextSibling = attached.nextSibling;
+    }
+    const ownerDocument = this[constants.OWNER_DOCUMENT];
+    for (const {
+      adoption
+    } of insertion) {
+      if (adoption) shared.adoptNodes(adoption, ownerDocument);
+    }
+    const isConnected = this[constants.IS_CONNECTED];
+    for (const {
+      nodes
+    } of insertion) {
+      if (nodes) {
+        for (const node of nodes) node[constants.IS_CONNECTED] = isConnected;
+      }
+    }
+  }
+  attachChild(child, before) {
+    if (before) {
+      const previous = before[constants.PREV];
       child[constants.NEXT] = before;
-      child[constants.PREV] = before[constants.PREV];
-      if (before[constants.PREV] === null) this[constants.CHILD] = child;
+      child[constants.PREV] = previous;
+      if (previous) previous[constants.NEXT] = child;else this[constants.CHILD] = child;
       before[constants.PREV] = child;
     } else {
       child[constants.NEXT] = null;
@@ -112,40 +239,155 @@ class ParentNode extends ChildNode.ChildNode {
         child[constants.PREV] = null;
       }
     }
-    const ownerDocument = this[constants.OWNER_DOCUMENT];
-    const isElement = child.nodeType === constants.NodeType.ELEMENT_NODE;
+    const isElement = shared.isElementNode(child);
     child[constants.PARENT] = this;
-    child[constants.OWNER_DOCUMENT] = ownerDocument;
-    const childNodes = this.childNodes;
     let insertIndex;
     if (before) {
-      insertIndex = childNodes.indexOf(before);
-      childNodes.splice(insertIndex, 0, child);
+      insertIndex = this.childNodes.indexOf(before);
+      this.childNodes.splice(insertIndex, 0, child);
       if (isElement) {
-        const children = this.children;
-        let ref = before;
-        while (ref && ref.nodeType !== 1) ref = ref[constants.NEXT];
-        if (ref) {
-          children.splice(children.indexOf(ref), 0, child);
+        let reference = before;
+        while (reference && !shared.isElementNode(reference)) {
+          reference = reference[constants.NEXT];
+        }
+        if (reference) {
+          this.children.splice(this.children.indexOf(reference), 0, child);
         } else {
-          children.push(child);
+          this.children.push(child);
         }
       }
     } else {
-      insertIndex = childNodes.length;
-      childNodes.push(child);
+      insertIndex = this.childNodes.length;
+      this.childNodes.push(child);
       if (isElement) this.children.push(child);
     }
-    if (this[constants.IS_CONNECTED]) {
-      for (const node of shared.selfAndDescendants(child)) {
-        node[constants.IS_CONNECTED] = true;
-        node.connectedCallback?.();
+    return {
+      index: insertIndex,
+      previousSibling: child[constants.PREV],
+      nextSibling: child[constants.NEXT]
+    };
+  }
+  queueRemovalMutationRecord(parent, child, previousSibling, nextSibling) {
+    if (!MutationObserver.childListObserversActive) return;
+    MutationObserver.queueMutationRecord({
+      type: 'childList',
+      target: parent,
+      removedNodes: MutationObserver.mutationNodeList(child),
+      previousSibling,
+      nextSibling
+    });
+  }
+  queueInsertionMutationRecords(insertion) {
+    if (!MutationObserver.childListObserversActive) return;
+    for (const prepared of insertion) {
+      const {
+        node,
+        source
+      } = prepared;
+      if (source) {
+        this.queueRemovalMutationRecord(source.parent, node, source.previousSibling, source.nextSibling);
+      }
+      MutationObserver.queueMutationRecord({
+        type: 'childList',
+        target: this,
+        addedNodes: MutationObserver.mutationNodeList(node),
+        previousSibling: prepared.previousSibling,
+        nextSibling: prepared.nextSibling
+      });
+    }
+  }
+  collectRemovalHookEffects(child, childNodesIndex) {
+    if (this.nodeType !== constants.NODE_TYPE_ELEMENT || hookEffects.isCoveredByPendingPublication(this)) {
+      return [];
+    }
+    return [[() => this[constants.HOOKS].removeChild?.(this, child, childNodesIndex)]];
+  }
+  collectInsertionHookEffects(insertion) {
+    const effects = [];
+    for (const prepared of insertion) {
+      const {
+        node,
+        source
+      } = prepared;
+      if (source?.parent.nodeType === constants.NODE_TYPE_ELEMENT && !hookEffects.isCoveredByPendingPublication(source.parent)) {
+        effects.push([() => source.parent[constants.HOOKS].removeChild?.(source.parent, node, source.index)]);
+      }
+      if (this.nodeType === constants.NODE_TYPE_ELEMENT && !hookEffects.isCoveredByPendingPublication(this)) {
+        effects.push([() => this[constants.HOOKS].insertChild?.(this, node, prepared.insertIndex), node]);
+      }
+    }
+    return effects;
+  }
+  enqueueInsertionReactions(insertion, destinationIsConnected) {
+    for (const prepared of insertion) {
+      const {
+        nodes
+      } = prepared;
+      if (nodes) {
+        if (prepared.shouldDisconnect) {
+          this.enqueueTreeReactions(nodes, 'disconnectedCallback');
+        }
+        if (destinationIsConnected) {
+          this.enqueueTreeReactions(nodes, 'connectedCallback');
+        }
       }
     }
-    if (this.nodeType === constants.NodeType.ELEMENT_NODE) {
-      this[constants.HOOKS].insertChild?.(this, child, insertIndex);
+  }
+  enqueueTreeReactions(nodes, callbackName) {
+    enqueueTreeReactions(nodes, callbackName);
+  }
+}
+function removeChildForAdoption(parent, child, adoption, destination) {
+  if (child.parentNode !== parent) throw Error(`not a child of this node`);
+  const disconnectedNodes = parent[constants.IS_CONNECTED] ? adoption.treeNodes : undefined;
+  const previousSibling = child[constants.PREV];
+  const nextSibling = child[constants.NEXT];
+  const childNodesIndex = detachChild(parent, child);
+  if (disconnectedNodes) {
+    for (const node of disconnectedNodes) node[constants.IS_CONNECTED] = false;
+  }
+  shared.adoptNodes(adoption.nodes, destination);
+  if (MutationObserver.childListObserversActive) {
+    MutationObserver.queueMutationRecord({
+      type: 'childList',
+      target: parent,
+      removedNodes: MutationObserver.mutationNodeList(child),
+      previousSibling,
+      nextSibling
+    });
+  }
+  if (disconnectedNodes) {
+    enqueueTreeReactions(disconnectedNodes, 'disconnectedCallback');
+  }
+  const effects = [];
+  if (parent.nodeType === constants.NODE_TYPE_ELEMENT && !hookEffects.isCoveredByPendingPublication(parent)) {
+    effects.push([() => parent[constants.HOOKS].removeChild?.(parent, child, childNodesIndex)]);
+  }
+  hookEffects.performHookEffects(effects);
+}
+function detachChild(parent, child) {
+  const previous = child[constants.PREV];
+  const next = child[constants.NEXT];
+  if (previous) previous[constants.NEXT] = next;else parent[constants.CHILD] = next;
+  if (next) next[constants.PREV] = previous;
+  const childNodesIndex = parent.childNodes.indexOf(child);
+  parent.childNodes.splice(childNodesIndex, 1);
+  if (shared.isElementNode(child)) {
+    parent.children.splice(parent.children.indexOf(child), 1);
+  }
+  child[constants.PARENT] = null;
+  child[constants.NEXT] = null;
+  child[constants.PREV] = null;
+  return childNodesIndex;
+}
+function enqueueTreeReactions(nodes, callbackName) {
+  for (const node of nodes) {
+    const callback = node[callbackName];
+    if (typeof callback === 'function') {
+      customElementReactions.enqueueCustomElementReaction(node, () => callback.call(node));
     }
   }
 }
 
 exports.ParentNode = ParentNode;
+exports.removeChildForAdoption = removeChildForAdoption;

package/build/cjs/SVGElement.cjs

@@ -6,7 +6,7 @@ const constants = require('./constants.cjs');
 const Element = require('./Element.cjs');
 
 class SVGElement extends Element.Element {
-  [constants.NS] = (() => constants.NamespaceURI.SVG)();
+  [constants.NS] = constants.SVG_NAMESPACE;
   get ownerSVGElement() {
     let root = null;
     let parent = this.parentNode;

package/build/cjs/Text.cjs

@@ -6,7 +6,7 @@ const constants = require('./constants.cjs');
 const CharacterData = require('./CharacterData.cjs');
 
 class Text extends CharacterData.CharacterData {
-  nodeType = (() => constants.NodeType.TEXT_NODE)();
+  nodeType = constants.NODE_TYPE_TEXT;
   [constants.NAME] = '#text';
 }