chore: lint++

Author: wmertens

packages/qwik/src/core/reactive-primitives/impl/async-signal-impl.ts

@@ -150,6 +150,7 @@ export class AsyncSignalImpl<T>
   }
 
   get untrackedLoading() {
+    // reading `.loading` means someone is interested in the result, so we should trigger the computation. The alternative is eager computation or imperative calls to invalidate; this seems nicer.
     this.$computeIfNeeded$();
     // During SSR there's no such thing as loading state, we must render complete results
     if ((import.meta.env.TEST ? isServerPlatform() : isServer) && this.$current$?.$promise$) {
@@ -217,12 +218,13 @@ export class AsyncSignalImpl<T>
       if (!this.$hasSubscribers$()) {
         this.abort();
       }
-    }, 0);
+    });
   }
 
   /** Returns a promise resolves when the signal finished computing. */
   async promise(): Promise<void> {
     this.$computeIfNeeded$();
+    // Wait for the current computation to finish, but if we became invalid while running, we need to wait for the new computation instead. So we loop until we are no longer invalid
     while (this.$current$?.$promise$) {
       await this.$current$?.$promise$;
     }

packages/qwik/src/core/shared/serdes/serialize.ts

@@ -409,20 +409,12 @@ export async function serialize(serializationContext: SerializationContext): Pro
           value.$flags$ & SerializationSignalFlags.SERIALIZATION_STRATEGY_NEVER;
         const isInvalid = value.$flags$ & SignalFlags.INVALID;
         const isSkippable = fastSkipSerialize(value.$untrackedValue$);
-        const interval =
-          value instanceof AsyncSignalImpl && value.$interval$ > 0 ? value.$interval$ : undefined;
-        const concurrency =
-          value instanceof AsyncSignalImpl && value.$concurrency$ !== 1
-            ? value.$concurrency$
-            : undefined;
-        const timeout =
-          value instanceof AsyncSignalImpl && value.$timeoutMs$ !== 0
-            ? value.$timeoutMs$
-            : undefined;
+        const isAsync = value instanceof AsyncSignalImpl;
+        const interval = isAsync && value.$interval$ > 0 ? value.$interval$ : undefined;
+        const concurrency = isAsync && value.$concurrency$ !== 1 ? value.$concurrency$ : undefined;
+        const timeout = isAsync && value.$timeoutMs$ !== 0 ? value.$timeoutMs$ : undefined;
         const eagerCleanup =
-          value instanceof AsyncSignalImpl && value.$flags$ & AsyncSignalFlags.EAGER_CLEANUP
-            ? true
-            : undefined;
+          isAsync && value.$flags$ & AsyncSignalFlags.EAGER_CLEANUP ? true : undefined;
 
         if (isInvalid || isSkippable) {
           v = NEEDS_COMPUTATION;
@@ -437,7 +429,6 @@ export async function serialize(serializationContext: SerializationContext): Pro
           filterEffectBackRefs(value[_EFFECT_BACK_REF]),
           value.$effects$,
         ];
-        const isAsync = value instanceof AsyncSignalImpl;
         if (isAsync) {
           // After SSR, the signal is never loading, so no need to send it
           out.push(value.$loadingEffects$, value.$errorEffects$, value.$untrackedError$);

packages/qwik/src/core/tests/use-async.spec.tsx

@@ -417,7 +417,7 @@ describe.each([
       await trigger(container.element, 'button', 'click');
       // on server after resuming cleanup is not called yet
       // on client it is called as usual
-      // so now the log is equal
+      // so from this point the log is equal for ssr and client
       expect((globalThis as any).log).toEqual(['cleanup']);
       await trigger(container.element, 'button', 'click'); //show
       await trigger(container.element, 'button', 'click'); //hide

packages/qwik/src/server/ssr-container.ts

@@ -901,23 +901,29 @@ class SSRContainer extends _SharedContainer implements ISSRContainer {
     if (!this.serializationCtx.$roots$.length) {
       return;
     }
-    const attrs: string[] = ['type', 'qwik/state'];
 
-    // Add q-d:qidle attribute if there are signals to eagerly resume
-    if (this.serializationCtx.$eagerResume$.size > 0) {
-      const qrl = createQRL(null, '_res', _res, null, [...this.serializationCtx.$eagerResume$]);
-      const qrlStr = qrlToString(this.serializationCtx, qrl);
-      attrs.push('q-d:qidle', qrlStr);
-      // Add 'd:qidle' to event names set
-      this.serializationCtx.$eventNames$.add('d:qidle');
-    }
+    const attrs = this.stateScriptAttrs();
 
     this.openElement('script', null, attrs);
     return maybeThen(this.serializationCtx.$serialize$(), () => {
       this.closeElement();
     });
   }
 
+  /** Add q-d:qidle attribute to eagerly resume some state if needed */
+  private stateScriptAttrs(): string[] {
+    const attrs = ['type', 'qwik/state'];
+    const eagerResume = this.serializationCtx.$eagerResume$;
+    if (eagerResume.size > 0) {
+      const qrl = createQRL(null, '_res', _res, null, [...eagerResume]);
+      const qrlStr = qrlToString(this.serializationCtx, qrl);
+      attrs.push('q-d:qidle', qrlStr);
+      // Add 'd:qidle' to event names set
+      this.serializationCtx.$eventNames$.add('d:qidle');
+    }
+    return attrs;
+  }
+
   private emitSyncFnsData() {
     const fns = this.serializationCtx.$syncFns$;
     if (fns.length) {