@qwik.dev/core 2.0.0-beta.24 → 2.0.0-beta.25

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.24-dev+314726b
+ * @qwik.dev/core 2.0.0-beta.25-dev+2677279
  * Copyright QwikDev. All Rights Reserved.
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/QwikDev/qwik/blob/main/LICENSE
@@ -1007,7 +1007,7 @@ const COMMA = ',';
  *
  * @public
  */
-const version = "2.0.0-beta.24-dev+314726b";
+const version = "2.0.0-beta.25-dev+2677279";
 
 // keep this import from core/build so the cjs build works
 const createPlatform = () => {
@@ -3068,6 +3068,14 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
                     }
                     delete constProps[k];
                 }
+                else if (k === BIND_CHECKED) {
+                    // Set flag, will process after walk
+                    bindCheckedSignal = constProps[k];
+                }
+                else if (k === BIND_VALUE) {
+                    // Set flag, will process after walk
+                    bindValueSignal = constProps[k];
+                }
                 processedKeys.add(k);
             }
         }
@@ -3097,44 +3105,65 @@ const _jsxSplit = (type, varProps, constProps, children, flags, key, dev) => {
                 }
                 processedKeys.add(k);
             }
-            // Handle bind:* - only in varProps, bind:* should be moved to varProps
-            if (bindCheckedSignal || bindValueSignal) {
-                if (!varPropsCopied) {
-                    varProps = { ...varProps };
-                    varPropsCopied = true;
-                }
-                if (bindCheckedSignal) {
+        }
+        // Handle bind:* - only in varProps, bind:* should be moved to varProps
+        if (bindCheckedSignal || bindValueSignal) {
+            if (!varPropsCopied) {
+                varProps = { ...varProps };
+                varPropsCopied = true;
+            }
+            varProps ||= {};
+            if (bindCheckedSignal) {
+                // Delete from both varProps and constProps if present
+                if (varProps && _hasOwnProperty$1.call(varProps, BIND_CHECKED)) {
                     delete varProps[BIND_CHECKED];
-                    varProps.checked = bindCheckedSignal;
-                    const handler = createQRL(null, '_chk', _chk, null, [bindCheckedSignal]);
-                    // Move q-e:input from constProps if it exists
-                    if (constProps && _hasOwnProperty$1.call(constProps, 'q-e:input')) {
-                        if (!constPropsCopied) {
-                            constProps = { ...constProps };
-                            constPropsCopied = true;
-                        }
-                        const existingHandler = constProps['q-e:input'];
-                        delete constProps['q-e:input'];
-                        toSort = mergeHandlers(varProps, 'q-e:input', existingHandler) || toSort;
+                }
+                if (constProps && _hasOwnProperty$1.call(constProps, BIND_CHECKED)) {
+                    if (!constPropsCopied) {
+                        constProps = { ...constProps };
+                        constPropsCopied = true;
                     }
-                    toSort = mergeHandlers(varProps, 'q-e:input', handler) || toSort;
+                    delete constProps[BIND_CHECKED];
                 }
-                else if (bindValueSignal) {
+                varProps.checked = bindCheckedSignal;
+                const handler = createQRL(null, '_chk', _chk, null, [bindCheckedSignal]);
+                // Move q-e:input from constProps if it exists
+                if (constProps && _hasOwnProperty$1.call(constProps, 'q-e:input')) {
+                    if (!constPropsCopied) {
+                        constProps = { ...constProps };
+                        constPropsCopied = true;
+                    }
+                    const existingHandler = constProps['q-e:input'];
+                    delete constProps['q-e:input'];
+                    toSort = mergeHandlers(varProps, 'q-e:input', existingHandler) || toSort;
+                }
+                toSort = mergeHandlers(varProps, 'q-e:input', handler) || toSort;
+            }
+            else if (bindValueSignal) {
+                // Delete from both varProps and constProps if present
+                if (varProps && _hasOwnProperty$1.call(varProps, BIND_VALUE)) {
                     delete varProps[BIND_VALUE];
-                    varProps.value = bindValueSignal;
-                    const handler = createQRL(null, '_val', _val, null, [bindValueSignal]);
-                    // Move q-e:input from constProps if it exists
-                    if (constProps && _hasOwnProperty$1.call(constProps, 'q-e:input')) {
-                        if (!constPropsCopied) {
-                            constProps = { ...constProps };
-                            constPropsCopied = true;
-                        }
-                        const existingHandler = constProps['q-e:input'];
-                        delete constProps['q-e:input'];
-                        toSort = mergeHandlers(varProps, 'q-e:input', existingHandler) || toSort;
+                }
+                if (constProps && _hasOwnProperty$1.call(constProps, BIND_VALUE)) {
+                    if (!constPropsCopied) {
+                        constProps = { ...constProps };
+                        constPropsCopied = true;
+                    }
+                    delete constProps[BIND_VALUE];
+                }
+                varProps.value = bindValueSignal;
+                const handler = createQRL(null, '_val', _val, null, [bindValueSignal]);
+                // Move q-e:input from constProps if it exists
+                if (constProps && _hasOwnProperty$1.call(constProps, 'q-e:input')) {
+                    if (!constPropsCopied) {
+                        constProps = { ...constProps };
+                        constPropsCopied = true;
                     }
-                    toSort = mergeHandlers(varProps, 'q-e:input', handler) || toSort;
+                    const existingHandler = constProps['q-e:input'];
+                    delete constProps['q-e:input'];
+                    toSort = mergeHandlers(varProps, 'q-e:input', existingHandler) || toSort;
                 }
+                toSort = mergeHandlers(varProps, 'q-e:input', handler) || toSort;
             }
         }
         // Transform className -> class
@@ -3712,6 +3741,10 @@ function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromD
  * @internal
  */
 function _run(event, element) {
+    if (!element.isConnected) {
+        // ignore events on disconnected elements, this can happen when the event is triggered while the element is being removed
+        return;
+    }
     const ctx = newInvokeContextFromDOM(event, element);
     if (typeof this === 'string') {
         setCaptures(deserializeCaptures(ctx.$container$, this));
@@ -7619,6 +7652,15 @@ function materializeFromVNodeData(vParent, vData, element, child) {
                 vnode_ensureElementKeyInflated(elementVNode);
                 addVNode(elementVNode);
                 child = fastNextSibling(child);
+                while (
+                // skip only elements, not text nodes
+                isElement(child) &&
+                    shouldSkipElement(child)) {
+                    child = fastNextSibling(child);
+                    if (!child && value > 0) {
+                        throw qError(27 /* QError.materializeVNodeDataError */, [vData, peek(), nextToConsumeIdx]);
+                    }
+                }
             }
             // collect the elements;
         }
@@ -9010,12 +9052,7 @@ class Serializer {
             ]);
         }
         else if (value instanceof EffectSubscription) {
-            this.output(32 /* TypeIds.EffectSubscription */, [
-                value.consumer,
-                value.property,
-                value.backRef,
-                value.data,
-            ]);
+            this.output(32 /* TypeIds.EffectSubscription */, [value.consumer, value.property, value.data]);
         }
         else if (isStore(value)) {
             const storeHandler = getStoreHandler(value);
@@ -9083,19 +9120,13 @@ class Serializer {
                     this.output(2 /* TypeIds.ForwardRef */, forwardRefId);
                 }
                 else {
-                    this.output(26 /* TypeIds.SerializerSignal */, [
-                        value.$computeQrl$,
-                        filterEffectBackRefs(value[_EFFECT_BACK_REF]),
-                        value.$effects$,
-                        maybeValue,
-                    ]);
+                    this.output(26 /* TypeIds.SerializerSignal */, [value.$computeQrl$, value.$effects$, maybeValue]);
                 }
                 return;
             }
             if (value instanceof WrappedSignalImpl) {
                 this.output(23 /* TypeIds.WrappedSignal */, [
                     ...serializeWrappingFn(this.$serializationContext$, value),
-                    filterEffectBackRefs(value[_EFFECT_BACK_REF]),
                     value.$flags$,
                     value.$hostElement$,
                     ...(value.$effects$ || []),
@@ -9123,11 +9154,7 @@ class Serializer {
                 else if (shouldNeverSerialize) {
                     v = NEEDS_COMPUTATION;
                 }
-                const out = [
-                    value.$computeQrl$,
-                    filterEffectBackRefs(value[_EFFECT_BACK_REF]),
-                    value.$effects$,
-                ];
+                const out = [value.$computeQrl$, value.$effects$];
                 if (isAsync) {
                     // After SSR, the signal is never loading, so no need to send it
                     out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);
@@ -9254,14 +9281,7 @@ class Serializer {
             this.output(29 /* TypeIds.JSXNode */, out);
         }
         else if (value instanceof Task) {
-            const out = [
-                value.$qrl$,
-                value.$flags$,
-                value.$index$,
-                value.$el$,
-                value[_EFFECT_BACK_REF],
-                value.$state$,
-            ];
+            const out = [value.$qrl$, value.$flags$, value.$index$, value.$el$, value.$state$];
             while (out[out.length - 1] === undefined) {
                 out.pop();
             }
@@ -9460,18 +9480,6 @@ function serializeWrappingFn(serializationContext, value) {
     const syncFnId = serializationContext.$addSyncFn$(value.$funcStr$, value.$args$.length, value.$func$);
     return [syncFnId, value.$args$];
 }
-function filterEffectBackRefs(effectBackRef) {
-    let effectBackRefToSerialize = undefined;
-    if (effectBackRef) {
-        for (const [effectProp, effect] of effectBackRef) {
-            if (effect.backRef) {
-                effectBackRefToSerialize ||= new Map();
-                effectBackRefToSerialize.set(effectProp, effect);
-            }
-        }
-    }
-    return effectBackRefToSerialize;
-}
 function tryGetBackRefs(props) {
     return Object.prototype.hasOwnProperty.call(props, QBackRefs)
         ? props[QBackRefs]
@@ -10195,8 +10203,7 @@ const inflate = (container, target, typeId, data) => {
             task.$flags$ = v[1];
             task.$index$ = v[2];
             task.$el$ = v[3];
-            task[_EFFECT_BACK_REF] = v[4];
-            task.$state$ = v[5];
+            task.$state$ = v[4];
             break;
         case 21 /* TypeIds.Component */:
             target[SERIALIZABLE_STATE][0] = data[0];
@@ -10217,6 +10224,7 @@ const inflate = (container, target, typeId, data) => {
             const storeHandler = getStoreHandler(target);
             storeHandler.$flags$ = flags;
             storeHandler.$effects$ = effects;
+            restoreEffectBackRefForEffectsMap(storeHandler.$effects$, store);
             break;
         }
         case 22 /* TypeIds.Signal */: {
@@ -10224,6 +10232,7 @@ const inflate = (container, target, typeId, data) => {
             const d = data;
             signal.$untrackedValue$ = d[0];
             signal.$effects$ = new Set(d.slice(1));
+            restoreEffectBackRefForEffects(signal.$effects$, signal);
             break;
         }
         case 23 /* TypeIds.WrappedSignal */: {
@@ -10231,41 +10240,43 @@ const inflate = (container, target, typeId, data) => {
             const d = data;
             signal.$func$ = container.getSyncFn(d[0]);
             signal.$args$ = d[1];
-            signal[_EFFECT_BACK_REF] = d[2];
             signal.$untrackedValue$ = NEEDS_COMPUTATION;
-            signal.$flags$ = d[3];
+            signal.$flags$ = d[2];
             signal.$flags$ |= 1 /* SignalFlags.INVALID */;
-            signal.$hostElement$ = d[4];
-            signal.$effects$ = new Set(d.slice(5));
+            signal.$hostElement$ = d[3];
+            signal.$effects$ = new Set(d.slice(4));
             inflateWrappedSignalValue(signal);
+            restoreEffectBackRefForEffects(signal.$effects$, signal);
             break;
         }
         case 25 /* TypeIds.AsyncSignal */: {
             const asyncSignal = target;
             const d = data;
             asyncSignal.$computeQrl$ = d[0];
-            asyncSignal[_EFFECT_BACK_REF] = d[1];
-            asyncSignal.$effects$ = new Set(d[2]);
-            asyncSignal.$loadingEffects$ = new Set(d[3]);
-            asyncSignal.$errorEffects$ = new Set(d[4]);
-            asyncSignal.$untrackedError$ = d[5];
-            asyncSignal.$flags$ = d[6] ?? 0;
+            asyncSignal.$effects$ = new Set(d[1]);
+            asyncSignal.$loadingEffects$ = new Set(d[2]);
+            asyncSignal.$errorEffects$ = new Set(d[3]);
+            asyncSignal.$untrackedError$ = d[4];
+            asyncSignal.$flags$ = d[5] ?? 0;
             if (asyncSignal.$flags$ & 64 /* AsyncSignalFlags.CLIENT_ONLY */) {
                 // If it's client only, it was serialized because it pretended to be loading
                 asyncSignal.$untrackedLoading$ = true;
             }
-            const hasValue = d.length > 7;
+            const hasValue = d.length > 6;
             if (hasValue) {
-                asyncSignal.$untrackedValue$ = d[7];
+                asyncSignal.$untrackedValue$ = d[6];
             }
             // can happen when never serialize etc
             if (asyncSignal.$untrackedValue$ === NEEDS_COMPUTATION) {
                 asyncSignal.$flags$ |= 1 /* SignalFlags.INVALID */;
             }
             // Note, we use the setter so that it schedules polling if needed
-            asyncSignal.interval = (d[8] ?? 0);
-            asyncSignal.$concurrency$ = (d[9] ?? 1);
-            asyncSignal.$timeoutMs$ = (d[10] ?? 0);
+            asyncSignal.interval = (d[7] ?? 0);
+            asyncSignal.$concurrency$ = (d[8] ?? 1);
+            asyncSignal.$timeoutMs$ = (d[9] ?? 0);
+            restoreEffectBackRefForEffects(asyncSignal.$effects$, asyncSignal);
+            restoreEffectBackRefForEffects(asyncSignal.$loadingEffects$, asyncSignal);
+            restoreEffectBackRefForEffects(asyncSignal.$errorEffects$, asyncSignal);
             break;
         }
         // Inflating a SerializerSignal is the same as inflating a ComputedSignal
@@ -10283,19 +10294,19 @@ const inflate = (container, target, typeId, data) => {
                 // ignore preload errors
             });
             loading = loading.finally(() => p);
-            computed[_EFFECT_BACK_REF] = d[1];
-            if (d[2]) {
-                computed.$effects$ = new Set(d[2]);
+            if (d[1]) {
+                computed.$effects$ = new Set(d[1]);
             }
-            const hasValue = d.length > 3;
+            const hasValue = d.length > 2;
             if (hasValue) {
-                computed.$untrackedValue$ = d[3];
+                computed.$untrackedValue$ = d[2];
             }
             if (typeId !== 26 /* TypeIds.SerializerSignal */ && computed.$untrackedValue$ !== NEEDS_COMPUTATION) {
                 // If we have a value after SSR, it will always be mean the signal was not invalid
                 // The serialized signal is always left invalid so it can recreate the custom object
                 computed.$flags$ &= -2 /* SignalFlags.INVALID */;
             }
+            restoreEffectBackRefForEffects(computed.$effects$, computed);
             break;
         }
         case 15 /* TypeIds.Error */: {
@@ -10370,7 +10381,9 @@ const inflate = (container, target, typeId, data) => {
                 owner._proxy = propsProxy;
             }
             propsProxy[_OWNER] = owner;
-            propsProxy[_PROPS_HANDLER].$effects$ = d[3];
+            const propsHandler = propsProxy[_PROPS_HANDLER];
+            propsHandler.$effects$ = d[3];
+            restoreEffectBackRefForEffectsMap(propsHandler.$effects$, propsProxy);
             break;
         case 31 /* TypeIds.SubscriptionData */: {
             const effectData = target;
@@ -10383,14 +10396,15 @@ const inflate = (container, target, typeId, data) => {
             const d = data;
             effectSub.consumer = d[0];
             effectSub.property = d[1];
-            effectSub.backRef = d[2];
-            effectSub.data = d[3];
+            effectSub.data = d[2];
+            restoreEffectBackRefForConsumer(effectSub);
             break;
         }
         default:
             throw qError(16 /* QError.serializeErrorNotImplemented */, [typeId]);
     }
-}; /**
+};
+/**
  * Restores an array eagerly. If you need it lazily, use `deserializeData(container, TypeIds.Array,
  * array)` instead
  */
@@ -10441,6 +10455,31 @@ function inflateWrappedSignalValue(signal) {
         }
     }
 }
+function restoreEffectBackRefForConsumer(effect) {
+    const isServerSide = import.meta.env.TEST ? isServerPlatform() : isServer;
+    const consumerBackRef = effect.consumer;
+    if (isServerSide && !consumerBackRef) {
+        // on browser, we don't serialize for example VNodes, so then on server side we don't have consumer
+        return;
+    }
+    consumerBackRef[_EFFECT_BACK_REF] ||= new Map();
+    consumerBackRef[_EFFECT_BACK_REF].set(effect.property, effect);
+}
+function restoreEffectBackRefForEffects(effects, consumer) {
+    if (effects) {
+        for (const effect of effects) {
+            effect.backRef ||= new Set();
+            effect.backRef.add(consumer);
+        }
+    }
+}
+function restoreEffectBackRefForEffectsMap(effectsMap, consumer) {
+    if (effectsMap) {
+        for (const [, effects] of effectsMap) {
+            restoreEffectBackRefForEffects(effects, consumer);
+        }
+    }
+}
 
 /** Arrays/Objects are special-cased so their identifiers is a single digit. */
 const needsInflation = (typeId) => typeId >= 15 /* TypeIds.Error */ || typeId === 4 /* TypeIds.Array */ || typeId === 5 /* TypeIds.Object */;