@angular/service-worker 12.2.8 → 13.0.0-next.11

package/config/config.d.ts

@@ -1,5 +1,5 @@
 /**
- * @license Angular v12.2.8
+ * @license Angular v13.0.0-next.11
  * (c) 2010-2021 Google LLC. https://angular.io/
  * License: MIT
  */

package/config/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@angular/service-worker/config",
-  "main": "../bundles/service-worker-config.umd.js",
-  "fesm2015": "../fesm2015/config.js",
-  "esm2015": "../esm2015/config/config.js",
+  "fesm2020": "../fesm2020/config.mjs",
+  "fesm2015": "../fesm2015/config.mjs",
+  "esm2020": "../esm2020/config/config.mjs",
   "typings": "./config.d.ts",
-  "module": "../fesm2015/config.js",
-  "es2015": "../fesm2015/config.js"
+  "module": "../fesm2015/config.mjs",
+  "es2020": "../fesm2020/config.mjs"
 }

package/esm2020/config/src/generator.mjs

@@ -0,0 +1,147 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { parseDurationToMs } from './duration';
+import { globToRegex } from './glob';
+const DEFAULT_NAVIGATION_URLS = [
+    '/**',
+    '!/**/*.*',
+    '!/**/*__*',
+    '!/**/*__*/**', // Exclude URLs containing `__` in any other segment.
+];
+/**
+ * Consumes service worker configuration files and processes them into control files.
+ *
+ * @publicApi
+ */
+export class Generator {
+    constructor(fs, baseHref) {
+        this.fs = fs;
+        this.baseHref = baseHref;
+    }
+    async process(config) {
+        const unorderedHashTable = {};
+        const assetGroups = await this.processAssetGroups(config, unorderedHashTable);
+        return {
+            configVersion: 1,
+            timestamp: Date.now(),
+            appData: config.appData,
+            index: joinUrls(this.baseHref, config.index),
+            assetGroups,
+            dataGroups: this.processDataGroups(config),
+            hashTable: withOrderedKeys(unorderedHashTable),
+            navigationUrls: processNavigationUrls(this.baseHref, config.navigationUrls),
+            navigationRequestStrategy: config.navigationRequestStrategy ?? 'performance',
+        };
+    }
+    async processAssetGroups(config, hashTable) {
+        const seenMap = new Set();
+        return Promise.all((config.assetGroups || []).map(async (group) => {
+            if (group.resources.versionedFiles) {
+                throw new Error(`Asset-group '${group.name}' in 'ngsw-config.json' uses the 'versionedFiles' option, ` +
+                    'which is no longer supported. Use \'files\' instead.');
+            }
+            const fileMatcher = globListToMatcher(group.resources.files || []);
+            const allFiles = await this.fs.list('/');
+            const matchedFiles = allFiles.filter(fileMatcher).filter(file => !seenMap.has(file)).sort();
+            matchedFiles.forEach(file => seenMap.add(file));
+            // Add the hashes.
+            await matchedFiles.reduce(async (previous, file) => {
+                await previous;
+                const hash = await this.fs.hash(file);
+                hashTable[joinUrls(this.baseHref, file)] = hash;
+            }, Promise.resolve());
+            return {
+                name: group.name,
+                installMode: group.installMode || 'prefetch',
+                updateMode: group.updateMode || group.installMode || 'prefetch',
+                cacheQueryOptions: buildCacheQueryOptions(group.cacheQueryOptions),
+                urls: matchedFiles.map(url => joinUrls(this.baseHref, url)),
+                patterns: (group.resources.urls || []).map(url => urlToRegex(url, this.baseHref, true)),
+            };
+        }));
+    }
+    processDataGroups(config) {
+        return (config.dataGroups || []).map(group => {
+            return {
+                name: group.name,
+                patterns: group.urls.map(url => urlToRegex(url, this.baseHref, true)),
+                strategy: group.cacheConfig.strategy || 'performance',
+                maxSize: group.cacheConfig.maxSize,
+                maxAge: parseDurationToMs(group.cacheConfig.maxAge),
+                timeoutMs: group.cacheConfig.timeout && parseDurationToMs(group.cacheConfig.timeout),
+                cacheQueryOptions: buildCacheQueryOptions(group.cacheQueryOptions),
+                version: group.version !== undefined ? group.version : 1,
+            };
+        });
+    }
+}
+export function processNavigationUrls(baseHref, urls = DEFAULT_NAVIGATION_URLS) {
+    return urls.map(url => {
+        const positive = !url.startsWith('!');
+        url = positive ? url : url.substr(1);
+        return { positive, regex: `^${urlToRegex(url, baseHref)}$` };
+    });
+}
+function globListToMatcher(globs) {
+    const patterns = globs.map(pattern => {
+        if (pattern.startsWith('!')) {
+            return {
+                positive: false,
+                regex: new RegExp('^' + globToRegex(pattern.substr(1)) + '$'),
+            };
+        }
+        else {
+            return {
+                positive: true,
+                regex: new RegExp('^' + globToRegex(pattern) + '$'),
+            };
+        }
+    });
+    return (file) => matches(file, patterns);
+}
+function matches(file, patterns) {
+    const res = patterns.reduce((isMatch, pattern) => {
+        if (pattern.positive) {
+            return isMatch || pattern.regex.test(file);
+        }
+        else {
+            return isMatch && !pattern.regex.test(file);
+        }
+    }, false);
+    return res;
+}
+function urlToRegex(url, baseHref, literalQuestionMark) {
+    if (!url.startsWith('/') && url.indexOf('://') === -1) {
+        // Prefix relative URLs with `baseHref`.
+        // Strip a leading `.` from a relative `baseHref` (e.g. `./foo/`), since it would result in an
+        // incorrect regex (matching a literal `.`).
+        url = joinUrls(baseHref.replace(/^\.(?=\/)/, ''), url);
+    }
+    return globToRegex(url, literalQuestionMark);
+}
+function joinUrls(a, b) {
+    if (a.endsWith('/') && b.startsWith('/')) {
+        return a + b.substr(1);
+    }
+    else if (!a.endsWith('/') && !b.startsWith('/')) {
+        return a + '/' + b;
+    }
+    return a + b;
+}
+function withOrderedKeys(unorderedObj) {
+    const orderedObj = {};
+    Object.keys(unorderedObj).sort().forEach(key => orderedObj[key] = unorderedObj[key]);
+    return orderedObj;
+}
+function buildCacheQueryOptions(inOptions) {
+    return {
+        ignoreVary: true,
+        ...inOptions,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../../../../../packages/service-worker/config/src/generator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {parseDurationToMs} from './duration';\nimport {Filesystem} from './filesystem';\nimport {globToRegex} from './glob';\nimport {Config} from './in';\n\nconst DEFAULT_NAVIGATION_URLS = [\n  '/**',           // Include all URLs.\n  '!/**/*.*',      // Exclude URLs to files (containing a file extension in the last segment).\n  '!/**/*__*',     // Exclude URLs containing `__` in the last segment.\n  '!/**/*__*/**',  // Exclude URLs containing `__` in any other segment.\n];\n\n/**\n * Consumes service worker configuration files and processes them into control files.\n *\n * @publicApi\n */\nexport class Generator {\n  constructor(readonly fs: Filesystem, private baseHref: string) {}\n\n  async process(config: Config): Promise<Object> {\n    const unorderedHashTable = {};\n    const assetGroups = await this.processAssetGroups(config, unorderedHashTable);\n\n    return {\n      configVersion: 1,\n      timestamp: Date.now(),\n      appData: config.appData,\n      index: joinUrls(this.baseHref, config.index),\n      assetGroups,\n      dataGroups: this.processDataGroups(config),\n      hashTable: withOrderedKeys(unorderedHashTable),\n      navigationUrls: processNavigationUrls(this.baseHref, config.navigationUrls),\n      navigationRequestStrategy: config.navigationRequestStrategy ?? 'performance',\n    };\n  }\n\n  private async processAssetGroups(config: Config, hashTable: {[file: string]: string|undefined}):\n      Promise<Object[]> {\n    const seenMap = new Set<string>();\n    return Promise.all((config.assetGroups || []).map(async (group) => {\n      if ((group.resources as any).versionedFiles) {\n        throw new Error(\n            `Asset-group '${group.name}' in 'ngsw-config.json' uses the 'versionedFiles' option, ` +\n            'which is no longer supported. Use \\'files\\' instead.');\n      }\n\n      const fileMatcher = globListToMatcher(group.resources.files || []);\n      const allFiles = await this.fs.list('/');\n\n      const matchedFiles = allFiles.filter(fileMatcher).filter(file => !seenMap.has(file)).sort();\n      matchedFiles.forEach(file => seenMap.add(file));\n\n      // Add the hashes.\n      await matchedFiles.reduce(async (previous, file) => {\n        await previous;\n        const hash = await this.fs.hash(file);\n        hashTable[joinUrls(this.baseHref, file)] = hash;\n      }, Promise.resolve());\n\n      return {\n        name: group.name,\n        installMode: group.installMode || 'prefetch',\n        updateMode: group.updateMode || group.installMode || 'prefetch',\n        cacheQueryOptions: buildCacheQueryOptions(group.cacheQueryOptions),\n        urls: matchedFiles.map(url => joinUrls(this.baseHref, url)),\n        patterns: (group.resources.urls || []).map(url => urlToRegex(url, this.baseHref, true)),\n      };\n    }));\n  }\n\n  private processDataGroups(config: Config): Object[] {\n    return (config.dataGroups || []).map(group => {\n      return {\n        name: group.name,\n        patterns: group.urls.map(url => urlToRegex(url, this.baseHref, true)),\n        strategy: group.cacheConfig.strategy || 'performance',\n        maxSize: group.cacheConfig.maxSize,\n        maxAge: parseDurationToMs(group.cacheConfig.maxAge),\n        timeoutMs: group.cacheConfig.timeout && parseDurationToMs(group.cacheConfig.timeout),\n        cacheQueryOptions: buildCacheQueryOptions(group.cacheQueryOptions),\n        version: group.version !== undefined ? group.version : 1,\n      };\n    });\n  }\n}\n\nexport function processNavigationUrls(\n    baseHref: string, urls = DEFAULT_NAVIGATION_URLS): {positive: boolean, regex: string}[] {\n  return urls.map(url => {\n    const positive = !url.startsWith('!');\n    url = positive ? url : url.substr(1);\n    return {positive, regex: `^${urlToRegex(url, baseHref)}$`};\n  });\n}\n\nfunction globListToMatcher(globs: string[]): (file: string) => boolean {\n  const patterns = globs.map(pattern => {\n    if (pattern.startsWith('!')) {\n      return {\n        positive: false,\n        regex: new RegExp('^' + globToRegex(pattern.substr(1)) + '$'),\n      };\n    } else {\n      return {\n        positive: true,\n        regex: new RegExp('^' + globToRegex(pattern) + '$'),\n      };\n    }\n  });\n  return (file: string) => matches(file, patterns);\n}\n\nfunction matches(file: string, patterns: {positive: boolean, regex: RegExp}[]): boolean {\n  const res = patterns.reduce((isMatch, pattern) => {\n    if (pattern.positive) {\n      return isMatch || pattern.regex.test(file);\n    } else {\n      return isMatch && !pattern.regex.test(file);\n    }\n  }, false);\n  return res;\n}\n\nfunction urlToRegex(url: string, baseHref: string, literalQuestionMark?: boolean): string {\n  if (!url.startsWith('/') && url.indexOf('://') === -1) {\n    // Prefix relative URLs with `baseHref`.\n    // Strip a leading `.` from a relative `baseHref` (e.g. `./foo/`), since it would result in an\n    // incorrect regex (matching a literal `.`).\n    url = joinUrls(baseHref.replace(/^\\.(?=\\/)/, ''), url);\n  }\n\n  return globToRegex(url, literalQuestionMark);\n}\n\nfunction joinUrls(a: string, b: string): string {\n  if (a.endsWith('/') && b.startsWith('/')) {\n    return a + b.substr(1);\n  } else if (!a.endsWith('/') && !b.startsWith('/')) {\n    return a + '/' + b;\n  }\n  return a + b;\n}\n\nfunction withOrderedKeys<T extends {[key: string]: any}>(unorderedObj: T): T {\n  const orderedObj = {} as {[key: string]: any};\n  Object.keys(unorderedObj).sort().forEach(key => orderedObj[key] = unorderedObj[key]);\n  return orderedObj as T;\n}\n\nfunction buildCacheQueryOptions(inOptions?: Pick<CacheQueryOptions, 'ignoreSearch'>):\n    CacheQueryOptions {\n  return {\n    ignoreVary: true,\n    ...inOptions,\n  };\n}\n"]}

package/esm2020/service-worker.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS13b3JrZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9zZXJ2aWNlLXdvcmtlci9zZXJ2aWNlLXdvcmtlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2020/src/low_level.mjs

@@ -0,0 +1,78 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { concat, defer, fromEvent, of, throwError } from 'rxjs';
+import { filter, map, publish, switchMap, take, tap } from 'rxjs/operators';
+export const ERR_SW_NOT_SUPPORTED = 'Service workers are disabled or not supported by this browser';
+function errorObservable(message) {
+    return defer(() => throwError(new Error(message)));
+}
+/**
+ * @publicApi
+ */
+export class NgswCommChannel {
+    constructor(serviceWorker) {
+        this.serviceWorker = serviceWorker;
+        if (!serviceWorker) {
+            this.worker = this.events = this.registration = errorObservable(ERR_SW_NOT_SUPPORTED);
+        }
+        else {
+            const controllerChangeEvents = fromEvent(serviceWorker, 'controllerchange');
+            const controllerChanges = controllerChangeEvents.pipe(map(() => serviceWorker.controller));
+            const currentController = defer(() => of(serviceWorker.controller));
+            const controllerWithChanges = concat(currentController, controllerChanges);
+            this.worker = controllerWithChanges.pipe(filter((c) => !!c));
+            this.registration = (this.worker.pipe(switchMap(() => serviceWorker.getRegistration())));
+            const rawEvents = fromEvent(serviceWorker, 'message');
+            const rawEventPayload = rawEvents.pipe(map(event => event.data));
+            const eventsUnconnected = rawEventPayload.pipe(filter(event => event && event.type));
+            const events = eventsUnconnected.pipe(publish());
+            events.connect();
+            this.events = events;
+        }
+    }
+    postMessage(action, payload) {
+        return this.worker
+            .pipe(take(1), tap((sw) => {
+            sw.postMessage({
+                action,
+                ...payload,
+            });
+        }))
+            .toPromise()
+            .then(() => undefined);
+    }
+    postMessageWithStatus(type, payload, nonce) {
+        const waitForStatus = this.waitForStatus(nonce);
+        const postMessage = this.postMessage(type, payload);
+        return Promise.all([waitForStatus, postMessage]).then(() => undefined);
+    }
+    generateNonce() {
+        return Math.round(Math.random() * 10000000);
+    }
+    eventsOfType(type) {
+        const filterFn = (event) => event.type === type;
+        return this.events.pipe(filter(filterFn));
+    }
+    nextEventOfType(type) {
+        return this.eventsOfType(type).pipe(take(1));
+    }
+    waitForStatus(nonce) {
+        return this.eventsOfType('STATUS')
+            .pipe(filter(event => event.nonce === nonce), take(1), map(event => {
+            if (event.status) {
+                return undefined;
+            }
+            throw new Error(event.error);
+        }))
+            .toPromise();
+    }
+    get isEnabled() {
+        return !!this.serviceWorker;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"low_level.js","sourceRoot":"","sources":["../../../../../../packages/service-worker/src/low_level.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {concat, ConnectableObservable, defer, fromEvent, Observable, of, throwError} from 'rxjs';\nimport {filter, map, publish, switchMap, take, tap} from 'rxjs/operators';\n\nexport const ERR_SW_NOT_SUPPORTED = 'Service workers are disabled or not supported by this browser';\n\n/**\n * An event emitted when a new version of the app is available.\n *\n * @see {@link guide/service-worker-communications Service worker communication guide}\n *\n * @publicApi\n */\nexport interface UpdateAvailableEvent {\n  type: 'UPDATE_AVAILABLE';\n  current: {hash: string, appData?: Object};\n  available: {hash: string, appData?: Object};\n}\n\n/**\n * An event emitted when a new version of the app has been downloaded and activated.\n *\n * @see {@link guide/service-worker-communications Service worker communication guide}\n *\n * @publicApi\n */\nexport interface UpdateActivatedEvent {\n  type: 'UPDATE_ACTIVATED';\n  previous?: {hash: string, appData?: Object};\n  current: {hash: string, appData?: Object};\n}\n\n/**\n * An event emitted when the version of the app used by the service worker to serve this client is\n * in a broken state that cannot be recovered from and a full page reload is required.\n *\n * For example, the service worker may not be able to retrieve a required resource, neither from the\n * cache nor from the server. This could happen if a new version is deployed to the server and the\n * service worker cache has been partially cleaned by the browser, removing some files of a previous\n * app version but not all.\n *\n * @see {@link guide/service-worker-communications Service worker communication guide}\n *\n * @publicApi\n */\nexport interface UnrecoverableStateEvent {\n  type: 'UNRECOVERABLE_STATE';\n  reason: string;\n}\n\n/**\n * An event emitted when a `PushEvent` is received by the service worker.\n */\nexport interface PushEvent {\n  type: 'PUSH';\n  data: any;\n}\n\nexport type IncomingEvent = UpdateAvailableEvent|UpdateActivatedEvent|UnrecoverableStateEvent;\n\nexport interface TypedEvent {\n  type: string;\n}\n\ninterface StatusEvent {\n  type: 'STATUS';\n  nonce: number;\n  status: boolean;\n  error?: string;\n}\n\n\nfunction errorObservable(message: string): Observable<any> {\n  return defer(() => throwError(new Error(message)));\n}\n\n/**\n * @publicApi\n */\nexport class NgswCommChannel {\n  readonly worker: Observable<ServiceWorker>;\n\n  readonly registration: Observable<ServiceWorkerRegistration>;\n\n  readonly events: Observable<TypedEvent>;\n\n  constructor(private serviceWorker: ServiceWorkerContainer|undefined) {\n    if (!serviceWorker) {\n      this.worker = this.events = this.registration = errorObservable(ERR_SW_NOT_SUPPORTED);\n    } else {\n      const controllerChangeEvents = fromEvent(serviceWorker, 'controllerchange');\n      const controllerChanges = controllerChangeEvents.pipe(map(() => serviceWorker.controller));\n      const currentController = defer(() => of(serviceWorker.controller));\n      const controllerWithChanges = concat(currentController, controllerChanges);\n\n      this.worker = controllerWithChanges.pipe(filter((c): c is ServiceWorker => !!c));\n\n      this.registration = <Observable<ServiceWorkerRegistration>>(\n          this.worker.pipe(switchMap(() => serviceWorker.getRegistration())));\n\n      const rawEvents = fromEvent<MessageEvent>(serviceWorker, 'message');\n      const rawEventPayload = rawEvents.pipe(map(event => event.data));\n      const eventsUnconnected = rawEventPayload.pipe(filter(event => event && event.type));\n      const events = eventsUnconnected.pipe(publish()) as ConnectableObservable<IncomingEvent>;\n      events.connect();\n\n      this.events = events;\n    }\n  }\n\n  postMessage(action: string, payload: Object): Promise<void> {\n    return this.worker\n        .pipe(take(1), tap((sw: ServiceWorker) => {\n                sw.postMessage({\n                  action,\n                  ...payload,\n                });\n              }))\n        .toPromise()\n        .then(() => undefined);\n  }\n\n  postMessageWithStatus(type: string, payload: Object, nonce: number): Promise<void> {\n    const waitForStatus = this.waitForStatus(nonce);\n    const postMessage = this.postMessage(type, payload);\n    return Promise.all([waitForStatus, postMessage]).then(() => undefined);\n  }\n\n  generateNonce(): number {\n    return Math.round(Math.random() * 10000000);\n  }\n\n  eventsOfType<T extends TypedEvent>(type: T['type']): Observable<T> {\n    const filterFn = (event: TypedEvent): event is T => event.type === type;\n    return this.events.pipe(filter(filterFn));\n  }\n\n  nextEventOfType<T extends TypedEvent>(type: T['type']): Observable<T> {\n    return this.eventsOfType(type).pipe(take(1));\n  }\n\n  waitForStatus(nonce: number): Promise<void> {\n    return this.eventsOfType<StatusEvent>('STATUS')\n        .pipe(filter(event => event.nonce === nonce), take(1), map(event => {\n                if (event.status) {\n                  return undefined;\n                }\n                throw new Error(event.error!);\n              }))\n        .toPromise();\n  }\n\n  get isEnabled(): boolean {\n    return !!this.serviceWorker;\n  }\n}\n"]}

package/esm2020/src/module.mjs

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { isPlatformBrowser } from '@angular/common';
+import { APP_INITIALIZER, ApplicationRef, InjectionToken, Injector, NgModule, NgZone, PLATFORM_ID } from '@angular/core';
+import { merge, of } from 'rxjs';
+import { delay, filter, take } from 'rxjs/operators';
+import { NgswCommChannel } from './low_level';
+import { SwPush } from './push';
+import { SwUpdate } from './update';
+import * as i0 from "@angular/core";
+/**
+ * Token that can be used to provide options for `ServiceWorkerModule` outside of
+ * `ServiceWorkerModule.register()`.
+ *
+ * You can use this token to define a provider that generates the registration options at runtime,
+ * for example via a function call:
+ *
+ * {@example service-worker/registration-options/module.ts region="registration-options"
+ *     header="app.module.ts"}
+ *
+ * @publicApi
+ */
+export class SwRegistrationOptions {
+}
+export const SCRIPT = new InjectionToken('NGSW_REGISTER_SCRIPT');
+export function ngswAppInitializer(injector, script, options, platformId) {
+    const initializer = () => {
+        if (!(isPlatformBrowser(platformId) && ('serviceWorker' in navigator) &&
+            options.enabled !== false)) {
+            return;
+        }
+        // Wait for service worker controller changes, and fire an INITIALIZE action when a new SW
+        // becomes active. This allows the SW to initialize itself even if there is no application
+        // traffic.
+        navigator.serviceWorker.addEventListener('controllerchange', () => {
+            if (navigator.serviceWorker.controller !== null) {
+                navigator.serviceWorker.controller.postMessage({ action: 'INITIALIZE' });
+            }
+        });
+        let readyToRegister$;
+        if (typeof options.registrationStrategy === 'function') {
+            readyToRegister$ = options.registrationStrategy();
+        }
+        else {
+            const [strategy, ...args] = (options.registrationStrategy || 'registerWhenStable:30000').split(':');
+            switch (strategy) {
+                case 'registerImmediately':
+                    readyToRegister$ = of(null);
+                    break;
+                case 'registerWithDelay':
+                    readyToRegister$ = delayWithTimeout(+args[0] || 0);
+                    break;
+                case 'registerWhenStable':
+                    readyToRegister$ = !args[0] ? whenStable(injector) :
+                        merge(whenStable(injector), delayWithTimeout(+args[0]));
+                    break;
+                default:
+                    // Unknown strategy.
+                    throw new Error(`Unknown ServiceWorker registration strategy: ${options.registrationStrategy}`);
+            }
+        }
+        // Don't return anything to avoid blocking the application until the SW is registered.
+        // Also, run outside the Angular zone to avoid preventing the app from stabilizing (especially
+        // given that some registration strategies wait for the app to stabilize).
+        // Catch and log the error if SW registration fails to avoid uncaught rejection warning.
+        const ngZone = injector.get(NgZone);
+        ngZone.runOutsideAngular(() => readyToRegister$.pipe(take(1)).subscribe(() => navigator.serviceWorker.register(script, { scope: options.scope })
+            .catch(err => console.error('Service worker registration failed with:', err))));
+    };
+    return initializer;
+}
+function delayWithTimeout(timeout) {
+    return of(null).pipe(delay(timeout));
+}
+function whenStable(injector) {
+    const appRef = injector.get(ApplicationRef);
+    return appRef.isStable.pipe(filter(stable => stable));
+}
+export function ngswCommChannelFactory(opts, platformId) {
+    return new NgswCommChannel(isPlatformBrowser(platformId) && opts.enabled !== false ? navigator.serviceWorker :
+        undefined);
+}
+/**
+ * @publicApi
+ */
+export class 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.
+     */
+    static register(script, opts = {}) {
+        return {
+            ngModule: ServiceWorkerModule,
+            providers: [
+                { provide: SCRIPT, useValue: script },
+                { provide: SwRegistrationOptions, useValue: opts },
+                {
+                    provide: NgswCommChannel,
+                    useFactory: ngswCommChannelFactory,
+                    deps: [SwRegistrationOptions, PLATFORM_ID]
+                },
+                {
+                    provide: APP_INITIALIZER,
+                    useFactory: ngswAppInitializer,
+                    deps: [Injector, SCRIPT, SwRegistrationOptions, PLATFORM_ID],
+                    multi: true,
+                },
+            ],
+        };
+    }
+}
+ServiceWorkerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: ServiceWorkerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ServiceWorkerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: ServiceWorkerModule });
+ServiceWorkerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: ServiceWorkerModule, providers: [SwPush, SwUpdate] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.11", ngImport: i0, type: ServiceWorkerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [SwPush, SwUpdate],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../../../packages/service-worker/src/module.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {isPlatformBrowser} from '@angular/common';\nimport {APP_INITIALIZER, ApplicationRef, InjectionToken, Injector, ModuleWithProviders, NgModule, NgZone, PLATFORM_ID} from '@angular/core';\nimport {merge, Observable, of} from 'rxjs';\nimport {delay, filter, take} from 'rxjs/operators';\n\nimport {NgswCommChannel} from './low_level';\nimport {SwPush} from './push';\nimport {SwUpdate} from './update';\n\n/**\n * Token that can be used to provide options for `ServiceWorkerModule` outside of\n * `ServiceWorkerModule.register()`.\n *\n * You can use this token to define a provider that generates the registration options at runtime,\n * for example via a function call:\n *\n * {@example service-worker/registration-options/module.ts region=\"registration-options\"\n *     header=\"app.module.ts\"}\n *\n * @publicApi\n */\nexport abstract class SwRegistrationOptions {\n  /**\n   * Whether the ServiceWorker will be registered and the related services (such as `SwPush` and\n   * `SwUpdate`) will attempt to communicate and interact with it.\n   *\n   * Default: true\n   */\n  enabled?: boolean;\n\n  /**\n   * A URL that defines the ServiceWorker's registration scope; that is, what range of URLs it can\n   * control. It will be used when calling\n   * [ServiceWorkerContainer#register()](https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/register).\n   */\n  scope?: string;\n\n  /**\n   * Defines the ServiceWorker registration strategy, which determines when it will be registered\n   * with the browser.\n   *\n   * The default behavior of registering once the application stabilizes (i.e. as soon as there are\n   * no pending micro- and macro-tasks) is designed to register the ServiceWorker as soon as\n   * possible but without affecting the application's first time load.\n   *\n   * Still, there might be cases where you want more control over when the ServiceWorker is\n   * registered (for example, there might be a long-running timeout or polling interval, preventing\n   * the app from stabilizing). The available option are:\n   *\n   * - `registerWhenStable:<timeout>`: Register as soon as the application stabilizes (no pending\n   *     micro-/macro-tasks) but no later than `<timeout>` milliseconds. If the app hasn't\n   *     stabilized after `<timeout>` milliseconds (for example, due to a recurrent asynchronous\n   *     task), the ServiceWorker will be registered anyway.\n   *     If `<timeout>` is omitted, the ServiceWorker will only be registered once the app\n   *     stabilizes.\n   * - `registerImmediately`: Register immediately.\n   * - `registerWithDelay:<timeout>`: Register with a delay of `<timeout>` milliseconds. For\n   *     example, use `registerWithDelay:5000` to register the ServiceWorker after 5 seconds. If\n   *     `<timeout>` is omitted, is defaults to `0`, which will register the ServiceWorker as soon\n   *     as possible but still asynchronously, once all pending micro-tasks are completed.\n   * - An [Observable](guide/observables) factory function: A function that returns an `Observable`.\n   *     The function will be used at runtime to obtain and subscribe to the `Observable` and the\n   *     ServiceWorker will be registered as soon as the first value is emitted.\n   *\n   * Default: 'registerWhenStable:30000'\n   */\n  registrationStrategy?: string|(() => Observable<unknown>);\n}\n\nexport const SCRIPT = new InjectionToken<string>('NGSW_REGISTER_SCRIPT');\n\nexport function ngswAppInitializer(\n    injector: Injector, script: string, options: SwRegistrationOptions,\n    platformId: string): Function {\n  const initializer = () => {\n    if (!(isPlatformBrowser(platformId) && ('serviceWorker' in navigator) &&\n          options.enabled !== false)) {\n      return;\n    }\n\n    // Wait for service worker controller changes, and fire an INITIALIZE action when a new SW\n    // becomes active. This allows the SW to initialize itself even if there is no application\n    // traffic.\n    navigator.serviceWorker.addEventListener('controllerchange', () => {\n      if (navigator.serviceWorker.controller !== null) {\n        navigator.serviceWorker.controller.postMessage({action: 'INITIALIZE'});\n      }\n    });\n\n    let readyToRegister$: Observable<unknown>;\n\n    if (typeof options.registrationStrategy === 'function') {\n      readyToRegister$ = options.registrationStrategy();\n    } else {\n      const [strategy, ...args] =\n          (options.registrationStrategy || 'registerWhenStable:30000').split(':');\n\n      switch (strategy) {\n        case 'registerImmediately':\n          readyToRegister$ = of(null);\n          break;\n        case 'registerWithDelay':\n          readyToRegister$ = delayWithTimeout(+args[0] || 0);\n          break;\n        case 'registerWhenStable':\n          readyToRegister$ = !args[0] ? whenStable(injector) :\n                                        merge(whenStable(injector), delayWithTimeout(+args[0]));\n          break;\n        default:\n          // Unknown strategy.\n          throw new Error(\n              `Unknown ServiceWorker registration strategy: ${options.registrationStrategy}`);\n      }\n    }\n\n    // Don't return anything to avoid blocking the application until the SW is registered.\n    // Also, run outside the Angular zone to avoid preventing the app from stabilizing (especially\n    // given that some registration strategies wait for the app to stabilize).\n    // Catch and log the error if SW registration fails to avoid uncaught rejection warning.\n    const ngZone = injector.get(NgZone);\n    ngZone.runOutsideAngular(\n        () => readyToRegister$.pipe(take(1)).subscribe(\n            () =>\n                navigator.serviceWorker.register(script, {scope: options.scope})\n                    .catch(err => console.error('Service worker registration failed with:', err))));\n  };\n  return initializer;\n}\n\nfunction delayWithTimeout(timeout: number): Observable<unknown> {\n  return of(null).pipe(delay(timeout));\n}\n\nfunction whenStable(injector: Injector): Observable<unknown> {\n  const appRef = injector.get(ApplicationRef);\n  return appRef.isStable.pipe(filter(stable => stable));\n}\n\nexport function ngswCommChannelFactory(\n    opts: SwRegistrationOptions, platformId: string): NgswCommChannel {\n  return new NgswCommChannel(\n      isPlatformBrowser(platformId) && opts.enabled !== false ? navigator.serviceWorker :\n                                                                undefined);\n}\n\n/**\n * @publicApi\n */\n@NgModule({\n  providers: [SwPush, SwUpdate],\n})\nexport class ServiceWorkerModule {\n  /**\n   * Register the given Angular Service Worker script.\n   *\n   * If `enabled` is set to `false` in the given options, the module will behave as if service\n   * workers are not supported by the browser, and the service worker will not be registered.\n   */\n  static register(script: string, opts: SwRegistrationOptions = {}):\n      ModuleWithProviders<ServiceWorkerModule> {\n    return {\n      ngModule: ServiceWorkerModule,\n      providers: [\n        {provide: SCRIPT, useValue: script},\n        {provide: SwRegistrationOptions, useValue: opts},\n        {\n          provide: NgswCommChannel,\n          useFactory: ngswCommChannelFactory,\n          deps: [SwRegistrationOptions, PLATFORM_ID]\n        },\n        {\n          provide: APP_INITIALIZER,\n          useFactory: ngswAppInitializer,\n          deps: [Injector, SCRIPT, SwRegistrationOptions, PLATFORM_ID],\n          multi: true,\n        },\n      ],\n    };\n  }\n}\n"]}