@vue/runtime-core 3.5.0-beta.1 → 3.5.0-beta.3

package/dist/runtime-core.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/runtime-core v3.5.0-beta.1
+* @vue/runtime-core v3.5.0-beta.3
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -137,12 +137,6 @@ const ErrorCodes = {
   "0": "SETUP_FUNCTION",
   "RENDER_FUNCTION": 1,
   "1": "RENDER_FUNCTION",
-  "WATCH_GETTER": 2,
-  "2": "WATCH_GETTER",
-  "WATCH_CALLBACK": 3,
-  "3": "WATCH_CALLBACK",
-  "WATCH_CLEANUP": 4,
-  "4": "WATCH_CLEANUP",
   "NATIVE_EVENT_HANDLER": 5,
   "5": "NATIVE_EVENT_HANDLER",
   "COMPONENT_EVENT_HANDLER": 6,
@@ -294,7 +288,7 @@ function nextTick(fn) {
   return fn ? p.then(this ? fn.bind(this) : fn) : p;
 }
 function findInsertionIndex(id) {
-  let start = flushIndex + 1;
+  let start = isFlushing ? flushIndex + 1 : 0;
   let end = queue.length;
   while (start < end) {
     const middle = start + end >>> 1;
@@ -310,15 +304,13 @@ function findInsertionIndex(id) {
 }
 function queueJob(job) {
   if (!(job.flags & 1)) {
-    if (job.id == null) {
-      queue.push(job);
-    } else if (
-      // fast path when the job id is larger than the tail
-      !(job.flags & 2) && job.id >= (queue[queue.length - 1] && queue[queue.length - 1].id || 0)
-    ) {
+    const jobId = getId(job);
+    const lastJob = queue[queue.length - 1];
+    if (!lastJob || // fast path when the job id is larger than the tail
+    !(job.flags & 2) && jobId >= getId(lastJob)) {
       queue.push(job);
     } else {
-      queue.splice(findInsertionIndex(job.id), 0, job);
+      queue.splice(findInsertionIndex(jobId), 0, job);
     }
     if (!(job.flags & 4)) {
       job.flags |= 1;
@@ -332,12 +324,6 @@ function queueFlush() {
     currentFlushPromise = resolvedPromise.then(flushJobs);
   }
 }
-function invalidateJob(job) {
-  const i = queue.indexOf(job);
-  if (i > flushIndex) {
-    queue.splice(i, 1);
-  }
-}
 function queuePostFlushCb(cb) {
   if (!shared.isArray(cb)) {
     if (activePostFlushCbs && cb.id === -1) {
@@ -399,24 +385,13 @@ function flushPostFlushCbs(seen) {
     postFlushIndex = 0;
   }
 }
-const getId = (job) => job.id == null ? Infinity : job.id;
-const comparator = (a, b) => {
-  const diff = getId(a) - getId(b);
-  if (diff === 0) {
-    const isAPre = a.flags & 2;
-    const isBPre = b.flags & 2;
-    if (isAPre && !isBPre) return -1;
-    if (isBPre && !isAPre) return 1;
-  }
-  return diff;
-};
+const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
 function flushJobs(seen) {
   isFlushPending = false;
   isFlushing = true;
   {
     seen = seen || /* @__PURE__ */ new Map();
   }
-  queue.sort(comparator);
   const check = (job) => checkRecursiveUpdates(seen, job) ;
   try {
     for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
@@ -744,7 +719,7 @@ function withDirectives(vnode, directives) {
         };
       }
       if (dir.deep) {
-        traverse(value);
+        reactivity.traverse(value);
       }
       bindings.push({
         dir,
@@ -1564,6 +1539,7 @@ const logMismatchError = () => {
 const isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject";
 const isMathMLContainer = (container) => container.namespaceURI.includes("MathML");
 const getContainerType = (container) => {
+  if (container.nodeType !== 1) return void 0;
   if (isSVGContainer(container)) return "svg";
   if (isMathMLContainer(container)) return "mathml";
   return void 0;
@@ -2492,7 +2468,7 @@ const KeepAliveImpl = {
     function pruneCache(filter) {
       cache.forEach((vnode, key) => {
         const name = getComponentName(vnode.type);
-        if (name && (!filter || !filter(name))) {
+        if (name && !filter(name)) {
           pruneCacheEntry(key);
         }
       });
@@ -2611,6 +2587,7 @@ function matches(pattern, name) {
   } else if (shared.isString(pattern)) {
     return pattern.split(",").includes(name);
   } else if (shared.isRegExp(pattern)) {
+    pattern.lastIndex = 0;
     return pattern.test(name);
   }
   return false;
@@ -3505,16 +3482,20 @@ function callHook(hook, instance, type) {
   );
 }
 function createWatcher(raw, ctx, publicThis, key) {
-  const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
+  let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
   if (shared.isString(raw)) {
     const handler = ctx[raw];
     if (shared.isFunction(handler)) {
-      watch(getter, handler);
+      {
+        watch(getter, handler);
+      }
     } else {
       warn$1(`Invalid watch handler specified by key "${raw}"`, handler);
     }
   } else if (shared.isFunction(raw)) {
-    watch(getter, raw.bind(publicThis));
+    {
+      watch(getter, raw.bind(publicThis));
+    }
   } else if (shared.isObject(raw)) {
     if (shared.isArray(raw)) {
       raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
@@ -4752,7 +4733,7 @@ function baseCreateRenderer(options, createHydrationFns) {
       if (subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
         subTree = filterSingleRoot(subTree.children) || subTree;
       }
-      if (vnode === subTree) {
+      if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
         const parentVNode = parentComponent.vnode;
         setScopeId(
           el,
@@ -5081,7 +5062,6 @@ function baseCreateRenderer(options, createHydrationFns) {
         return;
       } else {
         instance.next = n2;
-        invalidateJob(instance.update);
         instance.update();
       }
     } else {
@@ -5972,7 +5952,6 @@ function watchSyncEffect(effect, options) {
     shared.extend({}, options, { flush: "sync" }) 
   );
 }
-const INITIAL_WATCHER_VALUE = {};
 function watch(source, cb, options) {
   if (!shared.isFunction(cb)) {
     warn$1(
@@ -5981,21 +5960,8 @@ function watch(source, cb, options) {
   }
   return doWatch(source, cb, options);
 }
-function doWatch(source, cb, {
-  immediate,
-  deep,
-  flush,
-  once,
-  onTrack,
-  onTrigger
-} = shared.EMPTY_OBJ) {
-  if (cb && once) {
-    const _cb = cb;
-    cb = (...args) => {
-      _cb(...args);
-      watchHandle();
-    };
-  }
+function doWatch(source, cb, options = shared.EMPTY_OBJ) {
+  const { immediate, deep, flush, once } = options;
   if (!cb) {
     if (immediate !== void 0) {
       warn$1(
@@ -6013,164 +5979,53 @@ function doWatch(source, cb, {
       );
     }
   }
-  const warnInvalidSource = (s) => {
-    warn$1(
-      `Invalid watch source: `,
-      s,
-      `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
-    );
-  };
-  const instance = currentInstance;
-  const reactiveGetter = (source2) => {
-    if (deep) return source2;
-    if (reactivity.isShallow(source2) || deep === false || deep === 0)
-      return traverse(source2, 1);
-    return traverse(source2);
-  };
-  let getter;
-  let forceTrigger = false;
-  let isMultiSource = false;
-  if (reactivity.isRef(source)) {
-    getter = () => source.value;
-    forceTrigger = reactivity.isShallow(source);
-  } else if (reactivity.isReactive(source)) {
-    getter = () => reactiveGetter(source);
-    forceTrigger = true;
-  } else if (shared.isArray(source)) {
-    isMultiSource = true;
-    forceTrigger = source.some((s) => reactivity.isReactive(s) || reactivity.isShallow(s));
-    getter = () => source.map((s) => {
-      if (reactivity.isRef(s)) {
-        return s.value;
-      } else if (reactivity.isReactive(s)) {
-        return reactiveGetter(s);
-      } else if (shared.isFunction(s)) {
-        return callWithErrorHandling(s, instance, 2);
-      } else {
-        warnInvalidSource(s);
-      }
-    });
-  } else if (shared.isFunction(source)) {
-    if (cb) {
-      getter = () => callWithErrorHandling(source, instance, 2);
-    } else {
-      getter = () => {
-        if (cleanup) {
-          cleanup();
-        }
-        return callWithAsyncErrorHandling(
-          source,
-          instance,
-          3,
-          [onCleanup]
-        );
-      };
-    }
-  } else {
-    getter = shared.NOOP;
-    warnInvalidSource(source);
-  }
-  if (cb && deep) {
-    const baseGetter = getter;
-    const depth = deep === true ? Infinity : deep;
-    getter = () => traverse(baseGetter(), depth);
-  }
-  let cleanup;
-  let onCleanup = (fn) => {
-    cleanup = effect.onStop = () => {
-      callWithErrorHandling(fn, instance, 4);
-      cleanup = effect.onStop = void 0;
-    };
-  };
+  const baseWatchOptions = shared.extend({}, options);
+  baseWatchOptions.onWarn = warn$1;
   let ssrCleanup;
   if (isInSSRComponentSetup) {
-    onCleanup = shared.NOOP;
-    if (!cb) {
-      getter();
-    } else if (immediate) {
-      callWithAsyncErrorHandling(cb, instance, 3, [
-        getter(),
-        isMultiSource ? [] : void 0,
-        onCleanup
-      ]);
-    }
     if (flush === "sync") {
       const ctx = useSSRContext();
       ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
+    } else if (!cb || immediate) {
+      baseWatchOptions.once = true;
     } else {
-      const watchHandle2 = () => {
+      return {
+        stop: shared.NOOP,
+        resume: shared.NOOP,
+        pause: shared.NOOP
       };
-      watchHandle2.stop = shared.NOOP;
-      watchHandle2.resume = shared.NOOP;
-      watchHandle2.pause = shared.NOOP;
-      return watchHandle2;
     }
   }
-  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
-  const job = (immediateFirstRun) => {
-    if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) {
-      return;
-    }
-    if (cb) {
-      const newValue = effect.run();
-      if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => shared.hasChanged(v, oldValue[i])) : shared.hasChanged(newValue, oldValue)) || false) {
-        if (cleanup) {
-          cleanup();
-        }
-        callWithAsyncErrorHandling(cb, instance, 3, [
-          newValue,
-          // pass undefined as the old value when it's changed for the first time
-          oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
-          onCleanup
-        ]);
-        oldValue = newValue;
+  const instance = currentInstance;
+  baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
+  let isPre = false;
+  if (flush === "post") {
+    baseWatchOptions.scheduler = (job) => {
+      queuePostRenderEffect(job, instance && instance.suspense);
+    };
+  } else if (flush !== "sync") {
+    isPre = true;
+    baseWatchOptions.scheduler = (job, isFirstRun) => {
+      if (isFirstRun) {
+        job();
+      } else {
+        queueJob(job);
       }
-    } else {
-      effect.run();
-    }
-  };
-  if (cb) job.flags |= 4;
-  const effect = new reactivity.ReactiveEffect(getter);
-  let scheduler;
-  if (flush === "sync") {
-    effect.flags |= 64;
-    scheduler = job;
-  } else if (flush === "post") {
-    scheduler = () => queuePostRenderEffect(job, instance && instance.suspense);
-  } else {
-    job.flags |= 2;
-    if (instance) job.id = instance.uid;
-    scheduler = () => queueJob(job);
+    };
   }
-  effect.scheduler = scheduler;
-  const scope = reactivity.getCurrentScope();
-  const watchHandle = () => {
-    effect.stop();
-    if (scope) {
-      shared.remove(scope.effects, effect);
+  baseWatchOptions.augmentJob = (job) => {
+    if (cb) {
+      job.flags |= 4;
     }
-  };
-  watchHandle.pause = effect.pause.bind(effect);
-  watchHandle.resume = effect.resume.bind(effect);
-  watchHandle.stop = watchHandle;
-  {
-    effect.onTrack = onTrack;
-    effect.onTrigger = onTrigger;
-  }
-  if (cb) {
-    if (immediate) {
-      job(true);
-    } else {
-      oldValue = effect.run();
+    if (isPre) {
+      job.flags |= 2;
+      if (instance) {
+        job.id = instance.uid;
+        job.i = instance;
+      }
     }
-  } else if (flush === "post") {
-    queuePostRenderEffect(
-      effect.run.bind(effect),
-      instance && instance.suspense
-    );
-  } else {
-    effect.run();
-  }
+  };
+  const watchHandle = reactivity.watch(source, cb, baseWatchOptions);
   if (ssrCleanup) ssrCleanup.push(watchHandle);
   return watchHandle;
 }
@@ -6199,38 +6054,6 @@ function createPathGetter(ctx, path) {
     return cur;
   };
 }
-function traverse(value, depth = Infinity, seen) {
-  if (depth <= 0 || !shared.isObject(value) || value["__v_skip"]) {
-    return value;
-  }
-  seen = seen || /* @__PURE__ */ new Set();
-  if (seen.has(value)) {
-    return value;
-  }
-  seen.add(value);
-  depth--;
-  if (reactivity.isRef(value)) {
-    traverse(value.value, depth, seen);
-  } else if (shared.isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      traverse(value[i], depth, seen);
-    }
-  } else if (shared.isSet(value) || shared.isMap(value)) {
-    value.forEach((v) => {
-      traverse(v, depth, seen);
-    });
-  } else if (shared.isPlainObject(value)) {
-    for (const key in value) {
-      traverse(value[key], depth, seen);
-    }
-    for (const key of Object.getOwnPropertySymbols(value)) {
-      if (Object.prototype.propertyIsEnumerable.call(value, key)) {
-        traverse(value[key], depth, seen);
-      }
-    }
-  }
-  return value;
-}
 
 function useModel(props, name, options = shared.EMPTY_OBJ) {
   const i = getCurrentInstance();
@@ -8378,7 +8201,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.5.0-beta.1";
+const version = "3.5.0-beta.3";
 const warn = warn$1 ;
 const ErrorTypeStrings = ErrorTypeStrings$1 ;
 const devtools = devtools$1 ;
@@ -8406,6 +8229,7 @@ exports.customRef = reactivity.customRef;
 exports.effect = reactivity.effect;
 exports.effectScope = reactivity.effectScope;
 exports.getCurrentScope = reactivity.getCurrentScope;
+exports.getCurrentWatcher = reactivity.getCurrentWatcher;
 exports.isProxy = reactivity.isProxy;
 exports.isReactive = reactivity.isReactive;
 exports.isReadonly = reactivity.isReadonly;
@@ -8413,6 +8237,7 @@ exports.isRef = reactivity.isRef;
 exports.isShallow = reactivity.isShallow;
 exports.markRaw = reactivity.markRaw;
 exports.onScopeDispose = reactivity.onScopeDispose;
+exports.onWatcherCleanup = reactivity.onWatcherCleanup;
 exports.proxyRefs = reactivity.proxyRefs;
 exports.reactive = reactivity.reactive;
 exports.readonly = reactivity.readonly;