Method cacheResponse

packages/service-worker/worker/src/data.ts:537–574

* Operation for caching the response from the server. This has to happen all * at once, so that the cache and LRU tracking remain in sync. If the network request * completes before the timeout, this logic will be run inline with the response flow. * If the request times out on the server, a

(
    req: Request,
    res: Response,
    lru: LruList,
    okToCacheOpaque = false,
  )

   * request will still be running in the background, to be cached when it completes.
   */
  private async cacheResponse(
    req: Request,
    res: Response,
    lru: LruList,
    okToCacheOpaque = false,
  ): Promise<void> {
    // Only cache successful responses.
    if (!(res.ok || (okToCacheOpaque && res.type === 'opaque'))) {
      return;
    }

    // If caching this response would make the cache exceed its maximum size, evict something
    // first.
    if (lru.size >= this.config.maxSize) {
      // The cache is too big, evict something.
      const evictedUrl = lru.pop();
      if (evictedUrl !== null) {
        await this.clearCacheForUrl(evictedUrl);
      }
    }

    // TODO: evaluate for possible race conditions during flaky network periods.

    // Mark this resource as having been accessed recently. This ensures it won't be evicted
    // until enough other resources are requested that it falls off the end of the LRU chain.
    lru.accessed(req.url);

    // Store the response in the cache (cloning because the browser will consume
    // the body during the caching operation).
    await (await this.cache).put(req, res.clone());

    // Store the age of the cache.
    const ageTable = await this.ageTable;
    await ageTable.write(req.url, {age: this.adapter.time});

    // Sync the LRU chain to non-volatile storage.
    await this.syncLru();
  }

  /**
   * Delete all of the saved state which this group uses to track resources.