Side effect failing

[busslina]

I have this:

extension _UseConvenience on SideEffectRegistrar {
  SideEffectRegistrar get use => this;
}

extension ResourceSideEffects on SideEffectRegistrar {
  CountdownSideEffectController asCountdown(
    int initialSecondsCount, {
    bool autoStart = false,
  }) =>
      use.register((api) {
        final (state, setState) = use.state(initialSecondsCount);

        Timer startTimer() =>
            Timer.periodic(const Duration(seconds: 1), (timer) {
              setState(state - 1);

              if (state == 0) {
                timer.cancel();
              }

              api.rebuild();
            });

        final (timer, setTimer) =
            use.state<Timer?>(autoStart ? startTimer() : null);

        bool isActive() => timer?.isActive ?? false;

        return (
          value: '$state seconds',
          isActive: isActive(),
          pause: () {
            if (!isActive()) {
              return false;
            }

            timer!.cancel();

            return true;
          },
          resume: () {
            if (isActive()) {
              return false;
            }

            setTimer(startTimer());

            return true;
          },
          reset: () => setState(initialSecondsCount),
        );
      });
}

typedef CountdownSideEffectController = ({
  String value,
  bool isActive,
  bool Function() pause,
  bool Function() resume,
  void Function() reset,
});

It's always failing inside the Timer callback on setState(state - 1);

This is the error:

_TypeError
(type '(() => int, (int) => void)'
is not a subtype of type
'({bool isActive, String value})' in type cast)

[busslina]

I'm gonna try to do it without a custom Side Effect.
The downside to not use a custom effect that I see is that I cannot provide a custom initial value and I have to use a predefined one.

[busslina]

callonce (case 1) is not working

[GregoryConrad]

Took me a second to see the problem: use.callonce is capturing the value from the first build so it will only ever have that value. Solution: use.stateGetterSetter was designed just for this, so you can capture a function that will always return the latest value instead of capturing the value itself. Something like this should work:

    int countdownCapsule(CapsuleHandle use) {
      final (getValue, setValue) = use.stateGetterSetter(60);
      use.callonce(
        () => Timer.periodic(const Duration(seconds: 1), (_) {
          print('TIMER -- ${getValue()}');
          setValue(getValue() - 1);
        }),
      );

      return getValue();
    }

[busslina]

Cool.

Now my last question for today: Is it necessary to call rebuild() if the capsule is not a dependency of other capsules (only readed by the CapsuleContainer)? I would say no.

And, could be considered a side effect as an inline capsule?

[GregoryConrad]

Is it necessary to call rebuild() if the capsule is not a dependency of other capsules (only readed by the CapsuleContainer)?

whenever a side effect mutates and that mutation could result in new output data of the capsule itself, you should call rebuild. Even if there are no dependents, doing so is a best practice and when there are no dependents, the call is fairly inexpensive.

[GregoryConrad]

If there was no chance the output data would change, then it is is not necessary to call rebuild.

[GregoryConrad]

Issue in original post is that you are doing use.foobar conditionally. Since use.register only executes on the first build, you’ll only register those two use.state on the first build, which is incorrect

solution would be to hoist the use.states up before the use.register. You’ll still be able to access them within the register!

[busslina]

Cool. Gonna check it

[busslina]

So maybe I could do use.api().rebuild() instead of using register()!?

[GregoryConrad]

Well register would be ok, as long as you did:

final (state, setState) = use.state(foo);
final (state2, setState2)= use.state(bar);
return use.register((api) {
  void thing() {
    setState(foobar);
  }
  void thing2() {
    doSomething();
    api.rebuild();
  }
  return (thing, thing2);
});

You could also do:

final rebuild = use.rebuilder();
final (state, setState) = use.state(foo);
final (state2, setState2)= use.state(bar);
return use.callonce(() {
  void thing() {
    setState(foobar);
  }
  void thing2() {
    doSomething();
    rebuild();
  }
  return (thing, thing2);
});

Up to you.

[busslina]

Thanks !!!