lwc 2.5.6 → 2.5.10-alpha1

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

@@ -299,7 +299,7 @@ function htmlPropertyToAttribute(propName) {
   CACHED_PROPERTY_ATTRIBUTE_MAPPING.set(propName, attributeName);
   return attributeName;
 }
-/** version: 2.5.6 */
+/** version: 2.5.10-alpha1 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -479,7 +479,7 @@ function setFeatureFlagForTest(name, value) {
     setFeatureFlag(name, value);
   }
 }
-/** version: 2.5.6 */
+/** version: 2.5.10-alpha1 */
 
 /* proxy-compat-disable */
 
@@ -531,6 +531,28 @@ function guid() {
   }
 
   return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
+} // Borrowed from Vue template compiler.
+// https://github.com/vuejs/vue/blob/531371b818b0e31a989a06df43789728f23dc4e8/src/platforms/web/util/style.js#L5-L16
+
+
+const DECLARATION_DELIMITER = /;(?![^(]*\))/g;
+const PROPERTY_DELIMITER = /:(.+)/;
+
+function parseStyleText(cssText) {
+  const styleMap = {};
+  const declarations = cssText.split(DECLARATION_DELIMITER);
+
+  for (const declaration of declarations) {
+    if (declaration) {
+      const [prop, value] = declaration.split(PROPERTY_DELIMITER);
+
+      if (prop !== undefined && value !== undefined) {
+        styleMap[prop.trim()] = value.trim();
+      }
+    }
+  }
+
+  return styleMap;
 }
 /*
  * Copyright (c) 2019, salesforce.com, inc.
@@ -712,8 +734,8 @@ function getErrorComponentStack(vm) {
  */
 
 
-function logError(message, vm) {
-  let msg = `[LWC error]: ${message}`;
+function log(method, message, vm) {
+  let msg = `[LWC ${method}]: ${message}`;
 
   if (!isUndefined$1(vm)) {
     msg = `${msg}\n${getComponentStack(vm)}`;
@@ -721,7 +743,7 @@ function logError(message, vm) {
 
   if (process.env.NODE_ENV === 'test') {
     /* eslint-disable-next-line no-console */
-    console.error(msg);
+    console[method](msg);
     return;
   }
 
@@ -729,9 +751,17 @@ function logError(message, vm) {
     throw new Error(msg);
   } catch (e) {
     /* eslint-disable-next-line no-console */
-    console.error(e);
+    console[method](e);
   }
 }
+
+function logError(message, vm) {
+  log('error', message, vm);
+}
+
+function logWarn(message, vm) {
+  log('warn', message, vm);
+}
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -3095,8 +3125,10 @@ for (const [elementProp, rendererMethod] of childGetters) {
       }
 
       return renderer[rendererMethod](elm);
-    }
+    },
 
+    configurable: true,
+    enumerable: true
   };
 }
 
@@ -3116,8 +3148,11 @@ for (const queryMethod of queryMethods) {
       }
 
       return renderer[queryMethod](elm, arg);
-    }
+    },
 
+    configurable: true,
+    enumerable: true,
+    writable: true
   };
 }
 
