vue 2.7.6 → 2.7.9

package/dist/vue.js

@@ -1,5 +1,5 @@
 /*!
- * Vue.js v2.7.6
+ * Vue.js v2.7.9
  * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
@@ -655,13 +655,13 @@
               'referenced during render. Make sure that this property is reactive, ' +
               'either in the data option, or for class-based components, by ' +
               'initializing the property. ' +
-              'See: https://vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
+              'See: https://v2.vuejs.org/v2/guide/reactivity.html#Declaring-Reactive-Properties.', target);
       };
       var warnReservedPrefix_1 = function (target, key) {
           warn$2("Property \"".concat(key, "\" must be accessed with \"$data.").concat(key, "\" because ") +
               'properties starting with "$" or "_" are not proxied in the Vue instance to ' +
               'prevent conflicts with Vue internals. ' +
-              'See: https://vuejs.org/v2/api/#data', target);
+              'See: https://v2.vuejs.org/v2/api/#data', target);
       };
       var hasProxy_1 = typeof Proxy !== 'undefined' && isNative(Proxy);
       if (hasProxy_1) {
@@ -1007,7 +1007,7 @@
                   // #7981: for accessor properties without setter
                   return;
               }
-              else if (isRef(value) && !isRef(newVal)) {
+              else if (!shallow && isRef(value) && !isRef(newVal)) {
                   value.value = newVal;
                   return;
               }
@@ -2283,7 +2283,19 @@
       var exposeCalled = false;
       return {
           get attrs() {
-              return initAttrsProxy(vm);
+              if (!vm._attrsProxy) {
+                  var proxy = (vm._attrsProxy = {});
+                  def(proxy, '_v_attr_proxy', true);
+                  syncSetupProxy(proxy, vm.$attrs, emptyObject, vm, '$attrs');
+              }
+              return vm._attrsProxy;
+          },
+          get listeners() {
+              if (!vm._listenersProxy) {
+                  var proxy = (vm._listenersProxy = {});
+                  syncSetupProxy(proxy, vm.$listeners, emptyObject, vm, '$listeners');
+              }
+              return vm._listenersProxy;
           },
           get slots() {
               return initSlotsProxy(vm);
@@ -2304,20 +2316,12 @@
           }
       };
   }
-  function initAttrsProxy(vm) {
-      if (!vm._attrsProxy) {
-          var proxy = (vm._attrsProxy = {});
-          def(proxy, '_v_attr_proxy', true);
-          syncSetupAttrs(proxy, vm.$attrs, emptyObject, vm);
-      }
-      return vm._attrsProxy;
-  }
-  function syncSetupAttrs(to, from, prev, instance) {
+  function syncSetupProxy(to, from, prev, instance, type) {
       var changed = false;
       for (var key in from) {
           if (!(key in to)) {
               changed = true;
-              defineProxyAttr(to, key, instance);
+              defineProxyAttr(to, key, instance, type);
           }
           else if (from[key] !== prev[key]) {
               changed = true;
@@ -2331,12 +2335,12 @@
       }
       return changed;
   }
-  function defineProxyAttr(proxy, key, instance) {
+  function defineProxyAttr(proxy, key, instance, type) {
       Object.defineProperty(proxy, key, {
           enumerable: true,
           configurable: true,
           get: function () {
-              return instance.$attrs[key];
+              return instance[type][key];
           }
       });
   }
@@ -2357,17 +2361,27 @@
       }
   }
   /**
-   * @internal use manual type def
+   * @internal use manual type def because public setup context type relies on
+   * legacy VNode types
    */
   function useSlots() {
       return getContext().slots;
   }
   /**
-   * @internal use manual type def
+   * @internal use manual type def because public setup context type relies on
+   * legacy VNode types
    */
   function useAttrs() {
       return getContext().attrs;
   }
