Class CompoundSignalContext

packages/core/src/signals/CompoundSignalContext.ts:24–131

};

export class CompoundSignalContext<
  TSetterValue,
  TValue extends TSetterValue,
  TKeys extends keyof TValue = keyof TValue,
  TOwner = void,
> extends SignalContext<TSetterValue, TValue, TOwner> {
  public readonly signals: [keyof TValue, Signal<any, any, TOwner>][] = [];

  public constructor(
    private readonly entries: (
      | TKeys
      | [keyof TValue, Signal<any, any, TOwner>]
    )[],
    parser: (value: TSetterValue) => TValue,
    initial: SignalValue<TSetterValue>,
    interpolation: InterpolationFunction<TValue>,
    owner: TOwner = <TOwner>(<unknown>undefined),
    extensions: Partial<SignalExtensions<TSetterValue, TValue>> = {},
  ) {
    super(undefined, interpolation, owner, parser, extensions);
    this.parser = parser;

    for (const entry of entries) {
      let key: keyof TValue;
      let signal: Signal<any, any, TOwner>;
      if (Array.isArray(entry)) {
        [key, signal] = entry;
        (signal.context as any).owner ??= this;
      } else {
        key = entry;
        signal = new SignalContext(
          modify(initial, value => parser(value)[entry]),
          <any>map,
          owner ?? this.invokable,
        ).toSignal();
      }
      this.signals.push([key, signal]);
      Object.defineProperty(this.invokable, key, {value: signal});
    }
  }

  public override toSignal(): CompoundSignal<
    TSetterValue,
    TValue,
    TKeys,
    TOwner
  > {
    return this.invokable;
  }

  public override parse(value: TSetterValue): TValue {
    return this.parser(value);
  }

  public override getter(): TValue {
    return this.parse(
      <TSetterValue>(
        Object.fromEntries(