@vue/server-renderer 3.6.0-alpha.6 → 3.6.0-beta.1

package/dist/server-renderer.esm-bundler.js

@@ -1,10 +1,10 @@
 /**
-* @vue/server-renderer v3.6.0-alpha.6
+* @vue/server-renderer v3.6.0-beta.1
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
 import { createVNode as createVNode$1, ssrUtils, ssrContextKey, warn as warn$2, Fragment as Fragment$1, Static, Comment as Comment$1, Text as Text$1, mergeProps as mergeProps$1, createApp, initDirectivesForSSR } from 'vue';
-import { makeMap, isOn, isRenderableAttrValue, isSVGTag, propsToAttrMap, isBooleanAttr, includeBooleanAttr, isSSRSafeAttrName, escapeHtml, normalizeClass, isString, normalizeStyle, stringifyStyle, isArray, isObject, normalizeCssVarValue, toDisplayString, isFunction, EMPTY_OBJ, extend, NOOP, looseEqual, looseIndexOf, escapeHtmlComment, isPromise, isVoidTag } from '@vue/shared';
+import { makeMap, isOn, isRenderableAttrValue, isSVGTag, propsToAttrMap, isBooleanAttr, includeBooleanAttr, isSSRSafeAttrName, escapeHtml, normalizeClass, isString, normalizeStyle, stringifyStyle, isArray, isObject, normalizeCssVarValue, toDisplayString, isFunction, EMPTY_OBJ, getGlobalThis, extend, NOOP, looseEqual, looseIndexOf, escapeHtmlComment, isPromise, isVoidTag } from '@vue/shared';
 export { includeBooleanAttr as ssrIncludeBooleanAttr } from '@vue/shared';
 
 const shouldIgnoreProp = /* @__PURE__ */ makeMap(
@@ -427,6 +427,318 @@ function logError(err, type, instance, throwInDev = true, throwInProd = false) {
   }
 }
 
