---
url: /api/symbols/workbox-swkit/precaching/precachestrategy.md
---

# PrecacheStrategy

Class @vite-pwa/workbox-swkit/precaching

A workbox-strategies.Strategy implementation
specifically designed to work with
workbox-precaching.PrecacheController
to both cache and fetch precached assets.

Note: an instance of this class is created automatically when creating a
`PrecacheController`; it's generally not necessary to create this yourself.

## Constructor

```ts
new PrecacheStrategy(options?: PrecacheStrategyOptions)
```

## Properties

## Methods

### \_awaitComplete()

```ts
_awaitComplete(responseDone: Promise<Response>, handler: StrategyHandler, request: Request, event: ExtendableEvent): Promise<void>
```

### \_getResponse()

```ts
_getResponse(handler: StrategyHandler, request: Request, event: ExtendableEvent): Promise<Response>
```

### \_handleFetch()

```ts
_handleFetch(request: Request, handler: StrategyHandler): Promise<Response>
```

### \_handleInstall()

```ts
_handleInstall(request: Request, handler: StrategyHandler): Promise<Response>
```

### handle()

```ts
handle(options: HandlerCallbackOptions | FetchEvent): Promise<Response>
```

Perform a request strategy and returns a `Promise` that will resolve with
a `Response`, invoking all relevant plugin callbacks.

When a strategy instance is registered with a Workbox
workbox-routing.Route, this method is automatically
called when the route matches.

Alternatively, this method can be used in a standalone `FetchEvent`
listener by passing it to `event.respondWith()`.

**Parameters**

* `options` – A `FetchEvent` or an object with the
  properties listed below.

### handleAll()

```ts
handleAll(options: HandlerCallbackOptions | FetchEvent): [Promise<Response>, Promise<void>]
```

Similar to workbox-strategies.Strategy~handle, but
instead of just returning a `Promise` that resolves to a `Response` it
it will return an tuple of `[response, done]` promises, where the former
(`response`) is equivalent to what `handle()` returns, and the latter is a
Promise that will resolve once any promises that were added to
`event.waitUntil()` as part of performing the strategy have completed.

You can await the `done` promise to ensure any extra work performed by
the strategy (usually caching responses) completes successfully.

**Parameters**

* `options` – A `FetchEvent` or an object with the
  properties listed below.

**Returns:** A tuple of \[response, done]
promises that can be used to determine when the response resolves as
well as when the handler has completed all its work.