vue 2.7.1 → 2.7.4

package/dist/vue.runtime.js

@@ -1,5 +1,5 @@
 /*!
- * Vue.js v2.7.1
+ * Vue.js v2.7.4
  * (c) 2014-2022 Evan You
  * Released under the MIT License.
  */
@@ -330,7 +330,9 @@
       'activated',
       'deactivated',
       'errorCaptured',
-      'serverPrefetch'
+      'serverPrefetch',
+      'renderTracked',
+      'renderTriggered'
   ];
 
   var config = {
@@ -882,7 +884,7 @@
                   warn("Target is already a ".concat(existingOb.shallow ? "" : "non-", "shallow reactive object, and cannot be converted to ").concat(shallow ? "" : "non-", "shallow."));
               }
           }
-          var ob = observe(target, shallow);
+          var ob = observe(target, shallow, isServerRendering() /* ssr mock reactivity */);
           if (!ob) {
               if (target == null || isPrimitive(target)) {
                   warn("value cannot be made reactive: ".concat(String(target)));
@@ -944,7 +946,7 @@
       var ref = {};
       def(ref, RefFlag, true);
       def(ref, "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */, true);
-      ref.dep = defineReactive(ref, 'value', rawValue, null, shallow);
+      def(ref, 'dep', defineReactive(ref, 'value', rawValue, null, shallow, isServerRendering()));
       return ref;
   }
   function triggerRef(ref) {
@@ -1818,7 +1820,7 @@
           return tree;
       }
       // otherwise, render a fresh tree.
-      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, null, this // for render fns generated for functional component templates
+      tree = cached[index] = this.$options.staticRenderFns[index].call(this._renderProxy, this._c, this // for render fns generated for functional component templates
       );
       markStatic(tree, "__static__".concat(index), false);
       return tree;
@@ -3880,8 +3882,8 @@
       else {
           // pre
           watcher.update = function () {
-              if (instance && instance === currentInstance) {
-                  // pre-watcher triggered inside setup()
+              if (instance && instance === currentInstance && !instance._isMounted) {
+                  // pre-watcher triggered before
                   var buffer = instance._preWatchers || (instance._preWatchers = []);
                   if (buffer.indexOf(watcher) < 0)
                       buffer.push(watcher);
@@ -4141,6 +4143,78 @@
       });
   }
 
+  /**
+   * v3-compatible async component API.
+   * @internal the type is manually declared in <root>/types/v3-define-async-component.d.ts
+   * because it relies on existing manual types
+   */
+  function defineAsyncComponent(source) {
+      if (isFunction(source)) {
+          source = { loader: source };
+      }
+      var loader = source.loader, loadingComponent = source.loadingComponent, errorComponent = source.errorComponent, _a = source.delay, delay = _a === void 0 ? 200 : _a, timeout = source.timeout, // undefined = never times out
+      _b = source.suspensible, // undefined = never times out
+      suspensible = _b === void 0 ? false : _b, // in Vue 3 default is true
+      userOnError = source.onError;
+      if (suspensible) {
+          warn("The suspensiblbe option for async components is not supported in Vue2. It is ignored.");
+      }
+      var pendingRequest = null;
+      var retries = 0;
+      var retry = function () {
+          retries++;
+          pendingRequest = null;
+          return load();
+      };
+      var load = function () {
+          var thisRequest;
+          return (pendingRequest ||
+              (thisRequest = pendingRequest =
+                  loader()
+                      .catch(function (err) {
+                      err = err instanceof Error ? err : new Error(String(err));
+                      if (userOnError) {
+                          return new Promise(function (resolve, reject) {
+                              var userRetry = function () { return resolve(retry()); };
+                              var userFail = function () { return reject(err); };
+                              userOnError(err, userRetry, userFail, retries + 1);
+                          });
+                      }
+                      else {
+                          throw err;
+                      }
+                  })
+                      .then(function (comp) {
+                      if (thisRequest !== pendingRequest && pendingRequest) {
+                          return pendingRequest;
+                      }
+                      if (!comp) {
+                          warn("Async component loader resolved to undefined. " +
+                              "If you are using retry(), make sure to return its return value.");
+                      }
+                      // interop module default
+                      if (comp &&
+                          (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) {
+                          comp = comp.default;
+                      }
+                      if (comp && !isObject(comp) && !isFunction(comp)) {
+                          throw new Error("Invalid async component load result: ".concat(comp));
+                      }
+                      return comp;
+                  })));
+      };
+      return function () {
+          var component = load();
+          return {
+              component: component,
+              delay: delay,
+              timeout: timeout,
+              error: errorComponent,
+              loading: loadingComponent
+          };
+      };
+  }
+
   function createLifeCycle(hookName) {
       return function (fn, target) {
           if (target === void 0) { target = currentInstance; }
@@ -4179,7 +4253,10 @@
   var onRenderTracked = createLifeCycle('renderTracked');
   var onRenderTriggered = createLifeCycle('renderTriggered');
 
-  var version = '2.7.1';
+  /**
+   * Note: also update dist/vue.runtime.mjs when adding new exports to this file.
+   */
+  var version = '2.7.4';
   /**
    * @internal type is manually declared in <root>/types/v3-define-component.d.ts
    */
@@ -4231,6 +4308,7 @@
     del: del,
     useCssModule: useCssModule,
     useCssVars: useCssVars,
+    defineAsyncComponent: defineAsyncComponent,
     onBeforeMount: onBeforeMount,
     onMounted: onMounted,
     onBeforeUpdate: onBeforeUpdate,
@@ -4255,6 +4333,13 @@
   function toggleObserving(value) {
       shouldObserve = value;
   }
+  // ssr mock dep
+  var mockDep = {
+      notify: noop,
+      depend: noop,
+      addSub: noop,
+      removeSub: noop
+  };
   /**
    * Observer class that is attached to each observed
    * object. Once attached, the observer converts the target
@@ -4262,78 +4347,63 @@
    * collect dependencies and dispatch updates.
    */
   var Observer = /** @class */ (function () {
-      function Observer(value, shallow) {
+      function Observer(value, shallow, mock) {
           if (shallow === void 0) { shallow = false; }
+          if (mock === void 0) { mock = false; }
           this.value = value;
           this.shallow = shallow;
+          this.mock = mock;
           // this.value = value
-          this.dep = new Dep();
+          this.dep = mock ? mockDep : new Dep();
           this.vmCount = 0;
           def(value, '__ob__', this);
           if (isArray(value)) {
-              if (hasProto) {
-                  protoAugment(value, arrayMethods);
-              }
-              else {
-                  copyAugment(value, arrayMethods, arrayKeys);
+              if (!mock) {
+                  if (hasProto) {
+                      value.__proto__ = arrayMethods;
+                      /* eslint-enable no-proto */
+                  }
+                  else {
+                      for (var i = 0, l = arrayKeys.length; i < l; i++) {
+                          var key = arrayKeys[i];
+                          def(value, key, arrayMethods[key]);
+                      }
+                  }
               }
               if (!shallow) {
                   this.observeArray(value);
               }
           }
           else {
-              this.walk(value, shallow);
+              /**
+               * Walk through all properties and convert them into
+               * getter/setters. This method should only be called when
+               * value type is Object.
+               */
+              var keys = Object.keys(value);
+              for (var i = 0; i < keys.length; i++) {
+                  var key = keys[i];
+                  defineReactive(value, key, NO_INIITIAL_VALUE, undefined, shallow, mock);
+              }
           }
       }
-      /**
-       * Walk through all properties and convert them into
-       * getter/setters. This method should only be called when
-       * value type is Object.
-       */
-      Observer.prototype.walk = function (obj, shallow) {
-          var keys = Object.keys(obj);
-          for (var i = 0; i < keys.length; i++) {
-              var key = keys[i];
-              defineReactive(obj, key, NO_INIITIAL_VALUE, undefined, shallow);
-          }
-      };
       /**
        * Observe a list of Array items.
        */
-      Observer.prototype.observeArray = function (items) {
-          for (var i = 0, l = items.length; i < l; i++) {
-              observe(items[i]);
+      Observer.prototype.observeArray = function (value) {
+          for (var i = 0, l = value.length; i < l; i++) {
+              observe(value[i], false, this.mock);
           }
       };
       return Observer;
   }());
   // helpers
-  /**
-   * Augment a target Object or Array by intercepting
-   * the prototype chain using __proto__
-   */
-  function protoAugment(target, src) {
-      /* eslint-disable no-proto */
-      target.__proto__ = src;
-      /* eslint-enable no-proto */
-  }
-  /**
-   * Augment a target Object or Array by defining
-   * hidden properties.
-   */
-  /* istanbul ignore next */
-  function copyAugment(target, src, keys) {
-      for (var i = 0, l = keys.length; i < l; i++) {
-          var key = keys[i];
-          def(target, key, src[key]);
-      }
-  }
   /**
    * Attempt to create an observer instance for a value,
    * returns the new observer if successfully observed,
    * or the existing observer if the value already has one.
    */
-  function observe(value, shallow) {
+  function observe(value, shallow, ssrMockReactivity) {
       if (!isObject(value) || isRef(value) || value instanceof VNode) {
           return;
       }
@@ -4342,18 +4412,18 @@
           ob = value.__ob__;
       }
       else if (shouldObserve &&
-          !isServerRendering() &&
+          (ssrMockReactivity || !isServerRendering()) &&
           (isArray(value) || isPlainObject(value)) &&
           Object.isExtensible(value) &&
-          !value.__v_skip) {
-          ob = new Observer(value, shallow);
+          !value.__v_skip /* ReactiveFlags.SKIP */) {
+          ob = new Observer(value, shallow, ssrMockReactivity);
       }
       return ob;
   }
   /**
    * Define a reactive property on an Object.
    */
-  function defineReactive(obj, key, val, customSetter, shallow) {
+  function defineReactive(obj, key, val, customSetter, shallow, mock) {
       var dep = new Dep();
       var property = Object.getOwnPropertyDescriptor(obj, key);
       if (property && property.configurable === false) {
@@ -4366,7 +4436,7 @@
           (val === NO_INIITIAL_VALUE || arguments.length === 2)) {
           val = obj[key];
       }
-      var childOb = !shallow && observe(val);
+      var childOb = !shallow && observe(val, false, mock);
       Object.defineProperty(obj, key, {
           enumerable: true,
           configurable: true,
@@ -4411,7 +4481,7 @@
               else {
                   val = newVal;
               }
-              childOb = !shallow && observe(newVal);
+              childOb = !shallow && observe(newVal, false, mock);
               {
                   dep.notify({
                       type: "set" /* TriggerOpTypes.SET */,
@@ -4433,16 +4503,20 @@
           warn("Set operation on key \"".concat(key, "\" failed: target is readonly."));
           return;
       }
+      var ob = target.__ob__;
       if (isArray(target) && isValidArrayIndex(key)) {
           target.length = Math.max(target.length, key);
           target.splice(key, 1, val);
+          // when mocking for SSR, array methods are not hijacked
+          if (ob && !ob.shallow && ob.mock) {
+              observe(val, false, true);
+          }
           return val;
       }
       if (key in target && !(key in Object.prototype)) {
           target[key] = val;
           return val;
       }
-      var ob = target.__ob__;
       if (target._isVue || (ob && ob.vmCount)) {
           warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
                   'at runtime - declare it upfront in the data option.');
@@ -4452,7 +4526,7 @@
           target[key] = val;
           return val;
       }
-      defineReactive(ob.value, key, val);
+      defineReactive(ob.value, key, val, undefined, ob.shallow, ob.mock);
       {
           ob.dep.notify({
               type: "add" /* TriggerOpTypes.ADD */,
@@ -7055,7 +7129,7 @@
           }
           res[getRawDirName(dir)] = dir;
           if (vm._setupState && vm._setupState.__sfc) {
-              dir.def = resolveAsset(vm, '_setupState', 'v-' + dir.name);
+              dir.def = dir.def || resolveAsset(vm, '_setupState', 'v-' + dir.name);
           }
           dir.def = dir.def || resolveAsset(vm.$options, 'directives', dir.name, true);
       }