@vue/compat 3.2.27 → 3.2.28

package/dist/vue.cjs.prod.js

@@ -230,8 +230,20 @@ const SVG_TAGS = 'svg,animate,animateMotion,animateTransform,circle,clipPath,col
     'polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,' +
     'text,textPath,title,tspan,unknown,use,view';
 const VOID_TAGS = 'area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr';
+/**
+ * Compiler only.
+ * Do NOT use in runtime code paths unless behind `false` flag.
+ */
 const isHTMLTag = /*#__PURE__*/ makeMap(HTML_TAGS);
+/**
+ * Compiler only.
+ * Do NOT use in runtime code paths unless behind `false` flag.
+ */
 const isSVGTag = /*#__PURE__*/ makeMap(SVG_TAGS);
+/**
+ * Compiler only.
+ * Do NOT use in runtime code paths unless behind `false` flag.
+ */
 const isVoidTag = /*#__PURE__*/ makeMap(VOID_TAGS);
 
 const escapeRE = /["'&<>]/;
@@ -603,7 +615,7 @@ class ReactiveEffect {
         if (!this.active) {
             return this.fn();
         }
-        if (!effectStack.includes(this)) {
+        if (!effectStack.length || !effectStack.includes(this)) {
             try {
                 effectStack.push((activeEffect = this));
                 enableTracking();
@@ -847,6 +859,9 @@ function createGetter(isReadonly = false, shallow = false) {
         else if (key === "__v_isReadonly" /* IS_READONLY */) {
             return isReadonly;
         }
+        else if (key === "__v_isShallow" /* IS_SHALLOW */) {
+            return shallow;
+        }
         else if (key === "__v_raw" /* RAW */ &&
             receiver ===
                 (isReadonly
@@ -891,9 +906,14 @@ const shallowSet = /*#__PURE__*/ createSetter(true);
 function createSetter(shallow = false) {
     return function set(target, key, value, receiver) {
         let oldValue = target[key];
+        if (isReadonly(oldValue) && isRef(oldValue)) {
+            return false;
+        }
         if (!shallow && !isReadonly(value)) {
-            value = toRaw(value);
-            oldValue = toRaw(oldValue);
+            if (!isShallow(value)) {
+                value = toRaw(value);
+                oldValue = toRaw(oldValue);
+            }
             if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
                 oldValue.value = value;
                 return true;
@@ -1249,7 +1269,7 @@ function getTargetType(value) {
 }
 function reactive(target) {
     // if trying to observe a readonly proxy, return the readonly version.
-    if (target && target["__v_isReadonly" /* IS_READONLY */]) {
+    if (isReadonly(target)) {
         return target;
     }
     return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
@@ -1311,6 +1331,9 @@ function isReactive(value) {
 function isReadonly(value) {
     return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
 }
+function isShallow(value) {
+    return !!(value && value["__v_isShallow" /* IS_SHALLOW */]);
+}
 function isProxy(value) {
     return isReactive(value) || isReadonly(value);
 }
@@ -1360,22 +1383,22 @@ function createRef(rawValue, shallow) {
     return new RefImpl(rawValue, shallow);
 }
 class RefImpl {
-    constructor(value, _shallow) {
-        this._shallow = _shallow;
+    constructor(value, __v_isShallow) {
+        this.__v_isShallow = __v_isShallow;
         this.dep = undefined;
         this.__v_isRef = true;
-        this._rawValue = _shallow ? value : toRaw(value);
-        this._value = _shallow ? value : toReactive(value);
+        this._rawValue = __v_isShallow ? value : toRaw(value);
+        this._value = __v_isShallow ? value : toReactive(value);
     }
     get value() {
         trackRefValue(this);
         return this._value;
     }
     set value(newVal) {
-        newVal = this._shallow ? newVal : toRaw(newVal);
+        newVal = this.__v_isShallow ? newVal : toRaw(newVal);
         if (hasChanged(newVal, this._rawValue)) {
             this._rawValue = newVal;
-            this._value = this._shallow ? newVal : toReactive(newVal);
+            this._value = this.__v_isShallow ? newVal : toReactive(newVal);
             triggerRefValue(this);
         }
     }
@@ -1455,22 +1478,23 @@ class ComputedRefImpl {
     constructor(getter, _setter, isReadonly, isSSR) {
         this._setter = _setter;
         this.dep = undefined;
-        this._dirty = true;
         this.__v_isRef = true;
+        this._dirty = true;
         this.effect = new ReactiveEffect(getter, () => {
             if (!this._dirty) {
                 this._dirty = true;
                 triggerRefValue(this);
             }
         });
-        this.effect.active = !isSSR;
+        this.effect.computed = this;
+        this.effect.active = this._cacheable = !isSSR;
         this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
     }
     get value() {
         // the computed ref may get wrapped by other proxies e.g. readonly() #3376
         const self = toRaw(this);
         trackRefValue(self);
-        if (self._dirty) {
+        if (self._dirty || !self._cacheable) {
             self._dirty = false;
             self._value = self.effect.run();
         }
@@ -1996,6 +2020,7 @@ function emit(instance, event, args) {
 const compatModelEventPrefix = `onModelCompat:`;
 function convertLegacyVModelProps(vnode) {
     const { type, shapeFlag, props, dynamicProps } = vnode;
+    const comp = type;
     if (shapeFlag & 6 /* COMPONENT */ && props && 'modelValue' in props) {
         if (!isCompatEnabled("COMPONENT_V_MODEL" /* COMPONENT_V_MODEL */, 
         // this is a special case where we want to use the vnode component's
@@ -2007,7 +2032,9 @@ function convertLegacyVModelProps(vnode) {
         // v3 compiled model code -> v2 compat props
         // modelValue -> value
         // onUpdate:modelValue -> onModelCompat:input
-        const { prop = 'value', event = 'input' } = type.model || {};
+        const model = comp.model || {};
+        applyModelFromMixins(model, comp.mixins);
+        const { prop = 'value', event = 'input' } = model;
         if (prop !== 'modelValue') {
             props[prop] = props.modelValue;
             delete props.modelValue;
@@ -2020,6 +2047,16 @@ function convertLegacyVModelProps(vnode) {
         delete props['onUpdate:modelValue'];
     }
 }
+function applyModelFromMixins(model, mixins) {
+    if (mixins) {
+        mixins.forEach(m => {
+            if (m.model)
+                extend(model, m.model);
+            if (m.mixins)
+                applyModelFromMixins(model, m.mixins);
+        });
+    }
+}
 function compatModelEmit(instance, event, args) {
     if (!isCompatEnabled("COMPONENT_V_MODEL" /* COMPONENT_V_MODEL */, instance)) {
         return;
@@ -2853,7 +2890,7 @@ function inject(key, defaultValue, treatDefaultAsFactory = false) {
     if (instance) {
         // #2400
         // to support `app.use` plugins,
-        // fallback to appContext's `provides` if the intance is at root
+        // fallback to appContext's `provides` if the instance is at root
         const provides = instance.parent == null
             ? instance.vnode.appContext && instance.vnode.appContext.provides
             : instance.parent.provides;
@@ -2893,7 +2930,7 @@ function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EM
     let isMultiSource = false;
     if (isRef(source)) {
         getter = () => source.value;
-        forceTrigger = !!source._shallow;
+        forceTrigger = isShallow(source);
     }
     else if (isReactive(source)) {
         getter = () => source;
@@ -3766,7 +3803,7 @@ function matches(pattern, name) {
         return pattern.some((p) => matches(p, name));
     }
     else if (isString(pattern)) {
-        return pattern.split(',').indexOf(name) > -1;
+        return pattern.split(',').includes(name);
     }
     else if (pattern.test) {
         return pattern.test(name);
@@ -3962,7 +3999,7 @@ function applyOptions(instance) {
             const set = !isFunction(opt) && isFunction(opt.set)
                 ? opt.set.bind(publicThis)
                 : NOOP;
-            const c = computed({
+            const c = computed$1({
                 get,
                 set
             });
@@ -4412,7 +4449,9 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
         // attrs point to the same object so it should already have been updated.
         if (attrs !== rawCurrentProps) {
             for (const key in attrs) {
-                if (!rawProps || !hasOwn(rawProps, key)) {
+                if (!rawProps ||
+                    (!hasOwn(rawProps, key) &&
+                        (!hasOwn(rawProps, key + 'Native')))) {
                     delete attrs[key];
                     hasAttrsChanged = true;
                 }
@@ -4856,7 +4895,7 @@ function createCompatVue(createApp, createSingletonApp) {
             return vm;
         }
     }
-    Vue.version = "3.2.27";
+    Vue.version = `2.6.14-compat:${"3.2.28"}`;
     Vue.config = singletonApp.config;
     Vue.use = (p, ...options) => {
         if (p && isFunction(p.install)) {
@@ -7748,7 +7787,7 @@ function cloneVNode(vnode, extraProps, mergeRef = false) {
         shapeFlag: vnode.shapeFlag,
         // if the vnode is cloned with extra props, we can no longer assume its
         // existing patch flag to be reliable and need to add the FULL_PROPS flag.
-        // note: perserve flag for fragments since they use the flag for children
+        // note: preserve flag for fragments since they use the flag for children
         // fast paths only.
         patchFlag: extraProps && vnode.type !== Fragment
             ? patchFlag === -1 // hoisted node
@@ -7902,7 +7941,8 @@ function mergeProps(...args) {
             else if (isOn(key)) {
                 const existing = ret[key];
                 const incoming = toMerge[key];
-                if (existing !== incoming &&
+                if (incoming &&
+                    existing !== incoming &&
                     !(isArray(existing) && existing.includes(incoming))) {
                     ret[key] = existing
                         ? [].concat(existing, incoming)
@@ -8164,7 +8204,7 @@ function legacyCheckKeyCodes(instance, eventKeyCode, key, builtInKeyCode, eventK
 }
 function isKeyNotMatch(expect, actual) {
     if (isArray(expect)) {
-        return expect.indexOf(actual) === -1;
+        return !expect.includes(actual);
     }
     else {
         return expect !== actual;
@@ -8243,7 +8283,7 @@ function installCompatInstanceProperties(map) {
         extend(map, {
             // needed by many libs / render fns
             $vnode: i => i.vnode,
-            // inject addtional properties into $options for compat
+            // inject additional properties into $options for compat
             // e.g. vuex needs this.$options.parent
             $options: i => {
                 const res = extend({}, resolveMergedOptions(i));
@@ -8771,7 +8811,7 @@ function defineEmits() {
  * instance properties when it is accessed by a parent component via template
  * refs.
  *
- * `<script setup>` components are closed by default - i.e. varaibles inside
+ * `<script setup>` components are closed by default - i.e. variables inside
  * the `<script setup>` scope is not exposed to parent unless explicitly exposed
  * via `defineExpose`.
  *
@@ -8960,7 +9000,7 @@ function isMemoSame(cached, memo) {
 }
 
 // Core API ------------------------------------------------------------------
-const version = "3.2.27";
+const version = "3.2.28";
 const _ssrUtils = {
     createComponentInstance,
     setupComponent,
@@ -9394,7 +9434,7 @@ function patchStopImmediatePropagation(e, value) {
             originalStop.call(e);
             e._stopped = true;
         };
-        return value.map(fn => (e) => !e._stopped && fn(e));
+        return value.map(fn => (e) => !e._stopped && fn && fn(e));
     }
     else {
         return value;
@@ -10646,6 +10686,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   isProxy: isProxy,
   isReactive: isReactive,
   isReadonly: isReadonly,
+  isShallow: isShallow,
   customRef: customRef,
   triggerRef: triggerRef,
   shallowRef: shallowRef,
@@ -11865,7 +11906,7 @@ function parseAttributes(context, type) {
         }
         const attr = parseAttribute(context, attributeNames);
         // Trim whitespace between class
-        // https://github.com/vuejs/vue-next/issues/4251
+        // https://github.com/vuejs/core/issues/4251
         if (attr.type === 6 /* ATTRIBUTE */ &&
             attr.value &&
             attr.name === 'class') {
@@ -12098,7 +12139,7 @@ function parseTextData(context, length, mode) {
     advanceBy(context, length);
     if (mode === 2 /* RAWTEXT */ ||
         mode === 3 /* CDATA */ ||
-        rawText.indexOf('&') === -1) {
+        !rawText.includes('&')) {
         return rawText;
     }
     else {
@@ -13804,7 +13845,7 @@ function isReferenced(node, parent, grandparent) {
         // no: NODE.target
         case 'MetaProperty':
             return false;
-        // yes: type X = { somePropert: NODE }
+        // yes: type X = { someProperty: NODE }
         // no: type X = { NODE: OtherType }
         case 'ObjectTypeProperty':
             return parent.key !== node;
@@ -14295,6 +14336,7 @@ const transformFor = createStructuralDirectiveTransform('for', (node, dir, conte
         const renderExp = createCallExpression(helper(RENDER_LIST), [
             forNode.source
         ]);
+        const isTemplate = isTemplateNode(node);
         const memo = findDir(node, 'memo');
         const keyProp = findProp(node, `key`);
         const keyExp = keyProp &&
@@ -14302,15 +14344,17 @@ const transformFor = createStructuralDirectiveTransform('for', (node, dir, conte
                 ? createSimpleExpression(keyProp.value.content, true)
                 : keyProp.exp);
         const keyProperty = keyProp ? createObjectProperty(`key`, keyExp) : null;
-        if (context.prefixIdentifiers &&
-            keyProperty &&
-            keyProp.type !== 6 /* ATTRIBUTE */) {
-            // #2085 process :key expression needs to be processed in order for it
-            // to behave consistently for <template v-for> and <div v-for>.
-            // In the case of `<template v-for>`, the node is discarded and never
-            // traversed so its key expression won't be processed by the normal
-            // transforms.
-            keyProperty.value = processExpression(keyProperty.value, context);
+        if (isTemplate) {
+            // #2085 / #5288 process :key and v-memo expressions need to be
+            // processed on `<template v-for>`. In this case the node is discarded
+            // and never traversed so its binding expressions won't be processed
+            // by the normal transforms.
+            if (memo) {
+                memo.exp = processExpression(memo.exp, context);
+            }
+            if (keyProperty && keyProp.type !== 6 /* ATTRIBUTE */) {
+                keyProperty.value = processExpression(keyProperty.value, context);
+            }
         }
         const isStableFragment = forNode.source.type === 4 /* SIMPLE_EXPRESSION */ &&
             forNode.source.constType > 0 /* NOT_CONSTANT */;
@@ -14324,7 +14368,6 @@ const transformFor = createStructuralDirectiveTransform('for', (node, dir, conte
         return () => {
             // finish the codegen now that all children have been traversed
             let childBlock;
-            const isTemplate = isTemplateNode(node);
             const { children } = forNode;
             // check <template v-for> key placement
             if (isTemplate) {