@lwc/synthetic-shadow 2.6.2 → 2.6.3

package/dist/synthetic-shadow.js

@@ -194,7 +194,7 @@ const KEY__SYNTHETIC_MODE = '$$lwc-synthetic-mode';
 
 
 const hasNativeSymbolSupport = /*@__PURE__*/(() => Symbol('x').toString() === 'Symbol(x)')();
-/** version: 2.6.2 */
+/** version: 2.6.3 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -301,6 +301,7 @@ const {
   getElementsByClassName: getElementsByClassName$1
 } = HTMLElement.prototype;
 const shadowRootGetter = hasOwnProperty.call(Element.prototype, 'shadowRoot') ? getOwnPropertyDescriptor(Element.prototype, 'shadowRoot').get : () => null;
+const assignedSlotGetter$1 = hasOwnProperty.call(Element.prototype, 'assignedSlot') ? getOwnPropertyDescriptor(Element.prototype, 'assignedSlot').get : () => null;
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -899,6 +900,14 @@ function getNodeKey(node) {
 function isNodeShadowed(node) {
   return !isUndefined(getNodeOwnerKey(node));
 }
+/**
+ * Returns true if this node is a shadow host, is in a shadow host, or contains a shadow host
+ * anywhere in its tree.
+ */
+
+function isNodeOrDescendantsShadowed(node) {
+  return isNodeShadowed(node) || isSyntheticShadowHost(node) || containsHost(node);
+}
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -1523,7 +1532,7 @@ if (!_globalThis.lwcRuntimeFlags) {
 }
 
 const runtimeFlags = _globalThis.lwcRuntimeFlags;
-/** version: 2.6.2 */
+/** version: 2.6.3 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -1616,7 +1625,9 @@ function parentElementGetterPatched() {
 }
 
 function compareDocumentPositionPatched(otherNode) {
-  if (this.getRootNode() === otherNode) {
+  if (this === otherNode) {
+    return 0;
+  } else if (this.getRootNode() === otherNode) {
     // "this" is in a shadow tree where the shadow root is the "otherNode".
     return 10; // Node.DOCUMENT_POSITION_CONTAINS | Node.DOCUMENT_POSITION_PRECEDING
   } else if (getNodeOwnerKey(this) !== getNodeOwnerKey(otherNode)) {
@@ -1662,7 +1673,7 @@ function cloneNodePatched(deep) {
 function childNodesGetterPatched() {
   if (isSyntheticShadowHost(this)) {
     const owner = getNodeOwner(this);
-    const childNodes = isNull(owner) ? [] : getAllMatches(owner, getFilteredChildNodes(this));
+    const childNodes = isNull(owner) ? getFilteredChildNodes(this) : getAllMatches(owner, getFilteredChildNodes(this));
 
     if (process.env.NODE_ENV !== 'production' && isFalse(hasNativeSymbolSupport) && isExternalChildNodeAccessorFlagOn()) {
       // inserting a comment node as the first childNode to trick the IE11
@@ -1773,7 +1784,8 @@ defineProperties(_Node.prototype, {
   textContent: {
     get() {
       if (!runtimeFlags.ENABLE_NODE_PATCH) {
-        if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
+        // See note on get innerHTML in faux-shadow/element.ts
+        if (isNodeOrDescendantsShadowed(this)) {
           return textContentGetterPatched.call(this);
         }
 
@@ -2007,7 +2019,22 @@ function getAllRootNodes(node) {
   }
 
   return rootNodes;
-}
+} // Keep searching up the host tree until we find an element that is within the immediate shadow root
+
+
+const findAncestorHostInImmediateShadowRoot = (rootNode, targetRootNode) => {
+  let host;
+
+  while (!isUndefined(host = rootNode.host)) {
+    const thisRootNode = host.getRootNode();
+
+    if (thisRootNode === targetRootNode) {
+      return host;
+    }
+
+    rootNode = thisRootNode;
+  }
+};
 
 function fauxElementsFromPoint(context, doc, left, top) {
   const elements = elementsFromPoint.call(doc, left, top);
@@ -2021,8 +2048,28 @@ function fauxElementsFromPoint(context, doc, left, top) {
     for (let i = 0; i < elements.length; i++) {
       const element = elements[i];
 
-      if (rootNodes.indexOf(element.getRootNode()) !== -1 && !isSyntheticSlotElement(element)) {
-        result.push(element);
+      if (isSyntheticSlotElement(element)) {
+        continue;
+      }
+
+      const elementRootNode = element.getRootNode();
+
+      if (ArrayIndexOf.call(rootNodes, elementRootNode) !== -1) {
+        ArrayPush.call(result, element);
+        continue;
+      } // In cases where the host element is not visible but its shadow descendants are, then
+      // we may get the shadow descendant instead of the host element here. (The
+      // browser doesn't know the difference in synthetic shadow DOM.)
+      // In native shadow DOM, however, elementsFromPoint would return the host but not
+      // the child. So we need to detect if this shadow element's host is accessible from
+      // the context's shadow root. Note we also need to be careful not to add the host
+      // multiple times.
+
+
+      const ancestorHost = findAncestorHostInImmediateShadowRoot(elementRootNode, rootNodes[0]);
+
+      if (!isUndefined(ancestorHost) && ArrayIndexOf.call(elements, ancestorHost) === -1 && ArrayIndexOf.call(result, ancestorHost) === -1) {
+        ArrayPush.call(result, ancestorHost);
       }
     }
   }
@@ -2096,6 +2143,28 @@ function isSyntheticShadowHost(node) {
 function isSyntheticShadowRoot(node) {
   const shadowRootRecord = InternalSlot.get(node);
   return !isUndefined(shadowRootRecord) && node === shadowRootRecord.shadowRoot;
+} // Return true if any descendant is a host element
+
+function containsHost(node) {
+  // IE11 complains with "Unexpected call to method or property access." when calling walker.nextNode().
+  // The fix for this is to only walk trees for nodes that are Node.ELEMENT_NODE.
+  if (node.nodeType !== _Node.ELEMENT_NODE) {
+    return false;
+  } // IE requires all four arguments, even though the fourth is deprecated
+  // https://developer.mozilla.org/en-US/docs/Web/API/Document/createTreeWalker#browser_compatibility
+  // @ts-ignore
+
+
+  const walker = document.createTreeWalker(node, NodeFilter.SHOW_ELEMENT, null, false);
+  let descendant;
+
+  while (!isNull(descendant = walker.nextNode())) {
+    if (isSyntheticShadowHost(descendant)) {
+      return true;
+    }
+  }
+
+  return false;
 }
 let uid = 0;
 function attachShadow(elm, options) {
@@ -2143,6 +2212,12 @@ const SyntheticShadowRootDescriptors = {
       return `[object ShadowRoot]`;
     }
 
+  },
+  synthetic: {
+    writable: false,
+    enumerable: false,
+    configurable: false,
+    value: true
   }
 };
 const ShadowRootDescriptors = {
@@ -3971,6 +4046,14 @@ retargetRelatedTarget(FocusEvent);
  */
 retargetRelatedTarget(MouseEvent);
 