+const jobs = [];
+let postJobs = [];
+let activePostJobs = null;
+let currentFlushPromise = null;
+let jobsLength = 0;
+let flushIndex = 0;
+let postFlushIndex = 0;
+const resolvedPromise = /* @__PURE__ */ Promise.resolve();
+const RECURSION_LIMIT = 100;
+function nextTick(fn) {
+  const p = currentFlushPromise || resolvedPromise;
+  return fn ? p.then(this ? fn.bind(this) : fn) : p;
+}
+function findInsertionIndex(order, queue, start, end) {
+  while (start < end) {
+    const middle = start + end >>> 1;
+    if (queue[middle].order <= order) {
+      start = middle + 1;
+    } else {
+      end = middle;
+    }
+  }
+  return start;
+}
+function queueJob(job, id, isPre = false) {
+  if (queueJobWorker(
+    job,
+    isPre ? -2 : Infinity ,
+    jobs,
+    jobsLength,
+    flushIndex
+  )) {
+    jobsLength++;
+    queueFlush();
+  }
+}
+function queueJobWorker(job, order, queue, length, flushIndex2) {
+  const flags = job.flags;
+  if (!(flags & 1)) {
+    job.flags = flags | 1;
+    job.order = order;
+    if (flushIndex2 === length || // fast path when the job id is larger than the tail
+    order >= queue[length - 1].order) {
+      queue[length] = job;
+    } else {
+      queue.splice(findInsertionIndex(order, queue, flushIndex2, length), 0, job);
+    }
+    return true;
+  }
+  return false;
+}
+const doFlushJobs = () => {
+  try {
+    flushJobs();
+  } catch (e) {
+    currentFlushPromise = null;
+    throw e;
+  }
+};
+function queueFlush() {
+  if (!currentFlushPromise) {
+    currentFlushPromise = resolvedPromise.then(doFlushJobs);
+  }
+}
+function queuePostFlushCb(jobs2, id = Infinity) {
+  if (!isArray(jobs2)) {
+    if (activePostJobs && id === -1) {
+      activePostJobs.splice(postFlushIndex, 0, jobs2);
+    } else {
+      queueJobWorker(jobs2, id, postJobs, postJobs.length, 0);
+    }
+  } else {
+    for (const job of jobs2) {
+      queueJobWorker(job, id, postJobs, postJobs.length, 0);
+    }
+  }
+  queueFlush();
+}
+function flushPostFlushCbs(seen) {
+  if (postJobs.length) {
+    if (activePostJobs) {
+      activePostJobs.push(...postJobs);
+      postJobs.length = 0;
+      return;
+    }
+    activePostJobs = postJobs;
+    postJobs = [];
+    if (!!(process.env.NODE_ENV !== "production")) {
+      seen = seen || /* @__PURE__ */ new Map();
+    }
+    while (postFlushIndex < activePostJobs.length) {
+      const cb = activePostJobs[postFlushIndex++];
+      if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
+        continue;
+      }
+      if (cb.flags & 2) {
+        cb.flags &= -2;
+      }
+      if (!(cb.flags & 4)) {
+        try {
+          cb();
+        } finally {
+          cb.flags &= -2;
+        }
+      }
+    }
+    activePostJobs = null;
+    postFlushIndex = 0;
+  }
+}
+function flushJobs(seen) {
+  if (!!(process.env.NODE_ENV !== "production")) {
+    seen || (seen = /* @__PURE__ */ new Map());
+  }
+  try {
+    while (flushIndex < jobsLength) {
+      const job = jobs[flushIndex];
+      jobs[flushIndex++] = void 0;
+      if (!(job.flags & 4)) {
+        if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, job)) {
+          continue;
+        }
+        if (job.flags & 2) {
+          job.flags &= ~1;
+        }
+        try {
+          job();
+        } catch (err) {
+          handleError(
+            err,
+            job.i,
+            job.i ? 15 : 14
+          );
+        } finally {
+          if (!(job.flags & 2)) {
+            job.flags &= ~1;
+          }
+        }
+      }
+    }
+  } finally {
+    while (flushIndex < jobsLength) {
+      jobs[flushIndex].flags &= -2;
+      jobs[flushIndex++] = void 0;
+    }
+    flushIndex = 0;
+    jobsLength = 0;
+    flushPostFlushCbs(seen);
+    currentFlushPromise = null;
+    if (jobsLength || postJobs.length) {
+      flushJobs(seen);
+    }
+  }
+}
+function checkRecursiveUpdates(seen, fn) {
+  const count = seen.get(fn) || 0;
+  if (count > RECURSION_LIMIT) {
+    const instance = fn.i;
+    const componentName = instance && getComponentName(instance.type);
+    handleError(
+      `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,
+      null,
+      10
+    );
+    return true;
+  }
+  seen.set(fn, count + 1);
+  return false;
+}
+
+let isHmrUpdating = false;
+const hmrDirtyComponents = /* @__PURE__ */ new Map();
+const hmrDirtyComponentsMode = /* @__PURE__ */ new Map();
+if (!!(process.env.NODE_ENV !== "production")) {
+  getGlobalThis().__VUE_HMR_RUNTIME__ = {
+    createRecord: tryWrap(createRecord),
+    rerender: tryWrap(rerender),
+    reload: tryWrap(reload)
+  };
+}
+const map = /* @__PURE__ */ new Map();
+function createRecord(id, initialDef) {
+  if (map.has(id)) {
+    return false;
+  }
+  map.set(id, {
+    initialDef: normalizeClassComponent(initialDef),
+    instances: /* @__PURE__ */ new Set()
+  });
+  return true;
+}
+function normalizeClassComponent(component) {
+  return isClassComponent(component) ? component.__vccOpts : component;
+}
+function rerender(id, newRender) {
+  const record = map.get(id);
+  if (!record) {
+    return;
+  }
+  record.initialDef.render = newRender;
+  [...record.instances].forEach((instance) => {
+    if (newRender) {
+      instance.render = newRender;
+      normalizeClassComponent(instance.type).render = newRender;
+    }
+    isHmrUpdating = true;
+    if (instance.vapor) {
+      if (!instance.isUnmounted) instance.hmrRerender();
+    } else {
+      const i = instance;
+      if (!(i.effect.flags & 1024)) {
+        i.renderCache = [];
+        i.effect.run();
+      }
+    }
+    nextTick(() => {
+      isHmrUpdating = false;
+    });
+  });
+}
+function reload(id, newComp) {
+  const record = map.get(id);
+  if (!record) return;
+  newComp = normalizeClassComponent(newComp);
+  const isVapor = record.initialDef.__vapor;
+  updateComponentDef(record.initialDef, newComp);
+  const instances = [...record.instances];
+  if (isVapor && newComp.__vapor && !instances.some((i) => i.ceReload)) {
+    for (const instance of instances) {
+      if (instance.root && instance.root.ce && instance !== instance.root) {
+        instance.root.ce._removeChildStyle(instance.type);
+      }
+    }
+    for (const instance of instances) {
+      instance.hmrReload(newComp);
+    }
+  } else {
+    for (const instance of instances) {
+      const oldComp = normalizeClassComponent(instance.type);
+      let dirtyInstances = hmrDirtyComponents.get(oldComp);
+      if (!dirtyInstances) {
+        if (oldComp !== record.initialDef) {
+          updateComponentDef(oldComp, newComp);
+        }
+        hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
+      }
+      dirtyInstances.add(instance);
+      hmrDirtyComponentsMode.set(oldComp, !!isVapor);
+      instance.appContext.propsCache.delete(instance.type);
+      instance.appContext.emitsCache.delete(instance.type);
+      instance.appContext.optionsCache.delete(instance.type);
+      if (instance.ceReload) {
+        dirtyInstances.add(instance);
+        instance.ceReload(newComp.styles);
+        dirtyInstances.delete(instance);
+      } else if (instance.parent) {
+        queueJob(() => {
+          isHmrUpdating = true;
+          const parent = instance.parent;
+          if (parent.vapor) {
+            parent.hmrRerender();
+          } else {
+            if (!(parent.effect.flags & 1024)) {
+              parent.renderCache = [];
+              parent.effect.run();
+            }
+          }
+          nextTick(() => {
+            isHmrUpdating = false;
+          });
+          dirtyInstances.delete(instance);
+        });
+      } else if (instance.appContext.reload) {
+        instance.appContext.reload();
+      } else if (typeof window !== "undefined") {
+        window.location.reload();
+      } else {
+        console.warn(
+          "[HMR] Root or manually mounted instance modified. Full reload required."
+        );
+      }
+      if (instance.root.ce && instance !== instance.root) {
+        instance.root.ce._removeChildStyle(oldComp);
+      }
+    }
+  }
+  queuePostFlushCb(() => {
+    hmrDirtyComponents.clear();
+    hmrDirtyComponentsMode.clear();
+  });
+}
+function updateComponentDef(oldComp, newComp) {
+  extend(oldComp, newComp);
+  for (const key in oldComp) {
+    if (key !== "__file" && !(key in newComp)) {
+      delete oldComp[key];
+    }
+  }
+}
+function tryWrap(fn) {
+  return (id, arg) => {
+    try {
+      return fn(id, arg);
+    } catch (e) {
+      console.error(e);
+      console.warn(
+        `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
+      );
+    }
+  };
+}
+
 let devtools;
 let buffer = [];
 function setDevtoolsHook(hook, target) {
@@ -467,7 +779,7 @@ const isTeleport = (type) => type.__isTeleport;
 
 function setTransitionHooks(vnode, hooks) {
   if (vnode.shapeFlag & 6 && vnode.component) {
-    if (vnode.type.__vapor) {
+    if (isVaporComponent(vnode.type)) {
       getVaporInterface(vnode.component, vnode).setTransitionHooks(
         vnode.component,
         hooks
@@ -484,7 +796,7 @@ function setTransitionHooks(vnode, hooks) {
   }
 }
 
-const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+const NULL_DYNAMIC_COMPONENT = /* @__PURE__ */ Symbol.for("v-ndc");
 
 const internalObjectProto = {};
 const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
@@ -503,12 +815,18 @@ app.use(vaporInteropPlugin)
   }
   return res;
 }
+function isVaporComponent(type) {
+  if (!!(process.env.NODE_ENV !== "production") && isHmrUpdating && hmrDirtyComponentsMode.has(type)) {
+    return hmrDirtyComponentsMode.get(type);
+  }
+  return type.__vapor;
+}
 
 const isSuspense = (type) => type.__isSuspense;
 
-const Fragment = Symbol.for("v-fgt");
-const Text = Symbol.for("v-txt");
-const Comment = Symbol.for("v-cmt");
+const Fragment = /* @__PURE__ */ Symbol.for("v-fgt");
+const Text = /* @__PURE__ */ Symbol.for("v-txt");
+const Comment = /* @__PURE__ */ Symbol.for("v-cmt");
 function isVNode$2(value) {
   return value ? value.__v_isVNode === true : false;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/server-renderer",
-  "version": "3.6.0-alpha.6",
+  "version": "3.6.0-beta.1",
   "description": "@vue/server-renderer",
   "main": "index.js",
   "module": "dist/server-renderer.esm-bundler.js",
@@ -46,10 +46,10 @@
   },
   "homepage": "https://github.com/vuejs/core/tree/main/packages/server-renderer#readme",
   "peerDependencies": {
-    "vue": "3.6.0-alpha.6"
+    "vue": "3.6.0-beta.1"
   },
   "dependencies": {
-    "@vue/compiler-ssr": "3.6.0-alpha.6",
-    "@vue/shared": "3.6.0-alpha.6"
+    "@vue/compiler-ssr": "3.6.0-beta.1",
+    "@vue/shared": "3.6.0-beta.1"
   }
 }