Method loadEffect

packages/core/src/resource/resource.ts:412–517

()

  }

  private async loadEffect(): Promise<void> {
    const extRequest = this.extRequest();

    // Capture the previous status before any state transitions. Note that this is `untracked` since
    // we do not want the effect to depend on the state of the resource, only on the request.
    const {status: currentStatus, previousStatus} = untracked(this.state);

    if (extRequest.request === undefined) {
      // Nothing to load (and we should already be in a non-loading state).
      return;
    } else if (currentStatus !== 'loading') {
      // We're not in a loading or reloading state, so this loading request is stale.
      return;
    }

    // Cancel any previous loading attempts.
    this.abortInProgressLoad();

    // Capturing _this_ load's pending task in a local variable is important here. We may attempt to
    // resolve it twice:
    //
    //  1. when the loading function promise resolves/rejects
    //  2. when cancelling the loading operation
    //
    // After the loading operation is cancelled, `this.resolvePendingTask` no longer represents this
    // particular task, but this `await` may eventually resolve/reject. Thus, when we cancel in
    // response to (1) below, we need to cancel the locally saved task.
    let resolvePendingTask: (() => void) | undefined = (this.resolvePendingTask =
      this.pendingTasks.add());

    const {signal: abortSignal} = (this.pendingController = new AbortController());

    try {
      // The actual loading is run through `untracked` - only the request side of `resource` is
      // reactive. This avoids any confusion with signals tracking or not tracking depending on
      // which side of the `await` they are.
      const stream = untracked(() => {
        return this.loaderFn({
          params: extRequest.request as Exclude<R, undefined>,
          abortSignal,
          previous: {
            status: previousStatus,
          },
        });
      });

      // If this request has been aborted, or the current request no longer
      // matches this load, then we should ignore this resolution.
      const shouldDiscard = () => abortSignal.aborted || untracked(this.extRequest) !== extRequest;

      if (isSignal(stream)) {
        if (shouldDiscard()) {
          return;
        }

        this.state.set({
          extRequest,
          status: 'resolved',