+/*
+ * Copyright (c) 2021, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: MIT
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
+ */
+const assignedSlotGetter = hasOwnProperty.call(Text.prototype, 'assignedSlot') ? getOwnPropertyDescriptor(Text.prototype, 'assignedSlot').get : () => null;
+
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -4024,10 +4107,22 @@ function getFilteredSlotFlattenNodes(slot) {
 }
 
 function assignedSlotGetterPatched() {
-  const parentNode = parentNodeGetter.call(this);
+  const parentNode = parentNodeGetter.call(this); // use original assignedSlot if parent has a native shdow root
+
+  if (parentNode instanceof Element) {
+    const sr = shadowRootGetter.call(parentNode);
+
+    if (isInstanceOfNativeShadowRoot(sr)) {
+      if (this instanceof Text) {
+        return assignedSlotGetter.call(this);
+      }
+
+      return assignedSlotGetter$1.call(this);
+    }
+  }
   /**
    * The node is assigned to a slot if:
-   *  - it has a parent and it parent its parent is a slot element
+   *  - it has a parent and its parent is a slot element
    *  - and if the slot owner key is different than the node owner key.
    *
    * When the slot and the slotted node are 2 different shadow trees, the owner keys will be
@@ -4036,6 +4131,7 @@ function assignedSlotGetterPatched() {
    * different than the node owner key (always `undefined`).
    */
 
+
   if (!isNull(parentNode) && isSlotElement(parentNode) && getNodeOwnerKey(parentNode) !== getNodeOwnerKey(this)) {
     return parentNode;
   }
@@ -4252,7 +4348,10 @@ defineProperties(Element.prototype, {
   innerHTML: {
     get() {
       if (!runtimeFlags.ENABLE_ELEMENT_PATCH) {
-        if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
+        // If this element is in synthetic shadow, if it's a synthetic shadow host,
+        // or if any of its descendants are synthetic shadow hosts, then we can't
+        // use the native innerHTML because it would expose private node internals.
+        if (isNodeOrDescendantsShadowed(this)) {
           return innerHTMLGetterPatched.call(this);
         }
 
@@ -4277,7 +4376,8 @@ defineProperties(Element.prototype, {
   outerHTML: {
     get() {
       if (!runtimeFlags.ENABLE_ELEMENT_PATCH) {
-        if (isNodeShadowed(this) || isSyntheticShadowHost(this)) {
+        // See notes above on get innerHTML
+        if (isNodeOrDescendantsShadowed(this)) {
           return outerHTMLGetterPatched.call(this);
         }
 
@@ -5650,4 +5750,4 @@ defineProperty(Element.prototype, '$domManual$', {
 
   configurable: true
 });
-/** version: 2.6.2 */
+/** version: 2.6.3 */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lwc/synthetic-shadow",
-    "version": "2.6.2",
+    "version": "2.6.3",
     "description": "Synthetic Shadow Root for LWC",
     "homepage": "https://lwc.dev/",
     "repository": {
@@ -36,8 +36,8 @@
         "access": "public"
     },
     "devDependencies": {
-        "@lwc/features": "2.6.2",
-        "@lwc/shared": "2.6.2"
+        "@lwc/features": "2.6.3",
+        "@lwc/shared": "2.6.3"
     },
-    "gitHead": "a49666f207d17e164aa914cf00b8f9d5a656228d"
+    "gitHead": "1fdd835243eed190b8ab9ca61ae7eae9f9a4073d"
 }