@angular/service-worker
Version:
Angular - service worker tooling!
192 lines (191 loc) • 15.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. 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';
/** @type {?} */
export const ERR_SW_NOT_SUPPORTED = 'Service workers are disabled or not supported by this browser';
/**
* An event emitted when a new version of the app is available.
*
* \@publicApi
* @record
*/
export function UpdateAvailableEvent() { }
/** @type {?} */
UpdateAvailableEvent.prototype.type;
/** @type {?} */
UpdateAvailableEvent.prototype.current;
/** @type {?} */
UpdateAvailableEvent.prototype.available;
/**
* An event emitted when a new version of the app has been downloaded and activated.
*
* \@publicApi
* @record
*/
export function UpdateActivatedEvent() { }
/** @type {?} */
UpdateActivatedEvent.prototype.type;
/** @type {?|undefined} */
UpdateActivatedEvent.prototype.previous;
/** @type {?} */
UpdateActivatedEvent.prototype.current;
/**
* An event emitted when a `PushEvent` is received by the service worker.
* @record
*/
export function PushEvent() { }
/** @type {?} */
PushEvent.prototype.type;
/** @type {?} */
PushEvent.prototype.data;
/** @typedef {?} */
var IncomingEvent;
export { IncomingEvent };
/**
* @record
*/
export function TypedEvent() { }
/** @type {?} */
TypedEvent.prototype.type;
/**
* @record
*/
function StatusEvent() { }
/** @type {?} */
StatusEvent.prototype.type;
/** @type {?} */
StatusEvent.prototype.nonce;
/** @type {?} */
StatusEvent.prototype.status;
/** @type {?|undefined} */
StatusEvent.prototype.error;
/**
* @param {?} message
* @return {?}
*/
function errorObservable(message) {
return defer(() => throwError(new Error(message)));
}
/**
* \@publicApi
*/
export class NgswCommChannel {
/**
* @param {?} serviceWorker
*/
constructor(serviceWorker) {
this.serviceWorker = serviceWorker;
if (!serviceWorker) {
this.worker = this.events = this.registration = errorObservable(ERR_SW_NOT_SUPPORTED);
}
else {
/** @type {?} */
const controllerChangeEvents = fromEvent(serviceWorker, 'controllerchange');
/** @type {?} */
const controllerChanges = controllerChangeEvents.pipe(map(() => serviceWorker.controller));
/** @type {?} */
const currentController = defer(() => of(serviceWorker.controller));
/** @type {?} */
const controllerWithChanges = concat(currentController, controllerChanges);
this.worker = controllerWithChanges.pipe(filter(c => !!c));
this.registration = /** @type {?} */ ((this.worker.pipe(switchMap(() => serviceWorker.getRegistration()))));
/** @type {?} */
const rawEvents = fromEvent(serviceWorker, 'message');
/** @type {?} */
const rawEventPayload = rawEvents.pipe(map(event => event.data));
/** @type {?} */
const eventsUnconnected = rawEventPayload.pipe(filter(event => event && event.type));
/** @type {?} */
const events = /** @type {?} */ (eventsUnconnected.pipe(publish()));
events.connect();
this.events = events;
}
}
/**
* @param {?} action
* @param {?} payload
* @return {?}
*/
postMessage(action, payload) {
return this.worker
.pipe(take(1), tap((sw) => {
sw.postMessage(Object.assign({ action }, payload));
}))
.toPromise()
.then(() => undefined);
}
/**
* @param {?} type
* @param {?} payload
* @param {?} nonce
* @return {?}
*/
postMessageWithStatus(type, payload, nonce) {
/** @type {?} */
const waitForStatus = this.waitForStatus(nonce);
/** @type {?} */
const postMessage = this.postMessage(type, payload);
return Promise.all([waitForStatus, postMessage]).then(() => undefined);
}
/**
* @return {?}
*/
generateNonce() { return Math.round(Math.random() * 10000000); }
/**
* @template T
* @param {?} type
* @return {?}
*/
eventsOfType(type) {
/** @type {?} */
const filterFn = (event) => event.type === type;
return this.events.pipe(filter(filterFn));
}
/**
* @template T
* @param {?} type
* @return {?}
*/
nextEventOfType(type) {
return this.eventsOfType(type).pipe(take(1));
}
/**
* @param {?} nonce
* @return {?}
*/
waitForStatus(nonce) {
return this.eventsOfType('STATUS')
.pipe(filter(event => event.nonce === nonce), take(1), map(event => {
if (event.status) {
return undefined;
}
throw new Error(/** @type {?} */ ((event.error)));
}))
.toPromise();
}
/**
* @return {?}
*/
get isEnabled() { return !!this.serviceWorker; }
}
if (false) {
/** @type {?} */
NgswCommChannel.prototype.worker;
/** @type {?} */
NgswCommChannel.prototype.registration;
/** @type {?} */
NgswCommChannel.prototype.events;
/** @type {?} */
NgswCommChannel.prototype.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 Inc. 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 {ConnectableObservable, Observable, concat, defer, fromEvent, 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 * @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 * @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 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;\n\nexport interface TypedEvent { type: string; }\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<ServiceWorker>(c => !!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, ...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 { return Math.round(Math.random() * 10000000); }\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 { return !!this.serviceWorker; }\n}\n"]}