@lwc/synthetic-shadow 2.37.0 → 2.37.1

package/dist/synthetic-shadow.js

@@ -120,7 +120,16 @@ const KEY__NATIVE_QUERY_SELECTOR_ALL = '$nativeQuerySelectorAll$';
 // We use this to detect symbol support in order to avoid the expensive symbol polyfill. Note that
 // we can't use typeof since it will fail when transpiling.
 const hasNativeSymbolSupport = /*@__PURE__*/ (() => Symbol('x').toString() === 'Symbol(x)')();
-/** version: 2.37.0 */
+/** version: 2.37.1 */
+
+/**
+ * Copyright (C) 2018 salesforce.com, inc.
+ */
+// eslint-disable-next-line no-restricted-properties
+if (!_globalThis.lwcRuntimeFlags) {
+    Object.defineProperty(_globalThis, 'lwcRuntimeFlags', { value: create(null) });
+}
+/** version: 2.37.1 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -428,15 +437,6 @@ function arrayFromCollection(collection) {
 const eventTargetPrototype = typeof EventTarget !== 'undefined' ? EventTarget.prototype : _Node.prototype;
 const { addEventListener, dispatchEvent, removeEventListener } = eventTargetPrototype;
 
-/**
- * Copyright (C) 2018 salesforce.com, inc.
- */
-if (!_globalThis.lwcRuntimeFlags) {
-    Object.defineProperty(_globalThis, 'lwcRuntimeFlags', { value: create(null) });
-}
-const lwcRuntimeFlags = _globalThis.lwcRuntimeFlags;
-/** version: 2.37.0 */
-
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -447,52 +447,46 @@ const lwcRuntimeFlags = _globalThis.lwcRuntimeFlags;
 const HostElementKey = '$$HostElementKey$$';
 const ShadowedNodeKey = '$$ShadowedNodeKey$$';
 function fastDefineProperty(node, propName, config) {
-  const shadowedNode = node;
-  if (process.env.NODE_ENV !== 'production') {
-    // in dev, we are more restrictive
-    defineProperty(shadowedNode, propName, config);
-  } else {
-    const {
-      value
-    } = config;
-    // in prod, we prioritize performance
-    shadowedNode[propName] = value;
-  }
+    const shadowedNode = node;
+    if (process.env.NODE_ENV !== 'production') {
+        // in dev, we are more restrictive
+        defineProperty(shadowedNode, propName, config);
+    }
+    else {
+        const { value } = config;
+        // in prod, we prioritize performance
+        shadowedNode[propName] = value;
+    }
 }
 function setNodeOwnerKey(node, value) {
-  fastDefineProperty(node, HostElementKey, {
-    value,
-    configurable: true
-  });
+    fastDefineProperty(node, HostElementKey, { value, configurable: true });
 }
 function setNodeKey(node, value) {
-  fastDefineProperty(node, ShadowedNodeKey, {
-    value
-  });
+    fastDefineProperty(node, ShadowedNodeKey, { value });
 }
 function getNodeOwnerKey(node) {
-  return node[HostElementKey];
+    return node[HostElementKey];
 }
 function getNodeNearestOwnerKey(node) {
-  let host = node;
-  let hostKey;
-  // search for the first element with owner identity
-  // in case of manually inserted elements and elements slotted from Light DOM
-  while (!isNull(host)) {
-    hostKey = getNodeOwnerKey(host);
-    if (!isUndefined(hostKey)) {
-      return hostKey;
-    }
-    host = parentNodeGetter.call(host);
-    if (lwcRuntimeFlags.ENABLE_LIGHT_GET_ROOT_NODE_PATCH) {
-      if (!isNull(host) && isSyntheticSlotElement(host)) {
-        return undefined;
-      }
-    }
-  }
+    let host = node;
+    let hostKey;
+    // search for the first element with owner identity
+    // in case of manually inserted elements and elements slotted from Light DOM
+    while (!isNull(host)) {
+        hostKey = getNodeOwnerKey(host);
+        if (!isUndefined(hostKey)) {
+            return hostKey;
+        }
+        host = parentNodeGetter.call(host);
+        if (lwcRuntimeFlags.ENABLE_LIGHT_GET_ROOT_NODE_PATCH &&
+            !isNull(host) &&
+            isSyntheticSlotElement(host)) {
+            return undefined;
+        }
+    }
 }
 function getNodeKey(node) {
-  return node[ShadowedNodeKey];
+    return node[ShadowedNodeKey];
 }
 /**
  * This function does not traverse up for performance reasons, but is sufficient for most use
@@ -500,7 +494,7 @@ function getNodeKey(node) {
  * isNodeDeepShadowed instead.
  */
 function isNodeShadowed(node) {
-  return !isUndefined(getNodeOwnerKey(node));
+    return !isUndefined(getNodeOwnerKey(node));
 }
 
 /*
@@ -512,203 +506,209 @@ function isNodeShadowed(node) {
 // when finding a slot in the DOM, we can fold it if it is contained
 // inside another slot.
 function foldSlotElement(slot) {
-  let parent = parentElementGetter.call(slot);
-  while (!isNull(parent) && isSlotElement(parent)) {
-    slot = parent;
-    parent = parentElementGetter.call(slot);
-  }
-  return slot;
+    let parent = parentElementGetter.call(slot);
+    while (!isNull(parent) && isSlotElement(parent)) {
+        slot = parent;
+        parent = parentElementGetter.call(slot);
+    }
+    return slot;
 }
 function isNodeSlotted(host, node) {
-  if (process.env.NODE_ENV !== 'production') {
-    assert.invariant(host instanceof HTMLElement, `isNodeSlotted() should be called with a host as the first argument instead of ${host}`);
-    assert.invariant(node instanceof _Node, `isNodeSlotted() should be called with a node as the second argument instead of ${node}`);
-    assert.invariant(compareDocumentPosition.call(node, host) & DOCUMENT_POSITION_CONTAINS, `isNodeSlotted() should never be called with a node that is not a child node of ${host}`);
-  }
-  const hostKey = getNodeKey(host);
-  // this routine assumes that the node is coming from a different shadow (it is not owned by the host)
-  // just in case the provided node is not an element
-  let currentElement = node instanceof Element ? node : parentElementGetter.call(node);
-  while (!isNull(currentElement) && currentElement !== host) {
-    const elmOwnerKey = getNodeNearestOwnerKey(currentElement);
-    const parent = parentElementGetter.call(currentElement);
-    if (elmOwnerKey === hostKey) {
-      // we have reached an element inside the host's template, and only if
-      // that element is an slot, then the node is considered slotted
-      return isSlotElement(currentElement);
-    } else if (parent === host) {
-      return false;
-    } else if (!isNull(parent) && getNodeNearestOwnerKey(parent) !== elmOwnerKey) {
-      // we are crossing a boundary of some sort since the elm and its parent
-      // have different owner key. for slotted elements, this is possible
-      // if the parent happens to be a slot.
-      if (isSlotElement(parent)) {
-        /**
-         * the slot parent might be allocated inside another slot, think of:
-         * <x-root> (<--- root element)
-         *    <x-parent> (<--- own by x-root)
-         *       <x-child> (<--- own by x-root)
-         *           <slot> (<--- own by x-child)
-         *               <slot> (<--- own by x-parent)
-         *                  <div> (<--- own by x-root)
-         *
-         * while checking if x-parent has the div slotted, we need to traverse
-         * up, but when finding the first slot, we skip that one in favor of the
-         * most outer slot parent before jumping into its corresponding host.
-         */
-        currentElement = getNodeOwner(foldSlotElement(parent));
-        if (!isNull(currentElement)) {
-          if (currentElement === host) {
-            // the slot element is a top level element inside the shadow
-            // of a host that was allocated into host in question
-            return true;
-          } else if (getNodeNearestOwnerKey(currentElement) === hostKey) {
-            // the slot element is an element inside the shadow
-            // of a host that was allocated into host in question
-            return true;
-          }
+    if (process.env.NODE_ENV !== 'production') {
+        assert.invariant(host instanceof HTMLElement, `isNodeSlotted() should be called with a host as the first argument instead of ${host}`);
+        assert.invariant(node instanceof _Node, `isNodeSlotted() should be called with a node as the second argument instead of ${node}`);
+        assert.invariant(compareDocumentPosition.call(node, host) & DOCUMENT_POSITION_CONTAINS, `isNodeSlotted() should never be called with a node that is not a child node of ${host}`);
+    }
+    const hostKey = getNodeKey(host);
+    // this routine assumes that the node is coming from a different shadow (it is not owned by the host)
+    // just in case the provided node is not an element
+    let currentElement = node instanceof Element ? node : parentElementGetter.call(node);
+    while (!isNull(currentElement) && currentElement !== host) {
+        const elmOwnerKey = getNodeNearestOwnerKey(currentElement);
+        const parent = parentElementGetter.call(currentElement);
+        if (elmOwnerKey === hostKey) {
+            // we have reached an element inside the host's template, and only if
+            // that element is an slot, then the node is considered slotted
+            return isSlotElement(currentElement);
+        }
+        else if (parent === host) {
+            return false;
+        }
+        else if (!isNull(parent) && getNodeNearestOwnerKey(parent) !== elmOwnerKey) {
+            // we are crossing a boundary of some sort since the elm and its parent
+            // have different owner key. for slotted elements, this is possible
+            // if the parent happens to be a slot.
+            if (isSlotElement(parent)) {
+                /**
+                 * the slot parent might be allocated inside another slot, think of:
+                 * <x-root> (<--- root element)
+                 *    <x-parent> (<--- own by x-root)
+                 *       <x-child> (<--- own by x-root)
+                 *           <slot> (<--- own by x-child)
+                 *               <slot> (<--- own by x-parent)
+                 *                  <div> (<--- own by x-root)
+                 *
+                 * while checking if x-parent has the div slotted, we need to traverse
+                 * up, but when finding the first slot, we skip that one in favor of the
+                 * most outer slot parent before jumping into its corresponding host.
+                 */
+                currentElement = getNodeOwner(foldSlotElement(parent));
+                if (!isNull(currentElement)) {
+                    if (currentElement === host) {
+                        // the slot element is a top level element inside the shadow
+                        // of a host that was allocated into host in question
+                        return true;
+                    }
+                    else if (getNodeNearestOwnerKey(currentElement) === hostKey) {
+                        // the slot element is an element inside the shadow
+                        // of a host that was allocated into host in question
+                        return true;
+                    }
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            currentElement = parent;
         }
-      } else {
-        return false;
-      }
-    } else {
-      currentElement = parent;
     }
-  }
-  return false;
+    return false;
 }
 function getNodeOwner(node) {
-  if (!(node instanceof _Node)) {
-    return null;
-  }
-  const ownerKey = getNodeNearestOwnerKey(node);
-  if (isUndefined(ownerKey)) {
-    return null;
-  }
-  let nodeOwner = node;
-  // At this point, node is a valid node with owner identity, now we need to find the owner node
-  // search for a custom element with a VM that owns the first element with owner identity attached to it
-  while (!isNull(nodeOwner) && getNodeKey(nodeOwner) !== ownerKey) {
-    nodeOwner = parentNodeGetter.call(nodeOwner);
-  }
-  if (isNull(nodeOwner)) {
-    return null;
-  }
-  return nodeOwner;
+    if (!(node instanceof _Node)) {
+        return null;
+    }
+    const ownerKey = getNodeNearestOwnerKey(node);
+    if (isUndefined(ownerKey)) {
+        return null;
+    }
+    let nodeOwner = node;
+    // At this point, node is a valid node with owner identity, now we need to find the owner node
+    // search for a custom element with a VM that owns the first element with owner identity attached to it
+    while (!isNull(nodeOwner) && getNodeKey(nodeOwner) !== ownerKey) {
+        nodeOwner = parentNodeGetter.call(nodeOwner);
+    }
+    if (isNull(nodeOwner)) {
+        return null;
+    }
+    return nodeOwner;
 }
 function isSyntheticSlotElement(node) {
-  return isSlotElement(node) && isNodeShadowed(node);
+    return isSlotElement(node) && isNodeShadowed(node);
 }
 function isSlotElement(node) {
-  return node instanceof HTMLSlotElement;
+    return node instanceof HTMLSlotElement;
 }
 function isNodeOwnedBy(owner, node) {
-  if (process.env.NODE_ENV !== 'production') {
-    assert.invariant(owner instanceof HTMLElement, `isNodeOwnedBy() should be called with an element as the first argument instead of ${owner}`);
-    assert.invariant(node instanceof _Node, `isNodeOwnedBy() should be called with a node as the second argument instead of ${node}`);
-    assert.invariant(compareDocumentPosition.call(node, owner) & DOCUMENT_POSITION_CONTAINS, `isNodeOwnedBy() should never be called with a node that is not a child node of ${owner}`);
-  }
-  const ownerKey = getNodeNearestOwnerKey(node);
-  if (isUndefined(ownerKey)) {
-    if (lwcRuntimeFlags.ENABLE_LIGHT_GET_ROOT_NODE_PATCH) {
-      // in case of root level light DOM element slotting into a synthetic shadow
-      const host = parentNodeGetter.call(node);
-      if (!isNull(host) && isSyntheticSlotElement(host)) {
-        return false;
-      }
+    if (process.env.NODE_ENV !== 'production') {
+        assert.invariant(owner instanceof HTMLElement, `isNodeOwnedBy() should be called with an element as the first argument instead of ${owner}`);
+        assert.invariant(node instanceof _Node, `isNodeOwnedBy() should be called with a node as the second argument instead of ${node}`);
+        assert.invariant(compareDocumentPosition.call(node, owner) & DOCUMENT_POSITION_CONTAINS, `isNodeOwnedBy() should never be called with a node that is not a child node of ${owner}`);
+    }
+    const ownerKey = getNodeNearestOwnerKey(node);
+    if (isUndefined(ownerKey)) {
+        if (lwcRuntimeFlags.ENABLE_LIGHT_GET_ROOT_NODE_PATCH) {
+            // in case of root level light DOM element slotting into a synthetic shadow
+            const host = parentNodeGetter.call(node);
+            if (!isNull(host) && isSyntheticSlotElement(host)) {
+                return false;
+            }
+        }
+        // in case of manually inserted elements
+        return true;
     }
-    // in case of manually inserted elements
-    return true;
-  }
-  return getNodeKey(owner) === ownerKey;
+    return getNodeKey(owner) === ownerKey;
 }
 function shadowRootChildNodes(root) {
-  const elm = getHost(root);
-  return getAllMatches(elm, arrayFromCollection(childNodesGetter.call(elm)));
+    const elm = getHost(root);
+    return getAllMatches(elm, arrayFromCollection(childNodesGetter.call(elm)));
 }
 function getAllSlottedMatches(host, nodeList) {
-  const filteredAndPatched = [];
-  for (let i = 0, len = nodeList.length; i < len; i += 1) {
-    const node = nodeList[i];
-    if (!isNodeOwnedBy(host, node) && isNodeSlotted(host, node)) {
-      ArrayPush.call(filteredAndPatched, node);
+    const filteredAndPatched = [];
+    for (let i = 0, len = nodeList.length; i < len; i += 1) {
+        const node = nodeList[i];
+        if (!isNodeOwnedBy(host, node) && isNodeSlotted(host, node)) {
+            ArrayPush.call(filteredAndPatched, node);
+        }
     }
-  }
-  return filteredAndPatched;
+    return filteredAndPatched;
 }
 function getFirstSlottedMatch(host, nodeList) {
-  for (let i = 0, len = nodeList.length; i < len; i += 1) {
-    const node = nodeList[i];
-    if (!isNodeOwnedBy(host, node) && isNodeSlotted(host, node)) {
-      return node;
+    for (let i = 0, len = nodeList.length; i < len; i += 1) {
+        const node = nodeList[i];
+        if (!isNodeOwnedBy(host, node) && isNodeSlotted(host, node)) {
+            return node;
+        }
     }
-  }
-  return null;
+    return null;
 }
 function getAllMatches(owner, nodeList) {
-  const filteredAndPatched = [];
-  for (let i = 0, len = nodeList.length; i < len; i += 1) {
-    const node = nodeList[i];
-    const isOwned = isNodeOwnedBy(owner, node);
-    if (isOwned) {
-      // Patch querySelector, querySelectorAll, etc
-      // if element is owned by VM
-      ArrayPush.call(filteredAndPatched, node);
-    }
-  }
-  return filteredAndPatched;
+    const filteredAndPatched = [];
+    for (let i = 0, len = nodeList.length; i < len; i += 1) {
+        const node = nodeList[i];
+        const isOwned = isNodeOwnedBy(owner, node);
+        if (isOwned) {
+            // Patch querySelector, querySelectorAll, etc
+            // if element is owned by VM
+            ArrayPush.call(filteredAndPatched, node);
+        }
+    }
+    return filteredAndPatched;
 }
 function getFirstMatch(owner, nodeList) {
-  for (let i = 0, len = nodeList.length; i < len; i += 1) {
-    if (isNodeOwnedBy(owner, nodeList[i])) {
-      return nodeList[i];
+    for (let i = 0, len = nodeList.length; i < len; i += 1) {
+        if (isNodeOwnedBy(owner, nodeList[i])) {
+            return nodeList[i];
+        }
     }
-  }
-  return null;
+    return null;
 }
 function shadowRootQuerySelector(root, selector) {
-  const elm = getHost(root);
-  const nodeList = arrayFromCollection(querySelectorAll$1.call(elm, selector));
-  return getFirstMatch(elm, nodeList);
+    const elm = getHost(root);
+    const nodeList = arrayFromCollection(querySelectorAll$1.call(elm, selector));
+    return getFirstMatch(elm, nodeList);
 }
 function shadowRootQuerySelectorAll(root, selector) {
-  const elm = getHost(root);
-  const nodeList = querySelectorAll$1.call(elm, selector);
-  return getAllMatches(elm, arrayFromCollection(nodeList));
+    const elm = getHost(root);
+    const nodeList = querySelectorAll$1.call(elm, selector);
+    return getAllMatches(elm, arrayFromCollection(nodeList));
 }
 function getFilteredChildNodes(node) {
-  if (!isSyntheticShadowHost(node) && !isSlotElement(node)) {
-    // regular element - fast path
-    const children = childNodesGetter.call(node);
-    return arrayFromCollection(children);
-  }
-  if (isSyntheticShadowHost(node)) {
-    // we need to get only the nodes that were slotted
-    const slots = arrayFromCollection(querySelectorAll$1.call(node, 'slot'));
-    const resolver = getShadowRootResolver(getShadowRoot(node));
-    // Typescript is inferring the wrong function type for this particular
-    // overloaded method: https://github.com/Microsoft/TypeScript/issues/27972
-    // @ts-ignore type-mismatch
-    return ArrayReduce.call(slots, (seed, slot) => {
-      if (resolver === getShadowRootResolver(slot)) {
-        ArrayPush.apply(seed, getFilteredSlotAssignedNodes(slot));
-      }
-      return seed;
-    }, []);
-  } else {
-    // slot element
-    const children = arrayFromCollection(childNodesGetter.call(node));
-    const resolver = getShadowRootResolver(node);
-    return ArrayFilter.call(children, child => resolver === getShadowRootResolver(child));
-  }
+    if (!isSyntheticShadowHost(node) && !isSlotElement(node)) {
+        // regular element - fast path
+        const children = childNodesGetter.call(node);
+        return arrayFromCollection(children);
+    }
+    if (isSyntheticShadowHost(node)) {
+        // we need to get only the nodes that were slotted
+        const slots = arrayFromCollection(querySelectorAll$1.call(node, 'slot'));
+        const resolver = getShadowRootResolver(getShadowRoot(node));
+        // Typescript is inferring the wrong function type for this particular
+        // overloaded method: https://github.com/Microsoft/TypeScript/issues/27972
+        // @ts-ignore type-mismatch
+        return ArrayReduce.call(slots, (seed, slot) => {
+            if (resolver === getShadowRootResolver(slot)) {
+                ArrayPush.apply(seed, getFilteredSlotAssignedNodes(slot));
+            }
+            return seed;
+        }, []);
+    }
+    else {
+        // slot element
+        const children = arrayFromCollection(childNodesGetter.call(node));
+        const resolver = getShadowRootResolver(node);
+        return ArrayFilter.call(children, (child) => resolver === getShadowRootResolver(child));
+    }
 }
 function getFilteredSlotAssignedNodes(slot) {
-  const owner = getNodeOwner(slot);
-  if (isNull(owner)) {
-    return [];
-  }
-  const childNodes = arrayFromCollection(childNodesGetter.call(slot));
-  return ArrayFilter.call(childNodes, child => !isNodeShadowed(child) || !isNodeOwnedBy(owner, child));
+    const owner = getNodeOwner(slot);
+    if (isNull(owner)) {
+        return [];
+    }
+    const childNodes = arrayFromCollection(childNodesGetter.call(slot));
+    return ArrayFilter.call(childNodes, (child) => !isNodeShadowed(child) || !isNodeOwnedBy(owner, child));
 }
 
 /*
@@ -4674,26 +4674,4 @@ defineProperty(Element.prototype, '$domManual$', {
     },
     configurable: true,
 });
-
-/*
- * Copyright (c) 2018, 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
- */
-// Only used in LWC's Karma tests
-if (process.env.NODE_ENV === 'test-karma-lwc') {
-  window.addEventListener('test-dummy-flag', () => {
-    let hasFlag = false;
-    if (lwcRuntimeFlags.DUMMY_TEST_FLAG) {
-      hasFlag = true;
-    }
-    window.dispatchEvent(new CustomEvent('has-dummy-flag', {
-      detail: {
-        package: '@lwc/synthetic-shadow',
-        hasFlag
-      }
-    }));
-  });
-}
-/** version: 2.37.0 */
+/** version: 2.37.1 */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lwc/synthetic-shadow",
-    "version": "2.37.0",
+    "version": "2.37.1",
     "description": "Synthetic Shadow Root for LWC",
     "homepage": "https://lwc.dev/",
     "repository": {
@@ -36,8 +36,8 @@
         "access": "public"
     },
     "devDependencies": {
-        "@lwc/features": "2.37.0",
-        "@lwc/shared": "2.37.0"
+        "@lwc/features": "2.37.1",
+        "@lwc/shared": "2.37.1"
     },
     "nx": {
         "targets": {