perf: run trigger signal effects sync if possible

Author: Varixo

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

@@ -12,6 +12,7 @@ import {
   SignalFlags,
   WrappedSignalFlags,
 } from '../types';
+import { triggerEffects } from '../utils';
 import { SignalImpl } from './signal-impl';
 
 export class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
@@ -41,12 +42,23 @@ export class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
 
   invalidate() {
     this.$flags$ |= SignalFlags.INVALID;
-    this.$container$?.$scheduler$(
-      ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS,
-      this.$hostElement$,
-      this,
-      this.$effects$
-    );
+    // we are trying to run computation without creating a chore, which can be expensive
+    // for many signals. If it fails, we schedule a chore to run the computation.
+    try {
+      this.$computeIfNeeded$();
+    } catch (_) {
+      this.$container$?.$scheduler$(
+        ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS,
+        this.$hostElement$,
+        this,
+        this.$effects$
+      );
+    }
+    // if the computation not failed, we can run the effects directly
+    if (this.$flags$ & SignalFlags.RUN_EFFECTS) {
+      this.$flags$ &= ~SignalFlags.RUN_EFFECTS;
+      triggerEffects(this.$container$, this, this.$effects$);
+    }
   }
 
   /**
@@ -80,7 +92,14 @@ export class WrappedSignalImpl<T> extends SignalImpl<T> implements BackRef {
       this.$container$!
     );
     // TODO: we should remove invalid flag here, but some tests are failing
+    // Sometimes we may call .value on wrapped signals without ctx. This means subscription will be
+    // not created and effects will not be triggered. After wrapping this with if (this.$container$)
+    // less tests are failing, but still some are failing.
     // this.$flags$ &= ~SignalFlags.INVALID;
+
+    // reset flag in case we call computedIfNeeded twice and the value was changed only the first time
+    // TODO: change to version number?
+    this.$flags$ &= ~SignalFlags.RUN_EFFECTS;
     const didChange = untrackedValue !== this.$untrackedValue$;
     if (didChange) {
       this.$flags$ |= SignalFlags.RUN_EFFECTS;

packages/qwik/src/core/shared/scheduler.ts

@@ -85,8 +85,6 @@ import { VNodeFlags, type ClientContainer } from '../client/types';
 import { VNodeJournalOpCode, vnode_isVNode } from '../client/vnode';
 import { vnode_diff } from '../client/vnode-diff';
 import { ComputedSignalImpl } from '../reactive-primitives/impl/computed-signal-impl';
-import { SignalImpl } from '../reactive-primitives/impl/signal-impl';
-import { StoreHandler } from '../reactive-primitives/impl/store';
 import { WrappedSignalImpl } from '../reactive-primitives/impl/wrapped-signal-impl';
 import { isSignal, type Signal } from '../reactive-primitives/signal.public';
 import type { NodePropPayload } from '../reactive-primitives/subscription-data';
@@ -227,7 +225,7 @@ export const createScheduler = (
   function schedule(
     type: ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS,
     host: HostElement | null,
-    target: Signal | StoreHandler,
+    target: Signal<unknown> | StoreTarget,
     effects: Set<EffectSubscription> | null
   ): Chore<ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS>;
   function schedule(
@@ -714,11 +712,7 @@ This is often caused by modifying a signal in an already rendered component duri
       }
       case ChoreType.RECOMPUTE_AND_SCHEDULE_EFFECTS: {
         {
-          const target = chore.$target$ as
-            | SignalImpl
-            | ComputedSignalImpl<unknown>
-            | WrappedSignalImpl<unknown>
-            | StoreHandler;
+          const target = chore.$target$ as ComputedSignalImpl<unknown> | WrappedSignalImpl<unknown>;
 
           const effects = chore.$payload$ as Set<EffectSubscription>;
           if (!effects?.size) {
@@ -727,6 +721,8 @@ This is often caused by modifying a signal in an already rendered component duri
 
           let shouldCompute =
             target instanceof ComputedSignalImpl || target instanceof WrappedSignalImpl;
+
+          // for .error and .loading effects
           if (target instanceof AsyncComputedSignalImpl && effects !== target.$effects$) {
             shouldCompute = false;
           }