@angular/service-worker

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<ServiceWorkerModule, never>;

property ɵinj

static ɵinj: i0.ɵɵInjectorDeclaration<ServiceWorkerModule>;

property ɵmod

static ɵmod: i0.ɵɵNgModuleDeclaration<ServiceWorkerModule, never, never, never>;

method register

static register: (
    script: string,
    options?: SwRegistrationOptions
) => ModuleWithProviders<ServiceWorkerModule>;

• Register the given Angular Service Worker script.

  If enabled is set to false in the given options, the module will behave as if service workers are not supported by the browser, and the service worker will not be registered.

constructor

constructor(sw: NgswCommChannel);

property isEnabled

readonly isEnabled: boolean;

• True if the Service Worker is enabled (supported by the browser and enabled via ServiceWorkerModule).

property messages

readonly messages: Observable<object>;

• Emits the payloads of the received push notification messages.

property notificationClicks

readonly notificationClicks: Observable<{
    action: string;
    notification: NotificationOptions & { title: string };
}>;

• Emits the payloads of the received push notification messages as well as the action the user interacted with. If no action was used the action property contains an empty string ''.

  Note that the notification property does **not** contain a [Notification][Mozilla Notification] object but rather a [NotificationOptions](https://notifications.spec.whatwg.org/#dictdef-notificationoptions) object that also includes the title of the [Notification][Mozilla Notification] object.

  [Mozilla Notification]: https://developer.mozilla.org/en-US/docs/Web/API/Notification

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<SwPush, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<SwPush>;

property subscription

readonly subscription: Observable<PushSubscription>;

• Emits the currently active [PushSubscription](https://developer.mozilla.org/en-US/docs/Web/API/PushSubscription) associated to the Service Worker registration or null if there is no subscription.

method requestSubscription

requestSubscription: (options: {
    serverPublicKey: string;
}) => Promise<PushSubscription>;

• Subscribes to Web Push Notifications, after requesting and receiving user permission.

  Parameter options

  An object containing the serverPublicKey string.

  Returns

  A Promise that resolves to the new subscription object.

method unsubscribe

unsubscribe: () => Promise<void>;

• Unsubscribes from Service Worker push notifications.

  Returns

  A Promise that is resolved when the operation succeeds, or is rejected if there is no active subscription or the unsubscribe operation fails.

property enabled

enabled?: boolean;

• Whether the ServiceWorker will be registered and the related services (such as SwPush and SwUpdate) will attempt to communicate and interact with it.

  Default: true

property registrationStrategy

registrationStrategy?: string | (() => Observable<unknown>);

• Defines the ServiceWorker registration strategy, which determines when it will be registered with the browser.

  The default behavior of registering once the application stabilizes (i.e. as soon as there are no pending micro- and macro-tasks) is designed to register the ServiceWorker as soon as possible but without affecting the application's first time load.

  Still, there might be cases where you want more control over when the ServiceWorker is registered (for example, there might be a long-running timeout or polling interval, preventing the app from stabilizing). The available option are:

  - registerWhenStable:<timeout>: Register as soon as the application stabilizes (no pending micro-/macro-tasks) but no later than <timeout> milliseconds. If the app hasn't stabilized after <timeout> milliseconds (for example, due to a recurrent asynchronous task), the ServiceWorker will be registered anyway. If <timeout> is omitted, the ServiceWorker will only be registered once the app stabilizes. - registerImmediately: Register immediately. - registerWithDelay:<timeout>: Register with a delay of <timeout> milliseconds. For example, use registerWithDelay:5000 to register the ServiceWorker after 5 seconds. If <timeout> is omitted, is defaults to 0, which will register the ServiceWorker as soon as possible but still asynchronously, once all pending micro-tasks are completed. - An Observable factory function: A function that returns an Observable. The function will be used at runtime to obtain and subscribe to the Observable and the ServiceWorker will be registered as soon as the first value is emitted.

  Default: 'registerWhenStable:30000'

property scope

scope?: string;

• A URL that defines the ServiceWorker's registration scope; that is, what range of URLs it can control. It will be used when calling [ServiceWorkerContainer#register()](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register).

constructor

constructor(sw: NgswCommChannel);

property isEnabled

readonly isEnabled: boolean;

• True if the Service Worker is enabled (supported by the browser and enabled via ServiceWorkerModule).

property ɵfac

static ɵfac: i0.ɵɵFactoryDeclaration<SwUpdate, never>;

property ɵprov

static ɵprov: i0.ɵɵInjectableDeclaration<SwUpdate>;

property unrecoverable

readonly unrecoverable: Observable<UnrecoverableStateEvent>;

• Emits an UnrecoverableStateEvent event whenever the version of the app used by the service worker to serve this client is in a broken state that cannot be recovered from without a full page reload.

property versionUpdates

readonly versionUpdates: Observable<VersionEvent>;

• Emits a VersionDetectedEvent event whenever a new version is detected on the server.

  Emits a VersionInstallationFailedEvent event whenever checking for or downloading a new version fails.

  Emits a VersionReadyEvent event whenever a new version has been downloaded and is ready for activation.

method activateUpdate

activateUpdate: () => Promise<boolean>;

• Updates the current client (i.e. browser tab) to the latest version that is ready for activation.

  In most cases, you should not use this method and instead should update a client by reloading the page.

  Updating a client without reloading can easily result in a broken application due to a version mismatch between the application shell and other page resources, such as lazy-loaded chunks, whose filenames may change between versions.

  Only use this method, if you are certain it is safe for your specific use case.

  Returns

  a promise that - resolves to true if an update was activated successfully - resolves to false if no update was available (for example, the client was already on the latest version). - rejects if any error occurs

method checkForUpdate

checkForUpdate: () => Promise<boolean>;

• Checks for an update and waits until the new version is downloaded from the server and ready for activation.

  Returns

  a promise that - resolves to true if a new version was found and is ready to be activated. - resolves to false if no new version was found - rejects if any error occurs

property type

type: 'NO_NEW_VERSION_DETECTED';

property version

version: {
    hash: string;
    appData?: Object;
};

property reason

reason: string;

property type

type: 'UNRECOVERABLE_STATE';

property type

type: 'VERSION_DETECTED';

property version

version: {
    hash: string;
    appData?: object;
};

property error

error: string;

property type

type: 'VERSION_INSTALLATION_FAILED';

property version

version: {
    hash: string;
    appData?: object;
};

property currentVersion

currentVersion: {
    hash: string;
    appData?: object;
};

property latestVersion

latestVersion: {
    hash: string;
    appData?: object;
};

property type

type: 'VERSION_READY';