+  /**
+   * Vue 2 only
+   * @internal use manual type def because public setup context type relies on
+   * legacy VNode types
+   */
+  function useListeners() {
+      return getContext().listeners;
+  }
   function getContext() {
       if (!currentInstance) {
           warn$2("useContext() called without active instance.");
@@ -2411,7 +2425,9 @@
       var parentVnode = (vm.$vnode = options._parentVnode); // the placeholder node in parent tree
       var renderContext = parentVnode && parentVnode.context;
       vm.$slots = resolveSlots(options._renderChildren, renderContext);
-      vm.$scopedSlots = emptyObject;
+      vm.$scopedSlots = parentVnode
+          ? normalizeScopedSlots(vm.$parent, parentVnode.data.scopedSlots, vm.$slots)
+          : emptyObject;
       // bind the createElement fn to this instance
       // so that we get proper render context inside it.
       // args order: tag, data, children, normalizationType, alwaysNormalize
@@ -2445,7 +2461,7 @@
       Vue.prototype._render = function () {
           var vm = this;
           var _a = vm.$options, render = _a.render, _parentVnode = _a._parentVnode;
-          if (_parentVnode) {
+          if (_parentVnode && vm._isMounted) {
               vm.$scopedSlots = normalizeScopedSlots(vm.$parent, _parentVnode.data.scopedSlots, vm.$slots, vm.$scopedSlots);
               if (vm._slotsProxy) {
                   syncSetupSlots(vm._slotsProxy, vm.$scopedSlots);
@@ -2966,12 +2982,19 @@
       if (vm._attrsProxy) {
           // force update if attrs are accessed and has changed since it may be
           // passed to a child component.
-          if (syncSetupAttrs(vm._attrsProxy, attrs, (prevVNode.data && prevVNode.data.attrs) || emptyObject, vm)) {
+          if (syncSetupProxy(vm._attrsProxy, attrs, (prevVNode.data && prevVNode.data.attrs) || emptyObject, vm, '$attrs')) {
               needsForceUpdate = true;
           }
       }
       vm.$attrs = attrs;
-      vm.$listeners = listeners || emptyObject;
+      // update listeners
+      listeners = listeners || emptyObject;
+      var prevListeners = vm.$options._parentListeners;
+      if (vm._listenersProxy) {
+          syncSetupProxy(vm._listenersProxy, listeners, prevListeners || emptyObject, vm, '$listeners');
+      }
+      vm.$listeners = vm.$options._parentListeners = listeners;
+      updateComponentListeners(vm, listeners, prevListeners);
       // update props
       if (propsData && vm.$options.props) {
           toggleObserving(false);
@@ -2986,11 +3009,6 @@
           // keep a copy of raw propsData
           vm.$options.propsData = propsData;
       }
-      // update listeners
-      listeners = listeners || emptyObject;
-      var oldListeners = vm.$options._parentListeners;
-      vm.$options._parentListeners = listeners;
-      updateComponentListeners(vm, listeners, oldListeners);
       // resolve slots + force update if has children
       if (needsForceUpdate) {
           vm.$slots = resolveSlots(renderChildren, parentVnode.context);
@@ -3105,6 +3123,16 @@
           getNow = function () { return performance_1.now(); };
       }
   }
+  var sortCompareFn = function (a, b) {
+      if (a.post) {
+          if (!b.post)
+              return 1;
+      }
+      else if (b.post) {
+          return -1;
+      }
+      return a.id - b.id;
+  };
   /**
    * Flush both queues and run the watchers.
    */
@@ -3120,7 +3148,7 @@
       //    user watchers are created before the render watcher)
       // 3. If a component is destroyed during a parent component's watcher run,
       //    its watchers can be skipped.
-      queue.sort(function (a, b) { return a.id - b.id; });
+      queue.sort(sortCompareFn);
       // do not cache length because more watchers might be pushed
       // as we run existing watchers
       for (index$1 = 0; index$1 < queue.length; index$1++) {
@@ -3355,8 +3383,7 @@
       var oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE;
       // overwrite default run
       watcher.run = function () {
-          if (!watcher.active &&
-              !(flush === 'pre' && instance && instance._isBeingDestroyed)) {
+          if (!watcher.active) {
               return;
           }
           if (cb) {
@@ -3391,7 +3418,7 @@
           watcher.update = watcher.run;
       }
       else if (flush === 'post') {
-          watcher.id = Infinity;
+          watcher.post = true;
           watcher.update = function () { return queueWatcher(watcher); };
       }
       else {
@@ -3543,18 +3570,23 @@
           }
       }
       else {
-          var provides = currentInstance._provided;
-          // by default an instance inherits its parent's provides object
-          // but when it needs to provide values of its own, it creates its
-          // own provides object using parent provides object as prototype.
-          // this way in `inject` we can simply look up injections from direct
-          // parent and let the prototype chain do the work.
-          var parentProvides = currentInstance.$parent && currentInstance.$parent._provided;
-          if (parentProvides === provides) {
-              provides = currentInstance._provided = Object.create(parentProvides);
-          }
           // TS doesn't allow symbol as index type
-          provides[key] = value;
+          resolveProvided(currentInstance)[key] = value;
+      }
+  }
+  function resolveProvided(vm) {
+      // by default an instance inherits its parent's provides object
+      // but when it needs to provide values of its own, it creates its
+      // own provides object using parent provides object as prototype.
+      // this way in `inject` we can simply look up injections from direct
+      // parent and let the prototype chain do the work.
+      var existing = vm._provided;
+      var parentProvides = vm.$parent && vm.$parent._provided;
+      if (parentProvides === existing) {
+          return (vm._provided = Object.create(parentProvides));
+      }
+      else {
+          return existing;
       }
   }
   function inject(key, defaultValue, treatDefaultAsFactory) {
@@ -3914,17 +3946,21 @@
   var onUpdated = createLifeCycle('updated');
   var onBeforeUnmount = createLifeCycle('beforeDestroy');
   var onUnmounted = createLifeCycle('destroyed');
-  var onErrorCaptured = createLifeCycle('errorCaptured');
   var onActivated = createLifeCycle('activated');
   var onDeactivated = createLifeCycle('deactivated');
   var onServerPrefetch = createLifeCycle('serverPrefetch');
   var onRenderTracked = createLifeCycle('renderTracked');
-  var onRenderTriggered = createLifeCycle('renderTriggered');
+  var onRenderTriggered = createLifeCycle('renderTriggered');
+  var injectErrorCapturedHook = createLifeCycle('errorCaptured');
+  function onErrorCaptured(hook, target) {
+      if (target === void 0) { target = currentInstance; }
+      injectErrorCapturedHook(hook, target);
+  }
 
   /**
    * Note: also update dist/vue.runtime.mjs when adding new exports to this file.
    */
-  var version = '2.7.6';
+  var version = '2.7.9';
   /**
    * @internal type is manually declared in <root>/types/v3-define-component.d.ts
    */
@@ -3970,6 +4006,7 @@
     getCurrentInstance: getCurrentInstance,
     useSlots: useSlots,
     useAttrs: useAttrs,
+    useListeners: useListeners,
     mergeDefaults: mergeDefaults,
     nextTick: nextTick,
     set: set,
@@ -3983,12 +4020,12 @@
     onUpdated: onUpdated,
     onBeforeUnmount: onBeforeUnmount,
     onUnmounted: onUnmounted,
-    onErrorCaptured: onErrorCaptured,
     onActivated: onActivated,
     onDeactivated: onDeactivated,
     onServerPrefetch: onServerPrefetch,
     onRenderTracked: onRenderTracked,
-    onRenderTriggered: onRenderTriggered
+    onRenderTriggered: onRenderTriggered,
+    onErrorCaptured: onErrorCaptured
   });
 
   var seenObjects = new _Set();
@@ -4042,11 +4079,16 @@
    */
   var Watcher = /** @class */ (function () {
       function Watcher(vm, expOrFn, cb, options, isRenderWatcher) {
-          recordEffectScope(this, activeEffectScope || (vm ? vm._scope : undefined));
-          if ((this.vm = vm)) {
-              if (isRenderWatcher) {
-                  vm._watcher = this;
-              }
+          recordEffectScope(this, 
+          // if the active effect scope is manually created (not a component scope),
+          // prioritize it
+          activeEffectScope && !activeEffectScope._vm
+              ? activeEffectScope
+              : vm
+                  ? vm._scope
+                  : undefined);
+          if ((this.vm = vm) && isRenderWatcher) {
+              vm._watcher = this;
           }
           // options
           if (options) {
@@ -4066,6 +4108,7 @@
           this.cb = cb;
           this.id = ++uid$1; // uid for batching
           this.active = true;
+          this.post = false;
           this.dirty = this.lazy; // for lazy watchers
           this.deps = [];
           this.newDeps = [];
@@ -4313,7 +4356,7 @@
       if (!isPlainObject(data)) {
           data = {};
           warn$2('data functions should return an object:\n' +
-                  'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
+                  'https://v2.vuejs.org/v2/guide/components.html#data-Must-Be-a-Function', vm);
       }
       // proxy data on instance
       var keys = Object.keys(data);
@@ -4534,12 +4577,14 @@
           if (!isObject(provided)) {
               return;
           }
+          var source = resolveProvided(vm);
+          // IE9 doesn't support Object.getOwnPropertyDescriptors so we have to
+          // iterate the keys ourselves.
           var keys = hasSymbol ? Reflect.ownKeys(provided) : Object.keys(provided);
-          setCurrentInstance(vm);
           for (var i = 0; i < keys.length; i++) {
-              provide(keys[i], provided[keys[i]]);
+              var key = keys[i];
+              Object.defineProperty(source, key, Object.getOwnPropertyDescriptor(provided, key));
           }
-          setCurrentInstance();
       }
   }
   function initInjections(vm) {
@@ -4607,6 +4652,7 @@
           vm.__v_skip = true;
           // effect scope
           vm._scope = new EffectScope(true /* detached */);
+          vm._scope._vm = true;
           // merge options
           if (options && options._isComponent) {
               // optimize internal component instantiation
@@ -7156,7 +7202,16 @@
           }
           res[getRawDirName(dir)] = dir;
           if (vm._setupState && vm._setupState.__sfc) {
-              dir.def = dir.def || resolveAsset(vm, '_setupState', 'v-' + dir.name);
+              var setupDef = dir.def || resolveAsset(vm, '_setupState', 'v-' + dir.name);
+              if (typeof setupDef === 'function') {
+                  dir.def = {
+                      bind: setupDef,
+                      update: setupDef,
+                  };
+              }
+              else {
+                  dir.def = setupDef;
+              }
           }
           dir.def = dir.def || resolveAsset(vm.$options, 'directives', dir.name, true);
       }
@@ -10907,7 +10962,8 @@
           }
           else {
               var data = void 0;
-              if (!el.plain || (el.pre && state.maybeComponent(el))) {
+              var maybeComponent = state.maybeComponent(el);
+              if (!el.plain || (el.pre && maybeComponent)) {
                   data = genData(el, state);
               }
               var tag 
@@ -10915,11 +10971,8 @@
               = void 0;
               // check if this is a component in <script setup>
               var bindings = state.options.bindings;
-              if (bindings && bindings.__isScriptSetup !== false) {
-                  tag =
-                      checkBindingType(bindings, el.tag) ||
-                          checkBindingType(bindings, camelize(el.tag)) ||
-                          checkBindingType(bindings, capitalize(camelize(el.tag)));
+              if (maybeComponent && bindings && bindings.__isScriptSetup !== false) {
+                  tag = checkBindingType(bindings, el.tag);
               }
               if (!tag)
                   tag = "'".concat(el.tag, "'");
@@ -10936,9 +10989,29 @@
       }
   }
   function checkBindingType(bindings, key) {
-      var type = bindings[key];
-      if (type && type.startsWith('setup')) {
-          return key;
+      var camelName = camelize(key);
+      var PascalName = capitalize(camelName);
+      var checkType = function (type) {
+          if (bindings[key] === type) {
+              return key;
+          }
+          if (bindings[camelName] === type) {
+              return camelName;
+          }
+          if (bindings[PascalName] === type) {
+              return PascalName;
+          }
+      };
+      var fromConst = checkType("setup-const" /* BindingTypes.SETUP_CONST */) ||
+          checkType("setup-reactive-const" /* BindingTypes.SETUP_REACTIVE_CONST */);
+      if (fromConst) {
+          return fromConst;
+      }
+      var fromMaybeRef = checkType("setup-let" /* BindingTypes.SETUP_LET */) ||
+          checkType("setup-ref" /* BindingTypes.SETUP_REF */) ||
+          checkType("setup-maybe-ref" /* BindingTypes.SETUP_MAYBE_REF */);
+      if (fromMaybeRef) {
+          return fromMaybeRef;
       }
   }
   // hoist static sub-trees out