vue 2.7.1 → 2.7.4

package/dist/vue.common.dev.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.
  */
@@ -336,7 +336,9 @@ const LIFECYCLE_HOOKS = [
     'activated',
     'deactivated',
     'errorCaptured',
-    'serverPrefetch'
+    'serverPrefetch',
+    'renderTracked',
+    'renderTriggered'
 ];
 
 var config = {
@@ -844,7 +846,7 @@ function makeReactive(target, shallow) {
                 warn$2(`Target is already a ${existingOb.shallow ? `` : `non-`}shallow reactive object, and cannot be converted to ${shallow ? `` : `non-`}shallow.`);
             }
         }
-        const ob = observe(target, shallow);
+        const ob = observe(target, shallow, isServerRendering() /* ssr mock reactivity */);
         if (!ob) {
             if (target == null || isPrimitive(target)) {
                 warn$2(`value cannot be made reactive: ${String(target)}`);
@@ -906,7 +908,7 @@ function createRef(rawValue, shallow) {
     const 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) {
@@ -2526,7 +2528,7 @@ function renderStatic(index, isInFor) {
         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$1(tree, `__static__${index}`, false);
     return tree;
@@ -4299,8 +4301,8 @@ function doWatch(source, cb, { immediate, deep, flush = 'pre', onTrack, onTrigge
     else {
         // pre
         watcher.update = () => {
-            if (instance && instance === currentInstance) {
-                // pre-watcher triggered inside setup()
+            if (instance && instance === currentInstance && !instance._isMounted) {
+                // pre-watcher triggered before
                 const buffer = instance._preWatchers || (instance._preWatchers = []);
                 if (buffer.indexOf(watcher) < 0)
                     buffer.push(watcher);
@@ -4566,6 +4568,77 @@ function useCssVars(getter) {
     });
 }
 
+/**
+ * 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 };
+    }
+    const { loader, loadingComponent, errorComponent, delay = 200, timeout, // undefined = never times out
+    suspensible = false, // in Vue 3 default is true
+    onError: userOnError } = source;
+    if (suspensible) {
+        warn$2(`The suspensiblbe option for async components is not supported in Vue2. It is ignored.`);
+    }
+    let pendingRequest = null;
+    let retries = 0;
+    const retry = () => {
+        retries++;
+        pendingRequest = null;
+        return load();
+    };
+    const load = () => {
+        let thisRequest;
+        return (pendingRequest ||
+            (thisRequest = pendingRequest =
+                loader()
+                    .catch(err => {
+                    err = err instanceof Error ? err : new Error(String(err));
+                    if (userOnError) {
+                        return new Promise((resolve, reject) => {
+                            const userRetry = () => resolve(retry());
+                            const userFail = () => reject(err);
+                            userOnError(err, userRetry, userFail, retries + 1);
+                        });
+                    }
+                    else {
+                        throw err;
+                    }
+                })
+                    .then((comp) => {
+                    if (thisRequest !== pendingRequest && pendingRequest) {
+                        return pendingRequest;
+                    }
+                    if (!comp) {
+                        warn$2(`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: ${comp}`);
+                    }
+                    return comp;
+                })));
+    };
+    return () => {
+        const component = load();
+        return {
+            component,
+            delay,
+            timeout,
+            error: errorComponent,
+            loading: loadingComponent
+        };
+    };
+}
+
 function createLifeCycle(hookName) {
     return (fn, target = currentInstance) => {
         if (!target) {
@@ -4603,7 +4676,10 @@ const onServerPrefetch = createLifeCycle('serverPrefetch');
 const onRenderTracked = createLifeCycle('renderTracked');
 const onRenderTriggered = createLifeCycle('renderTriggered');
 
-const version = '2.7.1';
+/**
+ * Note: also update dist/vue.runtime.mjs when adding new exports to this file.
+ */
+const version = '2.7.4';
 /**
  * @internal type is manually declared in <root>/types/v3-define-component.d.ts
  */
@@ -4655,6 +4731,7 @@ var vca = /*#__PURE__*/Object.freeze({
   del: del,
   useCssModule: useCssModule,
   useCssVars: useCssVars,
+  defineAsyncComponent: defineAsyncComponent,
   onBeforeMount: onBeforeMount,
   onMounted: onMounted,
   onBeforeUpdate: onBeforeUpdate,
@@ -4679,6 +4756,13 @@ let shouldObserve = true;
 function toggleObserving(value) {
     shouldObserve = value;
 }
+// ssr mock dep
+const 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
@@ -4686,76 +4770,60 @@ function toggleObserving(value) {
  * collect dependencies and dispatch updates.
  */
 class Observer {
-    constructor(value, shallow = false) {
+    constructor(value, shallow = false, 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 (let i = 0, l = arrayKeys.length; i < l; i++) {
+                        const 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.
-     */
-    walk(obj, shallow) {
-        const keys = Object.keys(obj);
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            defineReactive(obj, key, NO_INIITIAL_VALUE, undefined, shallow);
+            /**
+             * Walk through all properties and convert them into
+             * getter/setters. This method should only be called when
+             * value type is Object.
+             */
+            const keys = Object.keys(value);
+            for (let i = 0; i < keys.length; i++) {
+                const key = keys[i];
+                defineReactive(value, key, NO_INIITIAL_VALUE, undefined, shallow, mock);
+            }
         }
     }
     /**
      * Observe a list of Array items.
      */
-    observeArray(items) {
-        for (let i = 0, l = items.length; i < l; i++) {
-            observe(items[i]);
+    observeArray(value) {
+        for (let i = 0, l = value.length; i < l; i++) {
+            observe(value[i], false, this.mock);
         }
     }
 }
 // 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 (let i = 0, l = keys.length; i < l; i++) {
-        const 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;
     }
@@ -4764,18 +4832,18 @@ function observe(value, shallow) {
         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) {
     const dep = new Dep();
     const property = Object.getOwnPropertyDescriptor(obj, key);
     if (property && property.configurable === false) {
@@ -4788,7 +4856,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
         (val === NO_INIITIAL_VALUE || arguments.length === 2)) {
         val = obj[key];
     }
-    let childOb = !shallow && observe(val);
+    let childOb = !shallow && observe(val, false, mock);
     Object.defineProperty(obj, key, {
         enumerable: true,
         configurable: true,
@@ -4833,7 +4901,7 @@ function defineReactive(obj, key, val, customSetter, shallow) {
             else {
                 val = newVal;
             }
-            childOb = !shallow && observe(newVal);
+            childOb = !shallow && observe(newVal, false, mock);
             {
                 dep.notify({
                     type: "set" /* TriggerOpTypes.SET */,
@@ -4855,16 +4923,20 @@ function set(target, key, val) {
         warn$2(`Set operation on key "${key}" failed: target is readonly.`);
         return;
     }
+    const 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;
     }
-    const ob = target.__ob__;
     if (target._isVue || (ob && ob.vmCount)) {
         warn$2('Avoid adding reactive properties to a Vue instance or its root $data ' +
                 'at runtime - declare it upfront in the data option.');
@@ -4874,7 +4946,7 @@ function set(target, key, val) {
         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 */,
@@ -6991,7 +7063,7 @@ function normalizeDirectives(dirs, vm) {
         }
         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);
     }