@vue/runtime-dom 3.2.44 → 3.2.45

package/dist/runtime-dom.global.js

@@ -2022,12 +2022,6 @@ var VueRuntimeDOM = (function (exports) {
               // components to be unmounted and re-mounted. Queue the update so that we
               // don't end up forcing the same parent to re-render multiple times.
               queueJob(instance.parent.update);
-              // instance is the inner component of an async custom element
-              // invoke to reset styles
-              if (instance.parent.type.__asyncLoader &&
-                  instance.parent.ceReload) {
-                  instance.parent.ceReload(newComp.styles);
-              }
           }
           else if (instance.appContext.reload) {
               // root instance mounted via createApp() has a reload method
@@ -3875,10 +3869,15 @@ var VueRuntimeDOM = (function (exports) {
           }
       });
   }
-  function createInnerComp(comp, { vnode: { ref, props, children, shapeFlag }, parent }) {
+  function createInnerComp(comp, parent) {
+      const { ref, props, children, ce } = parent.vnode;
       const vnode = createVNode(comp, props, children);
       // ensure inner component inherits the async wrapper's ref owner
       vnode.ref = ref;
+      // pass the custom element callback on to the inner comp
+      // and remove it from the async wrapper
+      vnode.ce = ce;
+      delete parent.vnode.ce;
       return vnode;
   }
 
@@ -4036,8 +4035,7 @@ var VueRuntimeDOM = (function (exports) {
                   : comp);
               const { include, exclude, max } = props;
               if ((include && (!name || !matches(include, name))) ||
-                  (exclude && name && matches(exclude, name)) ||
-                  (hmrDirtyComponents.has(comp))) {
+                  (exclude && name && matches(exclude, name))) {
                   current = vnode;
                   return rawVNode;
               }
@@ -4147,14 +4145,9 @@ var VueRuntimeDOM = (function (exports) {
       }, target);
   }
   function resetShapeFlag(vnode) {
-      let shapeFlag = vnode.shapeFlag;
-      if (shapeFlag & 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */) {
-          shapeFlag -= 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */;
-      }
-      if (shapeFlag & 512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */) {
-          shapeFlag -= 512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */;
-      }
-      vnode.shapeFlag = shapeFlag;
+      // bitwise operations to remove keep alive flags
+      vnode.shapeFlag &= ~256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */;
+      vnode.shapeFlag &= ~512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */;
   }
   function getInnerChild(vnode) {
       return vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */ ? vnode.ssContent : vnode;
@@ -4453,7 +4446,9 @@ var VueRuntimeDOM = (function (exports) {
           (currentRenderingInstance.parent &&
               isAsyncWrapper(currentRenderingInstance.parent) &&
               currentRenderingInstance.parent.isCE)) {
-          return createVNode('slot', name === 'default' ? null : { name }, fallback && fallback());
+          if (name !== 'default')
+              props.name = name;
+          return createVNode('slot', props, fallback && fallback());
       }
       let slot = slots[name];
       if (slot && slot.length > 1) {
@@ -4553,6 +4548,7 @@ var VueRuntimeDOM = (function (exports) {
       $watch: i => (instanceWatch.bind(i) )
   });
   const isReservedPrefix = (key) => key === '_' || key === '$';
+  const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
   const PublicInstanceProxyHandlers = {
       get({ _: instance }, key) {
           const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
@@ -4560,15 +4556,6 @@ var VueRuntimeDOM = (function (exports) {
           if (key === '__isVue') {
               return true;
           }
-          // prioritize <script setup> bindings during dev.
-          // this allows even properties that start with _ or $ to be used - so that
-          // it aligns with the production behavior where the render fn is inlined and
-          // indeed has access to all declared variables.
-          if (setupState !== EMPTY_OBJ &&
-              setupState.__isScriptSetup &&
-              hasOwn(setupState, key)) {
-              return setupState[key];
-          }
           // data / props / ctx
           // This getter gets called for every property access on the render context
           // during render and is a major hotspot. The most expensive part of this
@@ -4591,7 +4578,7 @@ var VueRuntimeDOM = (function (exports) {
                       // default: just fallthrough
                   }
               }
-              else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
+              else if (hasSetupBinding(setupState, key)) {
                   accessCache[key] = 1 /* AccessTypes.SETUP */;
                   return setupState[key];
               }
@@ -4661,21 +4648,26 @@ var VueRuntimeDOM = (function (exports) {
       },
       set({ _: instance }, key, value) {
           const { data, setupState, ctx } = instance;
-          if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
+          if (hasSetupBinding(setupState, key)) {
               setupState[key] = value;
               return true;
           }
+          else if (setupState.__isScriptSetup &&
+              hasOwn(setupState, key)) {
+              warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
+              return false;
+          }
           else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
               data[key] = value;
               return true;
           }
           else if (hasOwn(instance.props, key)) {
-              warn$1(`Attempting to mutate prop "${key}". Props are readonly.`, instance);
+              warn$1(`Attempting to mutate prop "${key}". Props are readonly.`);
               return false;
           }
           if (key[0] === '$' && key.slice(1) in instance) {
               warn$1(`Attempting to mutate public property "${key}". ` +
-                      `Properties starting with $ are reserved and readonly.`, instance);
+                      `Properties starting with $ are reserved and readonly.`);
               return false;
           }
           else {
@@ -4696,7 +4688,7 @@ var VueRuntimeDOM = (function (exports) {
           let normalizedProps;
           return (!!accessCache[key] ||
               (data !== EMPTY_OBJ && hasOwn(data, key)) ||
-              (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) ||
+              hasSetupBinding(setupState, key) ||
               ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) ||
               hasOwn(ctx, key) ||
               hasOwn(publicPropertiesMap, key) ||
@@ -7735,6 +7727,10 @@ var VueRuntimeDOM = (function (exports) {
                   if (!shallow)
                       traverseStaticChildren(c1, c2);
               }
+              // #6852 also inherit for text nodes
+              if (c2.type === Text) {
+                  c2.el = c1.el;
+              }
               // also inherit for comment nodes, but not placeholders (e.g. v-if which
               // would have received .el during block patch)
               if (c2.type === Comment && !c2.el) {
@@ -7905,6 +7901,7 @@ var VueRuntimeDOM = (function (exports) {
                   }
               }
           }
+          updateCssVars(n2);
       },
       remove(vnode, parentComponent, parentSuspense, optimized, { um: unmount, o: { remove: hostRemove } }, doRemove) {
           const { shapeFlag, children, anchor, targetAnchor, target, props } = vnode;
@@ -7983,11 +7980,26 @@ var VueRuntimeDOM = (function (exports) {
                   hydrateChildren(targetNode, vnode, target, parentComponent, parentSuspense, slotScopeIds, optimized);
               }
           }
+          updateCssVars(vnode);
       }
       return vnode.anchor && nextSibling(vnode.anchor);
   }
   // Force-casted public typing for h and TSX props inference
   const Teleport = TeleportImpl;
+  function updateCssVars(vnode) {
+      // presence of .ut method indicates owner component uses css vars.
+      // code path here can assume browser environment.
+      const ctx = vnode.ctx;
+      if (ctx && ctx.ut) {
+          let node = vnode.children[0].el;
+          while (node !== vnode.targetAnchor) {
+              if (node.nodeType === 1)
+                  node.setAttribute('data-v-owner', ctx.uid);
+              node = node.nextSibling;
+          }
+          ctx.ut();
+      }
+  }
 
   const Fragment = Symbol('Fragment' );
   const Text = Symbol('Text' );
@@ -8082,6 +8094,10 @@ var VueRuntimeDOM = (function (exports) {
   function isSameVNodeType(n1, n2) {
       if (n2.shapeFlag & 6 /* ShapeFlags.COMPONENT */ &&
           hmrDirtyComponents.has(n2.type)) {
+          // #7042, ensure the vnode being unmounted during HMR
+          // bitwise operations to remove keep alive flags
+          n1.shapeFlag &= ~256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */;
+          n2.shapeFlag &= ~512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */;
           // HMR only: if the component has been hot-updated, force a reload.
           return false;
       }
@@ -8137,7 +8153,8 @@ var VueRuntimeDOM = (function (exports) {
           patchFlag,
           dynamicProps,
           dynamicChildren: null,
-          appContext: null
+          appContext: null,
+          ctx: currentRenderingInstance
       };
       if (needFullChildrenNormalization) {
           normalizeChildren(vnode, children);
@@ -8304,7 +8321,8 @@ var VueRuntimeDOM = (function (exports) {
           ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
           ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
           el: vnode.el,
-          anchor: vnode.anchor
+          anchor: vnode.anchor,
+          ctx: vnode.ctx
       };
       return cloned;
   }
@@ -9268,7 +9286,7 @@ var VueRuntimeDOM = (function (exports) {
   }
 
   // Core API ------------------------------------------------------------------
-  const version = "3.2.44";
+  const version = "3.2.45";
   /**
    * SSR utils for \@vue/server-renderer. Only exposed in ssr-possible builds.
    * @internal
@@ -9757,12 +9775,21 @@ var VueRuntimeDOM = (function (exports) {
                       `defined as hydratable. Use \`defineSSRCustomElement\`.`);
               }
               this.attachShadow({ mode: 'open' });
+              if (!this._def.__asyncLoader) {
+                  // for sync component defs we can immediately resolve props
+                  this._resolveProps(this._def);
+              }
           }
       }
       connectedCallback() {
           this._connected = true;
           if (!this._instance) {
-              this._resolveDef();
+              if (this._resolved) {
+                  this._update();
+              }
+              else {
+                  this._resolveDef();
+              }
           }
       }
       disconnectedCallback() {
@@ -9778,9 +9805,6 @@ var VueRuntimeDOM = (function (exports) {
        * resolve inner component definition (handle possible async component)
        */
       _resolveDef() {
-          if (this._resolved) {
-              return;
-          }
           this._resolved = true;
           // set initial attrs
           for (let i = 0; i < this.attributes.length; i++) {
@@ -9792,38 +9816,26 @@ var VueRuntimeDOM = (function (exports) {
                   this._setAttr(m.attributeName);
               }
           }).observe(this, { attributes: true });
-          const resolve = (def) => {
-              const { props = {}, styles } = def;
-              const hasOptions = !isArray(props);
-              const rawKeys = props ? (hasOptions ? Object.keys(props) : props) : [];
+          const resolve = (def, isAsync = false) => {
+              const { props, styles } = def;
               // cast Number-type props set before resolve
               let numberProps;
-              if (hasOptions) {
-                  for (const key in this._props) {
+              if (props && !isArray(props)) {
+                  for (const key in props) {
                       const opt = props[key];
                       if (opt === Number || (opt && opt.type === Number)) {
-                          this._props[key] = toNumber(this._props[key]);
-                          (numberProps || (numberProps = Object.create(null)))[key] = true;
+                          if (key in this._props) {
+                              this._props[key] = toNumber(this._props[key]);
+                          }
+                          (numberProps || (numberProps = Object.create(null)))[camelize(key)] = true;
                       }
                   }
               }
               this._numberProps = numberProps;
-              // check if there are props set pre-upgrade or connect
-              for (const key of Object.keys(this)) {
-                  if (key[0] !== '_') {
-                      this._setProp(key, this[key], true, false);
-                  }
-              }
-              // defining getter/setters on prototype
-              for (const key of rawKeys.map(camelize)) {
-                  Object.defineProperty(this, key, {
-                      get() {
-                          return this._getProp(key);
-                      },
-                      set(val) {
-                          this._setProp(key, val);
-                      }
-                  });
+              if (isAsync) {
+                  // defining getter/setters on prototype
+                  // for sync defs, this already happened in the constructor
+                  this._resolveProps(def);
               }
               // apply CSS
               this._applyStyles(styles);
@@ -9832,12 +9844,33 @@ var VueRuntimeDOM = (function (exports) {
           };
           const asyncDef = this._def.__asyncLoader;
           if (asyncDef) {
-              asyncDef().then(resolve);
+              asyncDef().then(def => resolve(def, true));
           }
           else {
               resolve(this._def);
           }
       }
+      _resolveProps(def) {
+          const { props } = def;
+          const declaredPropKeys = isArray(props) ? props : Object.keys(props || {});
+          // check if there are props set pre-upgrade or connect
+          for (const key of Object.keys(this)) {
+              if (key[0] !== '_' && declaredPropKeys.includes(key)) {
+                  this._setProp(key, this[key], true, false);
+              }
+          }
+          // defining getter/setters on prototype
+          for (const key of declaredPropKeys.map(camelize)) {
+              Object.defineProperty(this, key, {
+                  get() {
+                      return this._getProp(key);
+                  },
+                  set(val) {
+                      this._setProp(key, val);
+                  }
+              });
+          }
+      }
       _setAttr(key) {
           let value = this.getAttribute(key);
           const camelKey = camelize(key);
@@ -9893,27 +9926,31 @@ var VueRuntimeDOM = (function (exports) {
                               this._styles.length = 0;
                           }
                           this._applyStyles(newStyles);
-                          // if this is an async component, ceReload is called from the inner
-                          // component so no need to reload the async wrapper
-                          if (!this._def.__asyncLoader) {
-                              // reload
-                              this._instance = null;
-                              this._update();
-                          }
+                          this._instance = null;
+                          this._update();
                       };
                   }
-                  // intercept emit
-                  instance.emit = (event, ...args) => {
+                  const dispatch = (event, args) => {
                       this.dispatchEvent(new CustomEvent(event, {
                           detail: args
                       }));
                   };
+                  // intercept emit
+                  instance.emit = (event, ...args) => {
+                      // dispatch both the raw and hyphenated versions of an event
+                      // to match Vue behavior
+                      dispatch(event, args);
+                      if (hyphenate(event) !== event) {
+                          dispatch(hyphenate(event), args);
+                      }
+                  };
                   // locate nearest Vue custom element parent for provide/inject
                   let parent = this;
                   while ((parent =
                       parent && (parent.parentNode || parent.host))) {
                       if (parent instanceof VueElement) {
                           instance.parent = parent._instance;
+                          instance.provides = parent._instance.provides;
                           break;
                       }
                   }
@@ -9957,7 +9994,14 @@ var VueRuntimeDOM = (function (exports) {
           warn$1(`useCssVars is called without current active component instance.`);
           return;
       }
-      const setVars = () => setVarsOnVNode(instance.subTree, getter(instance.proxy));
+      const updateTeleports = (instance.ut = (vars = getter(instance.proxy)) => {
+          Array.from(document.querySelectorAll(`[data-v-owner="${instance.uid}"]`)).forEach(node => setVarsOnNode(node, vars));
+      });
+      const setVars = () => {
+          const vars = getter(instance.proxy);
+          setVarsOnVNode(instance.subTree, vars);
+          updateTeleports(vars);
+      };
       watchPostEffect(setVars);
       onMounted(() => {
           const ob = new MutationObserver(setVars);