lwc 2.27.0 → 2.28.1

package/dist/engine-dom/esm/es2017/engine-dom.js

@@ -43,7 +43,7 @@ var assert = /*#__PURE__*/Object.freeze({
  */
 const { assign, create, defineProperties, defineProperty, freeze, getOwnPropertyDescriptor: getOwnPropertyDescriptor$1, getOwnPropertyNames: getOwnPropertyNames$1, getPrototypeOf: getPrototypeOf$1, hasOwnProperty: hasOwnProperty$1, isFrozen, keys, seal, setPrototypeOf, } = Object;
 const { isArray: isArray$1 } = Array;
-const { concat: ArrayConcat$1, copyWithin: ArrayCopyWithin, fill: ArrayFill, filter: ArrayFilter, find: ArrayFind, indexOf: ArrayIndexOf, join: ArrayJoin, map: ArrayMap, pop: ArrayPop, push: ArrayPush$1, reduce: ArrayReduce, reverse: ArrayReverse, shift: ArrayShift, slice: ArraySlice, sort: ArraySort, splice: ArraySplice, unshift: ArrayUnshift, forEach, } = Array.prototype;
+const { concat: ArrayConcat$1, copyWithin: ArrayCopyWithin, fill: ArrayFill, filter: ArrayFilter, find: ArrayFind, indexOf: ArrayIndexOf, join: ArrayJoin, map: ArrayMap, pop: ArrayPop, push: ArrayPush$1, reduce: ArrayReduce, reverse: ArrayReverse, shift: ArrayShift, slice: ArraySlice, some: ArraySome, sort: ArraySort, splice: ArraySplice, unshift: ArrayUnshift, forEach, } = Array.prototype;
 const { fromCharCode: StringFromCharCode } = String;
 const { charCodeAt: StringCharCodeAt, replace: StringReplace, slice: StringSlice, toLowerCase: StringToLowerCase, } = String.prototype;
 function isUndefined$1(obj) {
@@ -299,9 +299,9 @@ function htmlPropertyToAttribute(propName) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 // Increment whenever the LWC template compiler changes
-const LWC_VERSION = "2.27.0";
+const LWC_VERSION = "2.28.1";
 const LWC_VERSION_COMMENT_REGEX = /\/\*LWC compiler v([\d.]+)\*\/\s*}/;
-/** version: 2.27.0 */
+/** version: 2.28.1 */
 
 /**
  * Copyright (C) 2018 salesforce.com, inc.
@@ -383,7 +383,7 @@ for (let i = 0, len = ElementPrototypeAriaPropertyNames.length; i < len; i += 1)
         patch$1(propName);
     }
 }
-/** version: 2.27.0 */
+/** version: 2.28.1 */
 
 /**
  * Copyright (C) 2018 salesforce.com, inc.
@@ -463,7 +463,7 @@ function setFeatureFlagForTest(name, value) {
         setFeatureFlag(name, value);
     }
 }
-/** version: 2.27.0 */
+/** version: 2.28.1 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -3686,6 +3686,9 @@ function isSameVnode(vnode1, vnode2) {
 function isVCustomElement(vnode) {
     return vnode.type === 3 /* VNodeType.CustomElement */;
 }
+function isVFragment(vnode) {
+    return vnode.type === 5 /* VNodeType.Fragment */;
+}
 function isVScopedSlotFragment(vnode) {
     return vnode.type === 6 /* VNodeType.ScopedSlotFragment */;
 }
@@ -4213,9 +4216,14 @@ function mountCustomElement(vnode, parent, anchor, renderer) {
     if (lwcRuntimeFlags.ENABLE_NATIVE_CUSTOM_ELEMENT_LIFECYCLE) {
       disconnectRootElement(elm);
     }
-  };
+  }; // Should never get a tag with upper case letter at this point; the compiler
+  // should produce only tags with lowercase letters. However, the Java
+  // compiler may generate tagnames with uppercase letters so - for backwards
+  // compatibility, we lower case the tagname here.
 
-  const elm = createCustomElement(sel, upgradeCallback, connectedCallback, disconnectedCallback);
+
+  const normalizedTagname = sel.toLowerCase();
+  const elm = createCustomElement(normalizedTagname, upgradeCallback, connectedCallback, disconnectedCallback);
   vnode.elm = elm;
   vnode.vm = vm;
   linkNodeToShadow(elm, owner, renderer);