@@ -4275,7 +4310,7 @@ function createComponentDef(Ctor) {
     if (!isUndefined$1(ctorShadowSupportMode)) {
       assert.invariant(ctorShadowSupportMode === "any"
       /* Any */
-      || ctorShadowSupportMode === "default"
+      || ctorShadowSupportMode === "reset"
       /* Default */
       , `Invalid value for static property shadowSupportMode: '${ctorShadowSupportMode}'`);
     }
@@ -4437,7 +4472,7 @@ const lightingElementDef = {
   renderMode: 1
   /* Shadow */
   ,
-  shadowSupportMode: "default"
+  shadowSupportMode: "reset"
   /* Default */
   ,
   wire: EmptyObject,
@@ -4586,6 +4621,17 @@ function createElmHook(vnode) {
   modComputedStyle.create(vnode);
 }
 
+function hydrateElmHook(vnode) {
+  modEvents.create(vnode); // Attrs are already on the element.
+  // modAttrs.create(vnode);
+
+  modProps.create(vnode); // Already set.
+  // modStaticClassName.create(vnode);
+  // modStaticStyle.create(vnode);
+  // modComputedClassName.create(vnode);
+  // modComputedStyle.create(vnode);
+}
+
 function fallbackElmHook(elm, vnode) {
   const {
     owner
@@ -4757,6 +4803,179 @@ function createChildrenHook(vnode) {
   }
 }
 
+function isElementNode(node) {
+  // eslint-disable-next-line lwc-internal/no-global-node
+  return node.nodeType === Node.ELEMENT_NODE;
+}
+
+function vnodesAndElementHaveCompatibleAttrs(vnode, elm) {
+  const {
+    data: {
+      attrs = {}
+    },
+    owner: {
+      renderer
+    }
+  } = vnode;
+  let nodesAreCompatible = true; // Validate attributes, though we could always recovery from those by running the update mods.
+  // Note: intentionally ONLY matching vnodes.attrs to elm.attrs, in case SSR is adding extra attributes.
+
+  for (const [attrName, attrValue] of Object.entries(attrs)) {
+    const elmAttrValue = renderer.getAttribute(elm, attrName);
+
+    if (String(attrValue) !== elmAttrValue) {
+      logError(`Mismatch hydrating element <${elm.tagName.toLowerCase()}>: attribute "${attrName}" has different values, expected "${attrValue}" but found "${elmAttrValue}"`, vnode.owner);
+      nodesAreCompatible = false;
+    }
+  }
+
+  return nodesAreCompatible;
+}
+
+function vnodesAndElementHaveCompatibleClass(vnode, elm) {
+  const {
+    data: {
+      className,
+      classMap
+    },
+    owner: {
+      renderer
+    }
+  } = vnode;
+  let nodesAreCompatible = true;
+  let vnodeClassName;
+
+  if (!isUndefined$1(className) && String(className) !== elm.className) {
+    // className is used when class is bound to an expr.
+    nodesAreCompatible = false;
+    vnodeClassName = className;
+  } else if (!isUndefined$1(classMap)) {
+    // classMap is used when class is set to static value.
+    const classList = renderer.getClassList(elm);
+    let computedClassName = ''; // all classes from the vnode should be in the element.classList
+
+    for (const name in classMap) {
+      computedClassName += ' ' + name;
+
+      if (!classList.contains(name)) {
+        nodesAreCompatible = false;
+      }
+    }
+
+    vnodeClassName = computedClassName.trim();
+
+    if (classList.length > keys(classMap).length) {
+      nodesAreCompatible = false;
+    }
+  }
+
+  if (!nodesAreCompatible) {
+    logError(`Mismatch hydrating element <${elm.tagName.toLowerCase()}>: attribute "class" has different values, expected "${vnodeClassName}" but found "${elm.className}"`, vnode.owner);
+  }
+
+  return nodesAreCompatible;
+}
+
+function vnodesAndElementHaveCompatibleStyle(vnode, elm) {
+  const {
+    data: {
+      style,
+      styleDecls
+    },
+    owner: {
+      renderer
+    }
+  } = vnode;
+  const elmStyle = renderer.getAttribute(elm, 'style') || '';
+  let vnodeStyle;
+  let nodesAreCompatible = true;
+
+  if (!isUndefined$1(style) && style !== elmStyle) {
+    nodesAreCompatible = false;
+    vnodeStyle = style;
+  } else if (!isUndefined$1(styleDecls)) {
+    const parsedVnodeStyle = parseStyleText(elmStyle);
+    const expectedStyle = []; // styleMap is used when style is set to static value.
+
+    for (let i = 0, n = styleDecls.length; i < n; i++) {
+      const [prop, value, important] = styleDecls[i];
+      expectedStyle.push(`${prop}: ${value + (important ? ' important!' : '')}`);
+      const parsedPropValue = parsedVnodeStyle[prop];
+
+      if (isUndefined$1(parsedPropValue)) {
+        nodesAreCompatible = false;
+      } else if (!parsedPropValue.startsWith(value)) {
+        nodesAreCompatible = false;
+      } else if (important && !parsedPropValue.endsWith('!important')) {
+        nodesAreCompatible = false;
+      }
+    }
+
+    if (keys(parsedVnodeStyle).length > styleDecls.length) {
+      nodesAreCompatible = false;
+    }
+
+    vnodeStyle = ArrayJoin.call(expectedStyle, ';');
+  }
+
+  if (!nodesAreCompatible) {
+    // style is used when class is bound to an expr.
+    logError(`Mismatch hydrating element <${elm.tagName.toLowerCase()}>: attribute "style" has different values, expected "${vnodeStyle}" but found "${elmStyle}".`, vnode.owner);
+  }
+
+  return nodesAreCompatible;
+}
+
+function throwHydrationError() {
+  assert.fail('Server rendered elements do not match client side generated elements');
+}
+
+function hydrateChildrenHook(elmChildren, children, vm) {
+  var _a, _b;
+
+  if (process.env.NODE_ENV !== 'production') {
+    const filteredVNodes = ArrayFilter.call(children, vnode => !!vnode);
+
+    if (elmChildren.length !== filteredVNodes.length) {
+      logError(`Hydration mismatch: incorrect number of rendered nodes, expected ${filteredVNodes.length} but found ${elmChildren.length}.`, vm);
+      throwHydrationError();
+    }
+  }
+
+  let elmCurrentChildIdx = 0;
+
+  for (let j = 0, n = children.length; j < n; j++) {
+    const ch = children[j];
+
+    if (ch != null) {
+      const childNode = elmChildren[elmCurrentChildIdx];
+
+      if (process.env.NODE_ENV !== 'production') {
+        // VComments and VTexts validation is handled in their hooks
+        if (isElementNode(childNode)) {
+          if (((_a = ch.sel) === null || _a === void 0 ? void 0 : _a.toLowerCase()) !== childNode.tagName.toLowerCase()) {
+            logError(`Hydration mismatch: expecting element with tag "${(_b = ch.sel) === null || _b === void 0 ? void 0 : _b.toLowerCase()}" but found "${childNode.tagName.toLowerCase()}".`, vm);
+            throwHydrationError();
+          } // Note: props are not yet set
+
+
+          const hasIncompatibleAttrs = vnodesAndElementHaveCompatibleAttrs(ch, childNode);
+          const hasIncompatibleClass = vnodesAndElementHaveCompatibleClass(ch, childNode);
+          const hasIncompatibleStyle = vnodesAndElementHaveCompatibleStyle(ch, childNode);
+          const isVNodeAndElementCompatible = hasIncompatibleAttrs && hasIncompatibleClass && hasIncompatibleStyle;
+
+          if (!isVNodeAndElementCompatible) {
+            throwHydrationError();
+          }
+        }
+      }
+
+      ch.hook.hydrate(ch, childNode);
+      elmCurrentChildIdx++;
+    }
+  }
+}
+
 function updateCustomElmHook(oldVnode, vnode) {
   // Attrs need to be applied to element before props
   // IE11 will wipe out value on radio inputs if value
@@ -4840,38 +5059,6 @@ function getUpgradableConstructor(tagName, renderer) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 
-/**
- * EXPERIMENTAL: This function acts like a hook for Lightning Locker Service and other similar
- * libraries to sanitize HTML content. This hook process the content passed via the template to
- * lwc:inner-html directive.
- * It is meant to be overridden with setSanitizeHtmlContentHook
- */
-
-
-let sanitizeHtmlContentHook = () => {
-  // locker-service patches this function during runtime to sanitize HTML content.
-  throw new Error('sanitizeHtmlContent hook must be implemented.');
-};
-/**
- * Sets the sanitizeHtmlContentHook.
- *
- * @param newHookImpl
- * @returns oldHookImplementation.
- */
-
-
-function setSanitizeHtmlContentHook(newHookImpl) {
-  const currentHook = sanitizeHtmlContentHook;
-  sanitizeHtmlContentHook = newHookImpl;
-  return currentHook;
-}
-/*
- * 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
- */
-
 
 const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
 const SymbolIterator = Symbol.iterator;
@@ -4890,7 +5077,26 @@ const TextHook = {
   update: updateNodeHook,
   insert: insertNodeHook,
   move: insertNodeHook,
-  remove: removeNodeHook
+  remove: removeNodeHook,
+  hydrate: (vNode, node) => {
+    var _a;
+
+    if (process.env.NODE_ENV !== 'production') {
+      // eslint-disable-next-line lwc-internal/no-global-node
+      if (node.nodeType !== Node.TEXT_NODE) {
+        logError('Hydration mismatch: incorrect node type received', vNode.owner);
+        assert.fail('Hydration mismatch: incorrect node type received.');
+      }
+
+      if (node.nodeValue !== vNode.text) {
+        logWarn('Hydration mismatch: text values do not match, will recover from the difference', vNode.owner);
+      }
+    } // always set the text value to the one from the vnode.
+
+
+    node.nodeValue = (_a = vNode.text) !== null && _a !== void 0 ? _a : null;
+    vNode.elm = node;
+  }
 };
 const CommentHook = {
   create: vnode => {
@@ -4908,7 +5114,26 @@ const CommentHook = {
   update: updateNodeHook,
   insert: insertNodeHook,
   move: insertNodeHook,
-  remove: removeNodeHook
+  remove: removeNodeHook,
+  hydrate: (vNode, node) => {
+    var _a;
+
+    if (process.env.NODE_ENV !== 'production') {
+      // eslint-disable-next-line lwc-internal/no-global-node
+      if (node.nodeType !== Node.COMMENT_NODE) {
+        logError('Hydration mismatch: incorrect node type received', vNode.owner);
+        assert.fail('Hydration mismatch: incorrect node type received.');
+      }
+
+      if (node.nodeValue !== vNode.text) {
+        logWarn('Hydration mismatch: comment values do not match, will recover from the difference', vNode.owner);
+      }
+    } // always set the text value to the one from the vnode.
+
+
+    node.nodeValue = (_a = vNode.text) !== null && _a !== void 0 ? _a : null;
+    vNode.elm = node;
+  }
 }; // insert is called after update, which is used somewhere else (via a module)
 // to mark the vm as inserted, that means we cannot use update as the main channel
 // to rehydrate when dirty, because sometimes the element is not inserted just yet,
@@ -4948,6 +5173,38 @@ const ElementHook = {
   remove: (vnode, parentNode) => {
     removeNodeHook(vnode, parentNode);
     removeElmHook(vnode);
+  },
+  hydrate: (vnode, node) => {
+    const elm = node;
+    vnode.elm = elm;
+    const {
+      context
+    } = vnode.data;
+    const isDomManual = Boolean(!isUndefined$1(context) && !isUndefined$1(context.lwc) && context.lwc.dom === "manual"
+    /* manual */
+    );
+
+    if (isDomManual) {
+      // it may be that this element has lwc:inner-html, we need to diff and in case are the same,
+      // remove the innerHTML from props so it reuses the existing dom elements.
+      const {
+        props
+      } = vnode.data;
+
+      if (!isUndefined$1(props) && !isUndefined$1(props.innerHTML)) {
+        if (elm.innerHTML === props.innerHTML) {
+          delete props.innerHTML;
+        } else {
+          logWarn(`Mismatch hydrating element <${elm.tagName.toLowerCase()}>: innerHTML values do not match for element, will recover from the difference`, vnode.owner);
+        }
+      }
+    }
+
+    hydrateElmHook(vnode);
+
+    if (!isDomManual) {
+      hydrateChildrenHook(vnode.elm.childNodes, vnode.children, vnode.owner);
+    }
   }
 };
 const CustomElementHook = {
@@ -5039,6 +5296,44 @@ const CustomElementHook = {
       // will take care of disconnecting any child VM attached to its shadow as well.
       removeVM(vm);
     }
+  },
+  hydrate: (vnode, elm) => {
+    // the element is created, but the vm is not
+    const {
+      sel,
+      mode,
+      ctor,
+      owner
+    } = vnode;
+    const def = getComponentInternalDef(ctor);
+    createVM(elm, def, {
+      mode,
+      owner,
+      tagName: sel,
+      renderer: owner.renderer
+    });
+    vnode.elm = elm;
+    const vm = getAssociatedVM(elm);
+    allocateChildrenHook(vnode, vm);
+    hydrateElmHook(vnode); // Insert hook section:
+
+    if (process.env.NODE_ENV !== 'production') {
+      assert.isTrue(vm.state === 0
+      /* created */
+      , `${vm} cannot be recycled.`);
+    }
+
+    runConnectedCallback(vm);
+
+    if (vm.renderMode !== 0
+    /* Light */
+    ) {
+      // VM is not rendering in Light DOM, we can proceed and hydrate the slotted content.
+      // Note: for Light DOM, this is handled while hydrating the VM
+      hydrateChildrenHook(vnode.elm.childNodes, vnode.children, vm);
+    }
+
+    hydrateVM(vm);
   }
 };
 
@@ -5351,7 +5646,7 @@ function co(text) {
 
 
 function d(value) {
-  return value == null ? '' : value;
+  return value == null ? '' : String(value);
 } // [b]ind function
 
 
@@ -5513,6 +5808,26 @@ function sc(vnodes) {
 
   markAsDynamicChildren(vnodes);
   return vnodes;
+}
+/**
+ * EXPERIMENTAL: This function acts like a hook for Lightning Locker Service and other similar
+ * libraries to sanitize HTML content. This hook process the content passed via the template to
+ * lwc:inner-html directive.
+ * It is meant to be overridden with setSanitizeHtmlContentHook, it throws an error by default.
+ */
+
+
+let sanitizeHtmlContentHook = () => {
+  // locker-service patches this function during runtime to sanitize HTML content.
+  throw new Error('sanitizeHtmlContent hook must be implemented.');
+};
+/**
+ * Sets the sanitizeHtmlContentHook.
+ */
+
+
+function setSanitizeHtmlContentHook(newHookImpl) {
+  sanitizeHtmlContentHook = newHookImpl;
 } // [s]anitize [h]tml [c]ontent
 
 
@@ -5707,7 +6022,10 @@ function createStylesheet(vm, stylesheets) {
     for (let i = 0; i < stylesheets.length; i++) {
       renderer.insertGlobalStylesheet(stylesheets[i]);
     }
-  } else if (renderer.ssr) {
+  } else if (renderer.ssr || renderer.isHydrating()) {
+    // Note: We need to ensure that during hydration, the stylesheets method is the same as those in ssr.
+    //       This works in the client, because the stylesheets are created, and cached in the VM
+    //       the first time the VM renders.
     // native shadow or light DOM, SSR
     const combinedStylesheetContent = ArrayJoin.call(stylesheets, '\n');
     return createInlineStyleVNode(combinedStylesheetContent);
@@ -6332,6 +6650,12 @@ function connectRootElement(elm) {
   , vm);
 }
 
+function hydrateRootElement(elm) {
+  const vm = getAssociatedVM(elm);
+  runConnectedCallback(vm);
+  hydrateVM(vm);
+}
+
 function disconnectRootElement(elm) {
   const vm = getAssociatedVM(elm);
   resetComponentStateWhenRemoved(vm);
@@ -6339,6 +6663,10 @@ function disconnectRootElement(elm) {
 
 function appendVM(vm) {
   rehydrate(vm);
+}
+
+function hydrateVM(vm) {
+  hydrate(vm);
 } // just in case the component comes back, with this we guarantee re-rendering it
 // while preventing any attempt to rehydration until after reinsertion.
 
@@ -6572,6 +6900,22 @@ function rehydrate(vm) {
   }
 }
 
+function hydrate(vm) {
+  if (isTrue(vm.isDirty)) {
+    // manually diffing/patching here.
+    // This routine is:
+    // patchShadowRoot(vm, children);
+    //  -> addVnodes.
+    const children = renderComponent(vm);
+    vm.children = children;
+    const vmChildren = vm.renderMode === 0
+    /* Light */
+    ? vm.elm.childNodes : vm.elm.shadowRoot.childNodes;
+    hydrateChildrenHook(vmChildren, children, vm);
+    runRenderedCallback(vm);
+  }
+}
+
 function patchShadowRoot(vm, newCh) {
   const {
     children: oldCh
@@ -7398,28 +7742,12 @@ function readonly(obj) {
 
 let hooksAreSet = false;
 
-function overrideHooks(hooks) {
-  const oldHooks = {};
-
-  if (!isUndefined$1(hooks.sanitizeHtmlContent)) {
-    oldHooks.sanitizeHtmlContent = setSanitizeHtmlContentHook(hooks.sanitizeHtmlContent);
-  }
-
-  return oldHooks;
-}
-
 function setHooks(hooks) {
   assert.isFalse(hooksAreSet, 'Hooks are already overridden, only one definition is allowed.');
-  overrideHooks(hooks);
   hooksAreSet = true;
+  setSanitizeHtmlContentHook(hooks.sanitizeHtmlContent);
 }
-
-function setHooksForTest(hooks) {
-  if (process.env.NODE_ENV !== 'production') {
-    return overrideHooks(hooks);
-  }
-}
-/* version: 2.5.6 */
+/* version: 2.5.10-alpha1 */
 
 /*
  * Copyright (c) 2018, salesforce.com, inc.
@@ -7563,8 +7891,19 @@ if (isCustomElementRegistryAvailable()) {
   HTMLElementConstructor.prototype = HTMLElement.prototype;
 }
 
+let isHydrating = false;
+
+function setIsHydrating(v) {
+  isHydrating = v;
+}
+
 const renderer = {
   ssr: false,
+
+  isHydrating() {
+    return isHydrating;
+  },
+
   isNativeShadowDefined: _globalThis[KEY__IS_NATIVE_SHADOW_ROOT_DEFINED],
   isSyntheticShadowDefined: hasOwnProperty$1.call(Element.prototype, KEY__SHADOW_TOKEN),
 
@@ -7593,6 +7932,10 @@ const renderer = {
   },
 
   attachShadow(element, options) {
+    if (isHydrating) {
+      return element.shadowRoot;
+    }
+
     return element.attachShadow(options);
   },
 
@@ -7730,61 +8073,6 @@ const renderer = {
   getCustomElement,
   HTMLElement: HTMLElementConstructor
 };
-/*
- * 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
- */
-
-/**
- * This function builds a Web Component class from a LWC constructor so it can be
- * registered as a new element via customElements.define() at any given time.
- *
- * @deprecated since version 1.3.11
- *
- * @example
- * ```
- * import { buildCustomElementConstructor } from 'lwc';
- * import Foo from 'ns/foo';
- * const WC = buildCustomElementConstructor(Foo);
- * customElements.define('x-foo', WC);
- * const elm = document.createElement('x-foo');
- * ```
- */
-
-function deprecatedBuildCustomElementConstructor(Ctor) {
-  if (process.env.NODE_ENV !== 'production') {
-    /* eslint-disable-next-line no-console */
-    console.warn('Deprecated function called: "buildCustomElementConstructor" function is deprecated and it will be removed.' + `Use "${Ctor.name}.CustomElementConstructor" static property of the component constructor to access the corresponding custom element constructor instead.`);
-  }
-
-  return Ctor.CustomElementConstructor;
-}
-
-function buildCustomElementConstructor(Ctor) {
-  const def = getComponentInternalDef(Ctor);
-  return class extends def.bridge {
-    constructor() {
-      super();
-      createVM(this, def, {
-        mode: 'open',
-        owner: null,
-        tagName: this.tagName,
-        renderer
-      });
-    }
-
-    connectedCallback() {
-      connectRootElement(this);
-    }
-
-    disconnectedCallback() {
-      disconnectRootElement(this);
-    }
-
-  };
-}
 /*
  * Copyright (c) 2018, salesforce.com, inc.
  * All rights reserved.
@@ -7794,7 +8082,6 @@ function buildCustomElementConstructor(Ctor) {
 // TODO [#2472]: Remove this workaround when appropriate.
 // eslint-disable-next-line lwc-internal/no-global-node
 
-
 const _Node$1 = Node;
 const ConnectingSlot = new WeakMap();
 const DisconnectingSlot = new WeakMap();
@@ -7905,6 +8192,118 @@ function createElement(sel, options) {
  * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
  */
 
+
+function hydrateComponent(element, Ctor, props = {}) {
+  if (!isFunction$1(Ctor)) {
+    throw new TypeError(`"hydrateComponent" expects a valid component constructor as the second parameter but instead received ${Ctor}.`);
+  }
+
+  if (!isObject(props) || isNull(props)) {
+    throw new TypeError(`"hydrateComponent" expects an object as the third parameter but instead received ${props}.`);
+  }
+
+  const def = getComponentInternalDef(Ctor);
+
+  try {
+    // Let the renderer know we are hydrating, so it does not replace the existing shadowRoot
+    // and uses the same algo to create the stylesheets as in SSR.
+    setIsHydrating(true);
+    createVM(element, def, {
+      mode: 'open',
+      owner: null,
+      renderer,
+      tagName: element.tagName.toLowerCase()
+    });
+
+    for (const [key, value] of Object.entries(props)) {
+      element[key] = value;
+    }
+
+    hydrateRootElement(element); // set it back since now we finished hydration.
+
+    setIsHydrating(false);
+  } catch (e) {
+    // Fallback: In case there's an error while hydrating, let's log the error, and replace the element with
+    //           the client generated DOM.
+
+    /* eslint-disable-next-line no-console */
+    console.error('Recovering from error while hydrating: ', e);
+    setIsHydrating(false);
+    const newElem = createElement(element.tagName, {
+      is: Ctor,
+      mode: 'open'
+    });
+
+    for (const [key, value] of Object.entries(props)) {
+      newElem[key] = value;
+    }
+
+    element.parentNode.replaceChild(newElem, element);
+  }
+}
+/*
+ * 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
+ */
+
+/**
+ * This function builds a Web Component class from a LWC constructor so it can be
+ * registered as a new element via customElements.define() at any given time.
+ *
+ * @deprecated since version 1.3.11
+ *
+ * @example
+ * ```
+ * import { buildCustomElementConstructor } from 'lwc';
+ * import Foo from 'ns/foo';
+ * const WC = buildCustomElementConstructor(Foo);
+ * customElements.define('x-foo', WC);
+ * const elm = document.createElement('x-foo');
+ * ```
+ */
+
+
+function deprecatedBuildCustomElementConstructor(Ctor) {
+  if (process.env.NODE_ENV !== 'production') {
+    /* eslint-disable-next-line no-console */
+    console.warn('Deprecated function called: "buildCustomElementConstructor" function is deprecated and it will be removed.' + `Use "${Ctor.name}.CustomElementConstructor" static property of the component constructor to access the corresponding custom element constructor instead.`);
+  }
+
+  return Ctor.CustomElementConstructor;
+}
+
+function buildCustomElementConstructor(Ctor) {
+  const def = getComponentInternalDef(Ctor);
+  return class extends def.bridge {
+    constructor() {
+      super();
+      createVM(this, def, {
+        mode: 'open',
+        owner: null,
+        tagName: this.tagName,
+        renderer
+      });
+    }
+
+    connectedCallback() {
+      connectRootElement(this);
+    }
+
+    disconnectedCallback() {
+      disconnectRootElement(this);
+    }
+
+  };
+}
+/*
+ * 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
+ */
+
 /**
  * EXPERIMENTAL: This function provides access to the component constructor, given an HTMLElement.
  * This API is subject to change or being removed.
@@ -8004,6 +8403,6 @@ defineProperty(LightningElement, 'CustomElementConstructor', {
 });
 freeze(LightningElement);
 seal(LightningElement.prototype);
-/* version: 2.5.6 */
+/* version: 2.5.10-alpha1 */
 
-export { LightningElement, profilerControl as __unstable__ProfilerControl, api$1 as api, deprecatedBuildCustomElementConstructor as buildCustomElementConstructor, createContextProvider, createElement, getComponentConstructor, getComponentDef, isComponentConstructor, isNodeFromTemplate, readonly, register, registerComponent, registerDecorators, registerTemplate, sanitizeAttribute, setFeatureFlag, setFeatureFlagForTest, setHooks, setHooksForTest, swapComponent, swapStyle, swapTemplate, track, unwrap, wire };
+export { LightningElement, profilerControl as __unstable__ProfilerControl, api$1 as api, deprecatedBuildCustomElementConstructor as buildCustomElementConstructor, createContextProvider, createElement, getComponentConstructor, getComponentDef, hydrateComponent, isComponentConstructor, isNodeFromTemplate, readonly, register, registerComponent, registerDecorators, registerTemplate, sanitizeAttribute, setFeatureFlag, setFeatureFlagForTest, setHooks, swapComponent, swapStyle, swapTemplate, track, unwrap, wire };