typing of functions taking signals

[joprice]

I was having trouble figuring out a type for a helper like the one below, that should be able to take a signal or an atom instance, but I ended up finded the handleStateChange function and following its example. Since Signal is actually a subclass of of ZeduxNode, would it make sense to have ZeduxNode implement an interface or have a helper type that shares these operations for easy typing, or with more usage would I find there's good reason to require passing the type variables and bounds in this way?

// retains the last resolved value to allow visually preserving the state while loading the next value
const injectRetainPrevious = <G extends AnyNodeGenerics>(
  signal: ZeduxNode<G & {Params: any; Template: any}>,
): Signal<Pick<G, 'Events' | 'State'>> => {
  const data = signal.get();
  const prev = injectSignal(data);
  injectEffect(() => {
    const prevData = prev.getOnce().data;
    if (data.isLoading && prevData !== undefined) {
      prev.set({...data, data: prevData});
    } else {
      prev.set(data);
    }
  }, [data]);
  return prev;
};

[bowheart]

There is benefit to typing things this way. But you're not getting any of it here. The AnyNodeGenerics type helper allows passing partial types that the node must match. For example, here you can specify the state shape:

const injectRetainPrevious = <
  G extends AnyNodeGenerics<{
    State: { data: any; isLoading: boolean };
  }>
>(
  signal: ZeduxNode<G & { Params: any; Template: any }>
): Signal<Pick<G, "Events" | "State">> => { ... }

Then callers must pass nodes with the expected state shape and the function's own .data and .isLoading accesses are fully typed.

Since atoms are signals, you can also do this with the Signal class instead of ZeduxNode - and that sounds like what you want here - however that requires some manual type intersections

You discovered the types for a Signal's generics - NodeGenerics & {Params: any; Template: any}. We don't currently have a standalone type to represent this. Maybe we should. We could then also create an AnySignalGenerics helper. These:

type SignalGenerics = NodeGenerics & { Params?: any; Template?: any };

type AnySignalGenerics<
  G extends Partial<SignalGenerics> = { [K in keyof SignalGenerics]: any }
> = {
  [K in keyof SignalGenerics]: K extends keyof G ? G[K] : any;
};

With that defined, you can use the Signal class instead of ZeduxNode:

const injectRetainPrevious = <
  G extends SignalGenerics & {
    State: { data: any; isLoading: boolean } & Partial<Record<string, any>>;
  }
>(
  signal: Signal<G>
): Signal<Pick<G, "Events" | "State">> => { ... }

Note the & Partial<Record<string, any>>. I believe that will enforce a partial state match instead of an exact match (so the passed signal can have other fields).