@vue/runtime-dom 3.6.0-alpha.3 → 3.6.0-alpha.5

package/dist/runtime-dom.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/runtime-dom v3.6.0-alpha.3
+* @vue/runtime-dom v3.6.0-alpha.5
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -763,12 +763,9 @@ const defineSSRCustomElement = (/* @__NO_SIDE_EFFECTS__ */ (options, extraOption
 });
 const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
 };
-class VueElement extends BaseClass {
-  constructor(_def, _props = {}, _createApp = createApp) {
+class VueElementBase extends BaseClass {
+  constructor(def, props = {}, createAppFn) {
     super();
-    this._def = _def;
-    this._props = _props;
-    this._createApp = _createApp;
     this._isVueCE = true;
     /**
      * @internal
@@ -778,28 +775,23 @@ class VueElement extends BaseClass {
      * @internal
      */
     this._app = null;
-    /**
-     * @internal
-     */
-    this._nonce = this._def.nonce;
     this._connected = false;
     this._resolved = false;
-    this._patching = false;
-    this._dirty = false;
     this._numberProps = null;
     this._styleChildren = /* @__PURE__ */ new WeakSet();
+    this._patching = false;
+    this._dirty = false;
     this._ob = null;
-    if (this.shadowRoot && _createApp !== createApp) {
+    this._def = def;
+    this._props = props;
+    this._createApp = createAppFn;
+    this._nonce = def.nonce;
+    if (this._needsHydration()) {
       this._root = this.shadowRoot;
     } else {
-      if (this.shadowRoot) {
-        runtimeCore.warn(
-          `Custom element has pre-rendered declarative shadow root but is not defined as hydratable. Use \`defineSSRCustomElement\`.`
-        );
-      }
-      if (_def.shadowRoot !== false) {
+      if (def.shadowRoot !== false) {
         this.attachShadow(
-          shared.extend({}, _def.shadowRootOptions, {
+          shared.extend({}, def.shadowRootOptions, {
             mode: "open"
           })
         );
@@ -817,14 +809,14 @@ class VueElement extends BaseClass {
     this._connected = true;
     let parent = this;
     while (parent = parent && (parent.parentNode || parent.host)) {
-      if (parent instanceof VueElement) {
+      if (parent instanceof VueElementBase) {
         this._parent = parent;
         break;
       }
     }
     if (!this._instance) {
       if (this._resolved) {
-        this._mount(this._def);
+        this._mountComponent(this._def);
       } else {
         if (parent && parent._pendingResolve) {
           this._pendingResolve = parent._pendingResolve.then(() => {
@@ -837,20 +829,6 @@ class VueElement extends BaseClass {
       }
     }
   }
-  _setParent(parent = this._parent) {
-    if (parent) {
-      this._instance.parent = parent._instance;
-      this._inheritParentContext(parent);
-    }
-  }
-  _inheritParentContext(parent = this._parent) {
-    if (parent && this._app) {
-      Object.setPrototypeOf(
-        this._app._context.provides,
-        parent._instance.provides
-      );
-    }
-  }
   disconnectedCallback() {
     this._connected = false;
     runtimeCore.nextTick(() => {
@@ -859,9 +837,7 @@ class VueElement extends BaseClass {
           this._ob.disconnect();
           this._ob = null;
         }
-        this._app && this._app.unmount();
-        if (this._instance) this._instance.ce = void 0;
-        this._app = this._instance = null;
+        this._unmount();
         if (this._teleportTargets) {
           this._teleportTargets.clear();
           this._teleportTargets = void 0;
@@ -869,6 +845,20 @@ class VueElement extends BaseClass {
       }
     });
   }
+  _setParent(parent = this._parent) {
+    if (parent && this._instance) {
+      this._instance.parent = parent._instance;
+      this._inheritParentContext(parent);
+    }
+  }
+  _inheritParentContext(parent = this._parent) {
+    if (parent && this._app) {
+      Object.setPrototypeOf(
+        this._app._context.provides,
+        parent._instance.provides
+      );
+    }
+  }
   _processMutations(mutations) {
     for (const m of mutations) {
       this._setAttr(m.attributeName);
@@ -886,7 +876,7 @@ class VueElement extends BaseClass {
     }
     this._ob = new MutationObserver(this._processMutations.bind(this));
     this._ob.observe(this, { attributes: true });
-    const resolve = (def, isAsync = false) => {
+    const resolve = (def) => {
       this._resolved = true;
       this._pendingResolve = void 0;
       const { props, styles } = def;
@@ -911,29 +901,25 @@ class VueElement extends BaseClass {
           "Custom element style injection is not supported when using shadowRoot: false"
         );
       }
-      this._mount(def);
+      this._mountComponent(def);
     };
     const asyncDef = this._def.__asyncLoader;
     if (asyncDef) {
+      const { configureApp } = this._def;
       this._pendingResolve = asyncDef().then((def) => {
-        def.configureApp = this._def.configureApp;
-        resolve(this._def = def, true);
+        def.configureApp = configureApp;
+        this._def = def;
+        resolve(def);
       });
     } else {
       resolve(this._def);
     }
   }
-  _mount(def) {
-    if (!def.name) {
-      def.name = "VueElement";
-    }
-    this._app = this._createApp(def);
-    this._inheritParentContext();
-    if (def.configureApp) {
-      def.configureApp(this._app);
-    }
-    this._app._ceVNode = this._createVNode();
-    this._app.mount(this._root);
+  _mountComponent(def) {
+    this._mount(def);
+    this._processExposed();
+  }
+  _processExposed() {
     const exposed = this._instance && this._instance.exposed;
     if (!exposed) return;
     for (const key in exposed) {
@@ -947,6 +933,38 @@ class VueElement extends BaseClass {
       }
     }
   }
+  _processInstance() {
+    this._instance.ce = this;
+    this._instance.isCE = true;
+    {
+      this._instance.ceReload = (newStyles) => {
+        if (this._styles) {
+          this._styles.forEach((s) => this._root.removeChild(s));
+          this._styles.length = 0;
+        }
+        this._applyStyles(newStyles);
+        if (!this._instance.vapor) {
+          this._instance = null;
+        }
+        this._update();
+      };
+    }
+    const dispatch = (event, args) => {
+      this.dispatchEvent(
+        new CustomEvent(
+          event,
+          shared.isPlainObject(args[0]) ? shared.extend({ detail: args }, args[0]) : { detail: args }
+        )
+      );
+    };
+    this._instance.emit = (event, ...args) => {
+      dispatch(event, args);
+      if (shared.hyphenate(event) !== event) {
+        dispatch(shared.hyphenate(event), args);
+      }
+    };
+    this._setParent();
+  }
   _resolveProps(def) {
     const { props } = def;
     const declaredPropKeys = shared.isArray(props) ? props : Object.keys(props || {});
@@ -992,7 +1010,7 @@ class VueElement extends BaseClass {
         delete this._props[key];
       } else {
         this._props[key] = val;
-        if (key === "key" && this._app) {
+        if (key === "key" && this._app && this._app._ceVNode) {
           this._app._ceVNode.key = val;
         }
       }
@@ -1016,52 +1034,6 @@ class VueElement extends BaseClass {
       }
     }
   }
-  _update() {
-    const vnode = this._createVNode();
-    if (this._app) vnode.appContext = this._app._context;
-    render(vnode, this._root);
-  }
-  _createVNode() {
-    const baseProps = {};
-    if (!this.shadowRoot) {
-      baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
-    }
-    const vnode = runtimeCore.createVNode(this._def, shared.extend(baseProps, this._props));
-    if (!this._instance) {
-      vnode.ce = (instance) => {
-        this._instance = instance;
-        instance.ce = this;
-        instance.isCE = true;
-        {
-          instance.ceReload = (newStyles) => {
-            if (this._styles) {
-              this._styles.forEach((s) => this._root.removeChild(s));
-              this._styles.length = 0;
-            }
-            this._applyStyles(newStyles);
-            this._instance = null;
-            this._update();
-          };
-        }
-        const dispatch = (event, args) => {
-          this.dispatchEvent(
-            new CustomEvent(
-              event,
-              shared.isPlainObject(args[0]) ? shared.extend({ detail: args }, args[0]) : { detail: args }
-            )
-          );
-        };
-        instance.emit = (event, ...args) => {
-          dispatch(event, args);
-          if (shared.hyphenate(event) !== event) {
-            dispatch(shared.hyphenate(event), args);
-          }
-        };
-        this._setParent();
-      };
-    }
-    return vnode;
-  }
   _applyStyles(styles, owner) {
     if (!styles) return;
     if (owner) {
@@ -1110,11 +1082,13 @@ class VueElement extends BaseClass {
   _renderSlots() {
     const outlets = this._getSlots();
     const scopeId = this._instance.type.__scopeId;
+    const slotReplacements = /* @__PURE__ */ new Map();
     for (let i = 0; i < outlets.length; i++) {
       const o = outlets[i];
       const slotName = o.getAttribute("name") || "default";
       const content = this._slots[slotName];
       const parent = o.parentNode;
+      const replacementNodes = [];
       if (content) {
         for (const n of content) {
           if (scopeId && n.nodeType === 1) {
@@ -1127,12 +1101,19 @@ class VueElement extends BaseClass {
             }
           }
           parent.insertBefore(n, o);
+          replacementNodes.push(n);
         }
       } else {
-        while (o.firstChild) parent.insertBefore(o.firstChild, o);
+        while (o.firstChild) {
+          const child = o.firstChild;
+          parent.insertBefore(child, o);
+          replacementNodes.push(child);
+        }
       }
       parent.removeChild(o);
+      slotReplacements.set(o, replacementNodes);
     }
+    this._updateSlotNodes(slotReplacements);
   }
   /**
    * @internal
@@ -1189,13 +1170,76 @@ class VueElement extends BaseClass {
     }
   }
 }
+class VueElement extends VueElementBase {
+  constructor(def, props = {}, createAppFn = createApp) {
+    super(def, props, createAppFn);
+  }
+  _needsHydration() {
+    if (this.shadowRoot && this._createApp !== createApp) {
+      return true;
+    } else {
+      if (this.shadowRoot) {
+        runtimeCore.warn(
+          `Custom element has pre-rendered declarative shadow root but is not defined as hydratable. Use \`defineSSRCustomElement\`.`
+        );
+      }
+    }
+    return false;
+  }
+  _mount(def) {
+    if (!def.name) {
+      def.name = "VueElement";
+    }
+    this._app = this._createApp(def);
+    this._inheritParentContext();
+    if (def.configureApp) {
+      def.configureApp(this._app);
+    }
+    this._app._ceVNode = this._createVNode();
+    this._app.mount(this._root);
+  }
+  _update() {
+    if (!this._app) return;
+    const vnode = this._createVNode();
+    vnode.appContext = this._app._context;
+    render(vnode, this._root);
+  }
+  _unmount() {
+    if (this._app) {
+      this._app.unmount();
+    }
+    if (this._instance && this._instance.ce) {
+      this._instance.ce = void 0;
+    }
+    this._app = this._instance = null;
+  }
+  /**
+   * Only called when shadowRoot is false
+   */
+  _updateSlotNodes(replacements) {
+  }
+  _createVNode() {
+    const baseProps = {};
+    if (!this.shadowRoot) {
+      baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
+    }
+    const vnode = runtimeCore.createVNode(this._def, shared.extend(baseProps, this._props));
+    if (!this._instance) {
+      vnode.ce = (instance) => {
+        this._instance = instance;
+        this._processInstance();
+      };
+    }
+    return vnode;
+  }
+}
 function useHost(caller) {
-  const instance = runtimeCore.getCurrentInstance();
-  const el = instance && instance.ce;
+  const { hasInstance, value } = runtimeCore.useInstanceOption("ce", true);
+  const el = value;
   if (el) {
     return el;
   } else {
-    if (!instance) {
+    if (!hasInstance) {
       runtimeCore.warn(
         `${caller || "useHost"} called without an active component instance.`
       );
@@ -1214,12 +1258,12 @@ function useShadowRoot() {
 
 function useCssModule(name = "$style") {
   {
-    const instance = runtimeCore.getCurrentInstance();
-    if (!instance) {
+    const { hasInstance, value: type } = runtimeCore.useInstanceOption("type", true);
+    if (!hasInstance) {
       runtimeCore.warn(`useCssModule must be called inside setup()`);
       return shared.EMPTY_OBJ;
     }
-    const modules = instance.type.__cssModules;
+    const modules = type.__cssModules;
     if (!modules) {
       runtimeCore.warn(`Current instance does not have CSS modules injected.`);
       return shared.EMPTY_OBJ;
@@ -1879,12 +1923,15 @@ const initDirectivesForSSR = () => {
 exports.Transition = Transition;
 exports.TransitionGroup = TransitionGroup;
 exports.VueElement = VueElement;
+exports.VueElementBase = VueElementBase;
 exports.createApp = createApp;
 exports.createSSRApp = createSSRApp;
 exports.defineCustomElement = defineCustomElement;
 exports.defineSSRCustomElement = defineSSRCustomElement;
 exports.hydrate = hydrate;
 exports.initDirectivesForSSR = initDirectivesForSSR;
+exports.nodeOps = nodeOps;
+exports.patchProp = patchProp;
 exports.render = render;
 exports.useCssModule = useCssModule;
 exports.useCssVars = useCssVars;