@serwist/window 8.4.3 → 9.0.0-preview.0

package/src/index.ts

@@ -0,0 +1,15 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import { Serwist } from "./Serwist.js";
+import { messageSW } from "./messageSW.js";
+
+export { messageSW, Serwist };
+
+// See https://github.com/GoogleChrome/workbox/issues/2770
+export * from "./utils/SerwistEvent.js";

package/src/messageSW.ts

@@ -0,0 +1,33 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+/**
+ * Sends a data object to a service worker via `postMessage` and resolves with
+ * a response (if any).
+ *
+ * A response can be set in a message handler in the service worker by
+ * calling `event.ports[0].postMessage(...)`, which will resolve the promise
+ * returned by `messageSW()`. If no response is set, the promise will not
+ * resolve.
+ *
+ * @param sw The service worker to send the message to.
+ * @param data An object to send to the service worker.
+ * @returns
+ */
+// biome-ignore lint/complexity/noBannedTypes: Better not change type of data.
+function messageSW(sw: ServiceWorker, data: {}): Promise<any> {
+  return new Promise((resolve) => {
+    const messageChannel = new MessageChannel();
+    messageChannel.port1.onmessage = (event: MessageEvent) => {
+      resolve(event.data);
+    };
+    sw.postMessage(data, [messageChannel.port2]);
+  });
+}
+
+export { messageSW };

package/src/utils/SerwistEvent.ts

@@ -0,0 +1,57 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import type { SerwistEventTarget } from "./SerwistEventTarget.js";
+
+/**
+ * A minimal `Event` subclass shim.
+ * This doesn't *actually* subclass `Event` because not all browsers support
+ * constructable `EventTarget`, and using a real `Event` will error.
+ * @private
+ */
+export class SerwistEvent<K extends keyof SerwistEventMap> {
+  target?: SerwistEventTarget;
+  sw?: ServiceWorker;
+  originalEvent?: Event;
+  isExternal?: boolean;
+
+  constructor(
+    public type: K,
+    props: Omit<SerwistEventMap[K], "target" | "type">,
+  ) {
+    Object.assign(this, props);
+  }
+}
+
+export interface SerwistMessageEvent extends SerwistEvent<"message"> {
+  data: any;
+  originalEvent: Event;
+  ports: readonly MessagePort[];
+}
+
+export interface SerwistLifecycleEvent extends SerwistEvent<keyof SerwistLifecycleEventMap> {
+  isUpdate?: boolean;
+}
+
+export interface SerwistLifecycleWaitingEvent extends SerwistLifecycleEvent {
+  wasWaitingBeforeRegister?: boolean;
+}
+
+export interface SerwistLifecycleEventMap {
+  installing: SerwistLifecycleEvent;
+  installed: SerwistLifecycleEvent;
+  waiting: SerwistLifecycleWaitingEvent;
+  activating: SerwistLifecycleEvent;
+  activated: SerwistLifecycleEvent;
+  controlling: SerwistLifecycleEvent;
+  redundant: SerwistLifecycleEvent;
+}
+
+export interface SerwistEventMap extends SerwistLifecycleEventMap {
+  message: SerwistMessageEvent;
+}

package/src/utils/SerwistEventTarget.ts

@@ -0,0 +1,68 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+import type { SerwistEvent, SerwistEventMap } from "./SerwistEvent.js";
+
+export type ListenerCallback = (event: SerwistEvent<any>) => any;
+
+/**
+ * A minimal `EventTarget` shim.
+ * This is necessary because not all browsers support constructable
+ * `EventTarget`, so using a real `EventTarget` will error.
+ * @private
+ */
+export class SerwistEventTarget {
+  private readonly _eventListenerRegistry: Map<keyof SerwistEventMap, Set<ListenerCallback>> = new Map();
+
+  /**
+   * @param type
+   * @param listener
+   * @private
+   */
+  addEventListener<K extends keyof SerwistEventMap>(type: K, listener: (event: SerwistEventMap[K]) => any): void {
+    const foo = this._getEventListenersByType(type);
+    foo.add(listener as ListenerCallback);
+  }
+
+  /**
+   * @param type
+   * @param listener
+   * @private
+   */
+  removeEventListener<K extends keyof SerwistEventMap>(type: K, listener: (event: SerwistEventMap[K]) => any): void {
+    this._getEventListenersByType(type).delete(listener as ListenerCallback);
+  }
+
+  /**
+   * @param event
+   * @private
+   */
+  dispatchEvent(event: SerwistEvent<any>): void {
+    event.target = this;
+
+    const listeners = this._getEventListenersByType(event.type);
+    for (const listener of listeners) {
+      listener(event);
+    }
+  }
+
+  /**
+   * Returns a Set of listeners associated with the passed event type.
+   * If no handlers have been registered, an empty Set is returned.
+   *
+   * @param type The event type.
+   * @returns An array of handler functions.
+   * @private
+   */
+  private _getEventListenersByType(type: keyof SerwistEventMap) {
+    if (!this._eventListenerRegistry.has(type)) {
+      this._eventListenerRegistry.set(type, new Set());
+    }
+    return this._eventListenerRegistry.get(type)!;
+  }
+}

package/src/utils/urlsMatch.ts

@@ -0,0 +1,21 @@
+/*
+  Copyright 2019 Google LLC
+
+  Use of this source code is governed by an MIT-style
+  license that can be found in the LICENSE file or at
+  https://opensource.org/licenses/MIT.
+*/
+
+/**
+ * Returns true if two URLs have the same `.href` property. The URLS can be
+ * relative, and if they are the current location href is used to resolve URLs.
+ *
+ * @private
+ * @param url1
+ * @param url2
+ * @returns
+ */
+export function urlsMatch(url1: string, url2: string): boolean {
+  const { href } = location;
+  return new URL(url1, href).href === new URL(url2, href).href;
+}