Method constructor

packages/common/http/src/resource.ts:359–450

(
    injector: Injector,
    request: (ctx: ResourceParamsContext) => HttpRequest<T> | undefined,
    defaultValue: T,
    debugName?: string,
    parse?: (value: unknown) => T,
    equal?: ValueEqualityFn<unknown>,
    getInitialStream?: (
      request: HttpRequest<unknown> | undefined,
    ) => Signal<ResourceStreamItem<T>> | undefined,
  )

  readonly statusCode = this._statusCode.asReadonly();

  constructor(
    injector: Injector,
    request: (ctx: ResourceParamsContext) => HttpRequest<T> | undefined,
    defaultValue: T,
    debugName?: string,
    parse?: (value: unknown) => T,
    equal?: ValueEqualityFn<unknown>,
    getInitialStream?: (
      request: HttpRequest<unknown> | undefined,
    ) => Signal<ResourceStreamItem<T>> | undefined,
  ) {
    super(
      request,
      ({params: request, abortSignal}) => {
        let sub: Subscription | undefined;
        // In the unlikely case the request returns synchronously we want to make sure the observable
        // is subscribe even if it isn't initialized yet.
        let aborted = false;

        // `once: true`: calling unsubscribe() here (on abort) doesn't trigger the error/complete
        // callbacks below, so without it this listener wouldn't get removed on the abort path.
        const onAbort = () => {
          aborted = true;
          sub?.unsubscribe();
        };
        abortSignal.addEventListener('abort', onAbort, {once: true});

        // Start off stream as undefined.
        const stream = signal<ResourceStreamItem<T>>({value: undefined as T});
        let resolve: ((value: Signal<ResourceStreamItem<T>>) => void) | undefined;
        const promise = new Promise<Signal<ResourceStreamItem<T>>>((r) => (resolve = r));

        const send = (value: ResourceStreamItem<T>): void => {
          stream.set(value);
          resolve?.(stream);
          resolve = undefined;
        };

        sub = this.client.request(request!).subscribe({
          next: (event) => {
            switch (event.type) {
              case HttpEventType.Response:
                this._headers.set(event.headers);
                this._statusCode.set(event.status);
                try {
                  send({value: parse ? parse(event.body) : (event.body as T)});
                } catch (error) {
                  send({error: encapsulateResourceError(error)});
                }
                break;
              case HttpEventType.DownloadProgress:
                this._progress.set(event);
                break;
            }
          },
          error: (error) => {
            if (error instanceof HttpErrorResponse) {
              this._headers.set(error.headers);