@@ -4517,6 +4525,17 @@ function allocateChildren(vnode, vm) {
     shadowMode
   } = vm;
 
+  if (process.env.NODE_ENV !== 'production') {
+    // If any of the children being allocated is a scoped slot fragment, make sure the receiving
+    // component is a light DOM component. This is mainly to validate light dom parent running
+    // in native shadow mode.
+    if (renderMode !== 0
+    /* RenderMode.Light */
+    && ArraySome.call(children, child => !isNull(child) && isVScopedSlotFragment(child))) {
+      logError(`Invalid usage of 'lwc:slot-data' on ${getComponentTag(vm)} tag. Scoped slot content can only be passed to a light dom child.`);
+    }
+  }
+
   if (shadowMode === 1
   /* ShadowMode.Synthetic */
   || renderMode === 0
@@ -4558,26 +4577,26 @@ function createViewModelHook(elm, vnode, renderer) {
 
   return vm;
 }
+/**
+ * Collects all slots into a SlotSet, traversing through VFragment Nodes
+ */
 
-function allocateInSlot(vm, children, owner) {
-  var _a, _b;
 
-  const {
-    cmpSlots: {
-      slotAssignments: oldSlotsMapping
-    }
-  } = vm;
-  const cmpSlotsMapping = create(null);
-  vm.cmpSlots = {
-    owner,
-    slotAssignments: cmpSlotsMapping
-  };
+function collectSlots(vm, children, cmpSlotsMapping) {
+  var _a, _b;
 
   for (let i = 0, len = children.length; i < len; i += 1) {
     const vnode = children[i];
 
     if (isNull(vnode)) {
       continue;
+    } // Dive further iff the content is wrapped in a VFragment
+
+
+    if (isVFragment(vnode)) {
+      // Remove the text delimiter nodes to avoid overriding default slot content
+      collectSlots(vm, vnode.children.slice(1, -1), cmpSlotsMapping);
+      continue;
     }
 
     let slotName = '';
@@ -4591,6 +4610,20 @@ function allocateInSlot(vm, children, owner) {
     const vnodes = cmpSlotsMapping[slotName] = cmpSlotsMapping[slotName] || [];
     ArrayPush$1.call(vnodes, vnode);
   }
+}
+
+function allocateInSlot(vm, children, owner) {
+  const {
+    cmpSlots: {
+      slotAssignments: oldSlotsMapping
+    }
+  } = vm;
+  const cmpSlotsMapping = create(null);
+  collectSlots(vm, children, cmpSlotsMapping);
+  vm.cmpSlots = {
+    owner,
+    slotAssignments: cmpSlotsMapping
+  };
 
   if (isFalse(vm.isDirty)) {
     // We need to determine if the old allocation is really different from the new one
@@ -4911,27 +4944,42 @@ function s(slotName, data, children, slotset) {
         !isUndefined$1(slotset.slotAssignments) &&
         !isUndefined$1(slotset.slotAssignments[slotName]) &&
         slotset.slotAssignments[slotName].length !== 0) {
-        children = slotset.slotAssignments[slotName].reduce((acc, vnode) => {
-            // If the passed slot content is factory, evaluate it and use the produced vnodes
-            if (vnode && isVScopedSlotFragment(vnode)) {
-                const vmBeingRenderedInception = getVMBeingRendered();
-                let children = [];
-                // Evaluate in the scope of the slot content's owner
-                // if a slotset is provided, there will always be an owner. The only case where owner is
-                // undefined is for root components, but root components cannot accept slotted content
-                setVMBeingRendered(slotset.owner);
-                try {
-                    children = vnode.factory(data.slotData);
+        children = slotset.slotAssignments[slotName].reduce((accumulator, vnode) => {
+            if (vnode) {
+                const assignedNodeIsScopedSlot = isVScopedSlotFragment(vnode);
+                // The only sniff test for a scoped <slot> element is the presence of `slotData`
+                const isScopedSlotElement = !isUndefined$1(data.slotData);
+                // Check if slot types of parent and child are matching
+                if (assignedNodeIsScopedSlot !== isScopedSlotElement) {
+                    if (process.env.NODE_ENV !== 'production') {
+                        logError(`Mismatched slot types for ${slotName === '' ? '(default)' : slotName} slot. Both parent and child component must use standard type or scoped type for a given slot.`, slotset.owner);
+                    }
+                    // Ignore slot content from parent
+                    return accumulator;
+                }
+                // If the passed slot content is factory, evaluate it and add the produced vnodes
+                if (assignedNodeIsScopedSlot) {
+                    const vmBeingRenderedInception = getVMBeingRendered();
+                    let scopedSlotChildren = [];
+                    // Evaluate in the scope of the slot content's owner
+                    // if a slotset is provided, there will always be an owner. The only case where owner is
+                    // undefined is for root components, but root components cannot accept slotted content
+                    setVMBeingRendered(slotset.owner);
+                    try {
+                        scopedSlotChildren = vnode.factory(data.slotData);
+                    }
+                    finally {
+                        setVMBeingRendered(vmBeingRenderedInception);
+                    }
+                    return ArrayConcat$1.call(accumulator, scopedSlotChildren);
                 }
-                finally {
-                    setVMBeingRendered(vmBeingRenderedInception);
+                else {
+                    // If the slot content is standard type, the content is static, no additional
+                    // processing needed on the vnode
+                    return ArrayConcat$1.call(accumulator, vnode);
                 }
-                return ArrayConcat$1.call(acc, children);
-            }
-            else {
-                // If the slot content is a static list of child nodes provided by the parent, nothing to do
-                return ArrayConcat$1.call(acc, vnode);
             }
+            return accumulator;
         }, []);
     }
     const vmBeingRendered = getVMBeingRendered();
@@ -7061,11 +7109,12 @@ function validateClassAttr(vnode, elm, renderer) {
         }
     }
     let nodesAreCompatible = true;
-    let vnodeClassName;
-    if (!isUndefined$1(className) && String(className) !== getProperty(elm, 'className')) {
+    let readableVnodeClassname;
+    const elmClassName = getProperty(elm, 'className');
+    if (!isUndefined$1(className) && String(className) !== elmClassName) {
         // className is used when class is bound to an expr.
         nodesAreCompatible = false;
-        vnodeClassName = className;
+        readableVnodeClassname = className;
     }
     else if (!isUndefined$1(classMap)) {
         // classMap is used when class is set to static value.
@@ -7078,14 +7127,19 @@ function validateClassAttr(vnode, elm, renderer) {
                 nodesAreCompatible = false;
             }
         }
-        vnodeClassName = computedClassName.trim();
+        readableVnodeClassname = computedClassName.trim();
         if (classList.length > keys(classMap).length) {
             nodesAreCompatible = false;
         }
     }
+    else if (isUndefined$1(className) && elmClassName !== '') {
+        // SSR contains a className but client-side VDOM does not
+        nodesAreCompatible = false;
+        readableVnodeClassname = '';
+    }
     if (!nodesAreCompatible) {
         if (process.env.NODE_ENV !== 'production') {
-            logError(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: attribute "class" has different values, expected "${vnodeClassName}" but found "${getProperty(elm, 'className')}"`, vnode.owner);
+            logError(`Mismatch hydrating element <${getProperty(elm, 'tagName').toLowerCase()}>: attribute "class" has different values, expected "${readableVnodeClassname}" but found "${elmClassName}"`, vnode.owner);
         }
     }
     return nodesAreCompatible;
@@ -7299,7 +7353,7 @@ function getComponentConstructor(elm) {
     }
     return ctor;
 }
-/* version: 2.27.0 */
+/* version: 2.28.1 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -7573,10 +7627,12 @@ function createScopedRegistry() {
     const pendingRegistryForElement = new WeakMap();
     const definitionForConstructor = new WeakMap();
     const registeredUserCtors = new WeakSet();
+    const registeredPivotCtors = new WeakSet();
     const pivotCtorByTag = new Map();
     const globalDefinitionsByTag = new Map();
     const globalDefinitionsByClass = new Map();
     const awaitingUpgrade = new Map();
+    const pendingWhenDefinedCallbacks = new Map();
     const EMPTY_SET = new Set();
     function createDefinitionRecord(constructor) {
         var _a;
@@ -7682,6 +7738,7 @@ function createScopedRegistry() {
             }
         }
         PivotCtor.observedAttributes = [...registeredDefinition.observedAttributes];
+        registeredPivotCtors.add(PivotCtor);
         return PivotCtor;
     }
     function getNewObservedAttributes(registeredDefinition, pivotDefinition) {
@@ -7815,6 +7872,27 @@ function createScopedRegistry() {
         }
         return createDefinitionRecord(constructor);
     }
+    // Defer a `whenDefined()` callback until an externally-visible custom element is defined
+    function createPendingWhenDefinedCallback(tagName) {
+        return new Promise((resolve) => {
+            let resolvers = pendingWhenDefinedCallbacks.get(tagName);
+            if (isUndefined$1(resolvers)) {
+                resolvers = [];
+                pendingWhenDefinedCallbacks.set(tagName, resolvers);
+            }
+            resolvers.push(resolve);
+        });
+    }
+    // Call any pending `whenDefined()` callbacks
+    function flushPendingWhenDefinedCallbacks(tagName, ctor) {
+        const resolvers = pendingWhenDefinedCallbacks.get(tagName);
+        if (!isUndefined$1(resolvers)) {
+            for (const resolver of resolvers) {
+                resolver(ctor);
+            }
+        }
+        pendingWhenDefinedCallbacks.delete(tagName);
+    }
     const { customElements: nativeRegistry } = window;
     const { define: nativeDefine, whenDefined: nativeWhenDefined, get: nativeGet } = nativeRegistry;
     // patch for the global registry define mechanism
@@ -7869,6 +7947,8 @@ function createScopedRegistry() {
                 }
             }
         }
+        // If anyone called customElements.whenDefined() and is still waiting for a promise resolution, resolve now
+        flushPendingWhenDefinedCallbacks(tagName, constructor);
     };
     CustomElementRegistry.prototype.get = function get(tagName) {
         const NativeCtor = nativeGet.call(nativeRegistry, tagName);
@@ -7877,8 +7957,10 @@ function createScopedRegistry() {
             if (!isUndefined$1(definition)) {
                 return definition.UserCtor; // defined by the patched custom elements registry
             }
-            // TODO [#3073]: return undefined rather than the pivot constructor (NativeCtor)
-            return NativeCtor; // return the pivot constructor or constructor that existed before patching
+            if (registeredPivotCtors.has(NativeCtor)) {
+                return undefined; // pivot constructors should not be observable, return undefined
+            }
+            return NativeCtor; // constructor that existed before patching
         }
     };
     CustomElementRegistry.prototype.whenDefined = function whenDefined(tagName) {
@@ -7887,13 +7969,17 @@ function createScopedRegistry() {
             if (!isUndefined$1(definition)) {
                 return definition.UserCtor;
             }
-            // TODO [#3073]: return undefined rather than the pivot constructor (NativeCtor)
             // In this case, the custom element must have been defined before the registry patches
             // were applied. So return the non-pivot constructor
             if (isUndefined$1(NativeCtor)) {
                 // Chromium bug: https://bugs.chromium.org/p/chromium/issues/detail?id=1335247
                 // We can patch the correct behavior using customElements.get()
-                return nativeGet.call(nativeRegistry, tagName);
+                NativeCtor = nativeGet.call(nativeRegistry, tagName);
+            }
+            if (registeredPivotCtors.has(NativeCtor)) {
+                // Pivot constructors should not be observable. Wait to resolve the promise
+                // if a constructor is ever defined in userland
+                return createPendingWhenDefinedCallback(tagName);
             }
             return NativeCtor;
         });
@@ -8123,7 +8209,7 @@ function rendererFactory(baseRenderer) {
     function isNull(obj) {
         return obj === null;
     }
-    /** version: 2.27.0 */
+    /** version: 2.28.1 */
 
     /*
      * Copyright (c) 2018, salesforce.com, inc.
@@ -8702,6 +8788,6 @@ defineProperty(LightningElement, 'CustomElementConstructor', {
 });
 freeze(LightningElement);
 seal(LightningElement.prototype);
-/* version: 2.27.0 */
+/* version: 2.28.1 */
 
 export { LightningElement, profilerControl as __unstable__ProfilerControl, api$1 as api, deprecatedBuildCustomElementConstructor as buildCustomElementConstructor, createContextProvider, createElement, freezeTemplate, getComponentConstructor, getComponentDef, hydrateComponent, isComponentConstructor, isNodeShadowed as isNodeFromTemplate, parseFragment, parseSVGFragment, readonly, register, registerComponent, registerDecorators, registerTemplate, renderer, rendererFactory, sanitizeAttribute, setFeatureFlag, setFeatureFlagForTest, setHooks, swapComponent, swapStyle, swapTemplate, track, unwrap, wire };