@openmrs/esm-app-shell 5.3.3-pre.1231 → 5.3.3-pre.1247

package/src/run.ts

@@ -1,4 +1,4 @@
-import { start, triggerAppChange } from "single-spa";
+import { start, triggerAppChange } from 'single-spa';
 import {
   setupApiModule,
   renderLoadingSpinner,
@@ -31,19 +31,15 @@ import {
   OpenmrsRoutes,
   getCurrentImportMap,
   importDynamic,
-} from "@openmrs/esm-framework/src/internal";
-import {
-  finishRegisteringAllApps,
-  registerApp,
-  tryRegisterExtension,
-} from "./apps";
-import { setupI18n } from "./locale";
-import { appName, getCoreExtensions } from "./ui";
+} from '@openmrs/esm-framework/src/internal';
+import { finishRegisteringAllApps, registerApp, tryRegisterExtension } from './apps';
+import { setupI18n } from './locale';
+import { appName, getCoreExtensions } from './ui';
 
 // @internal
 // used to track when the window.installedModules global is finalised
 // so we can pre-load all modules
-const REGISTRATION_PROMISES = Symbol("openmrs_registration_promises");
+const REGISTRATION_PROMISES = Symbol('openmrs_registration_promises');
 
 /**
  * Sets up the frontend modules (apps). Uses the defined export
@@ -52,9 +48,7 @@ const REGISTRATION_PROMISES = Symbol("openmrs_registration_promises");
  * as the registry of all apps in the application.
  */
 async function setupApps() {
-  const scriptTags = document.querySelectorAll<HTMLScriptElement>(
-    "script[type='openmrs-routes']"
-  );
+  const scriptTags = document.querySelectorAll<HTMLScriptElement>("script[type='openmrs-routes']");
 
   const promises: Array<Promise<OpenmrsRoutes>> = [];
   for (let i = 0; i < scriptTags.length; i++) {
@@ -68,33 +62,26 @@ async function setupApps() {
             routes = (await openmrsFetch<OpenmrsRoutes>(scriptTag.src)).data;
           }
         } catch (e) {
-          console.error(
-            `Caught error while loading routes from ${
-              scriptTag.src ?? "JSON script tag content"
-            }`,
-            e
-          );
+          console.error(`Caught error while loading routes from ${scriptTag.src ?? 'JSON script tag content'}`, e);
 
           return {};
         }
 
         return Promise.resolve(routes ?? {});
-      })(scriptTags.item(i))
+      })(scriptTags.item(i)),
     );
   }
 
   const routes = (await Promise.all(promises)).reduce(
     (accumulatedRoutes, routes) => ({ ...accumulatedRoutes, ...routes }),
-    {}
+    {},
   );
 
   const modules: typeof window.installedModules = [];
-  const registrationPromises = Object.entries(routes).map(
-    async ([module, routes]) => {
-      modules.push([module, routes]);
-      registerApp(module, routes);
-    }
-  );
+  const registrationPromises = Object.entries(routes).map(async ([module, routes]) => {
+    modules.push([module, routes]);
+    registerApp(module, routes);
+  });
 
   window[REGISTRATION_PROMISES] = Promise.all(registrationPromises);
   window.installedModules = modules;
@@ -120,9 +107,9 @@ function connectivityChanged() {
   dispatchConnectivityChanged(online);
   showToast({
     critical: true,
-    description: `Connection: ${online ? "online" : "offline"}`,
-    title: "App",
-    kind: online ? "success" : "warning",
+    description: `Connection: ${online ? 'online' : 'offline'}`,
+    title: 'App',
+    kind: online ? 'success' : 'warning',
   });
 }
 
@@ -130,18 +117,15 @@ function connectivityChanged() {
  * Runs the shell by importing the translations and starting single SPA.
  */
 function runShell() {
-  window.addEventListener("offline", connectivityChanged);
-  window.addEventListener("online", connectivityChanged);
+  window.addEventListener('offline', connectivityChanged);
+  window.addEventListener('online', connectivityChanged);
   return setupI18n()
     .catch((err) => console.error(`Failed to initialize translations`, err))
     .then(() => start());
 }
 
 async function preloadScripts() {
-  const [, importMap] = await Promise.all([
-    window[REGISTRATION_PROMISES],
-    getCurrentImportMap(),
-  ]);
+  const [, importMap] = await Promise.all([window[REGISTRATION_PROMISES], getCurrentImportMap()]);
 
   window.installedModules.map(async ([module]) => {
     // we simply swallow the error here since this is only a preload
@@ -155,28 +139,25 @@ function handleInitFailure(e: Error) {
 }
 
 function renderFatalErrorPage(e?: Error) {
-  const template = document.querySelector<HTMLTemplateElement>("#app-error");
+  const template = document.querySelector<HTMLTemplateElement>('#app-error');
 
   if (template) {
     const fragment = template.content.cloneNode(true) as DocumentFragment;
     const messageContainer = fragment.querySelector('[data-var="message"]');
 
     if (messageContainer) {
-      messageContainer.textContent =
-        e?.message || "No additional information available.";
+      messageContainer.textContent = e?.message || 'No additional information available.';
     }
 
     if (
-      localStorage.getItem("openmrs:devtools") &&
-      Object.keys(localStorage).some((k) =>
-        k.startsWith("import-map-override:")
-      )
+      localStorage.getItem('openmrs:devtools') &&
+      Object.keys(localStorage).some((k) => k.startsWith('import-map-override:'))
     ) {
-      const appErrorActionButtons = fragment?.querySelector("#buttons");
+      const appErrorActionButtons = fragment?.querySelector('#buttons');
       if (appErrorActionButtons) {
-        const clearDevOverridesButton = document.createElement("button");
-        clearDevOverridesButton.className = "cds--btn";
-        clearDevOverridesButton.innerHTML = "Clear dev overrides";
+        const clearDevOverridesButton = document.createElement('button');
+        clearDevOverridesButton.className = 'cds--btn';
+        clearDevOverridesButton.innerHTML = 'Clear dev overrides';
         clearDevOverridesButton.onclick = clearDevOverrides;
         appErrorActionButtons.appendChild(clearDevOverridesButton);
       }
@@ -189,10 +170,8 @@ function renderFatalErrorPage(e?: Error) {
 function clearDevOverrides() {
   for (const key of Object.keys(localStorage)) {
     if (
-      key.startsWith("import-map-override:") &&
-      !["import-map-override:react", "import-map-override:react-dom"].includes(
-        key
-      )
+      key.startsWith('import-map-override:') &&
+      !['import-map-override:react', 'import-map-override:react-dom'].includes(key)
     ) {
       localStorage.removeItem(key);
     }
@@ -217,34 +196,30 @@ function createConfigLoader(configUrls: Array<string>) {
             value: {},
           };
         });
-    })
+    }),
   );
   return () => loadingConfigs.then(loadConfigs);
 }
 
 function showNotifications() {
-  renderInlineNotifications(
-    document.querySelector(".omrs-inline-notifications-container")
-  );
+  renderInlineNotifications(document.querySelector('.omrs-inline-notifications-container'));
   return;
 }
 
 function showActionableNotifications() {
-  renderActionableNotifications(
-    document.querySelector(".omrs-actionable-notifications-container")
-  );
+  renderActionableNotifications(document.querySelector('.omrs-actionable-notifications-container'));
 }
 
 function showToasts() {
-  renderToasts(document.querySelector(".omrs-toasts-container"));
+  renderToasts(document.querySelector('.omrs-toasts-container'));
 }
 
 function showSnackbars() {
-  renderSnackbars(document.querySelector(".omrs-snackbars-container"));
+  renderSnackbars(document.querySelector('.omrs-snackbars-container'));
 }
 
 function showModals() {
-  renderModals(document.querySelector(".omrs-modals-container"));
+  renderModals(document.querySelector('.omrs-modals-container'));
 }
 
 function showLoadingSpinner() {
@@ -263,16 +238,14 @@ function registerCoreExtensions() {
 
 async function setupOffline() {
   try {
-    await registerOmrsServiceWorker(
-      `${window.getOpenmrsSpaBase()}service-worker.js`
-    );
+    await registerOmrsServiceWorker(`${window.getOpenmrsSpaBase()}service-worker.js`);
     await activateOfflineCapability();
     setupOfflineStaticDependencyPrecaching();
   } catch (error) {
-    console.error("Error while setting up offline mode.", error);
+    console.error('Error while setting up offline mode.', error);
     showNotification({
-      kind: "error",
-      title: "Offline Setup Error",
+      kind: 'error',
+      title: 'Offline Setup Error',
       description: error.message,
     });
   }
@@ -283,9 +256,7 @@ function setupOfflineStaticDependencyPrecaching() {
   let lastPrecache: Date | null = null;
 
   subscribeOnlineAndLoginChange((online, hasLoggedInUser) => {
-    const hasExceededPrecacheDelay =
-      !lastPrecache ||
-      new Date().getTime() - lastPrecache.getTime() > precacheDelay;
+    const hasExceededPrecacheDelay = !lastPrecache || new Date().getTime() - lastPrecache.getTime() > precacheDelay;
 
     if (hasLoggedInUser && online && hasExceededPrecacheDelay) {
       lastPrecache = new Date();
@@ -294,9 +265,7 @@ function setupOfflineStaticDependencyPrecaching() {
   });
 }
 
-function subscribeOnlineAndLoginChange(
-  cb: (online: boolean, hasLoggedInUser: boolean) => void
-) {
+function subscribeOnlineAndLoginChange(cb: (online: boolean, hasLoggedInUser: boolean) => void) {
   let isOnline = false;
   let hasLoggedInUser = false;
 
@@ -316,40 +285,37 @@ async function precacheGlobalStaticDependencies() {
 
   // By default, cache the session endpoint.
   // This ensures that a lot of user/session related functions also work offline.
-  const sessionPathUrl = new URL(
-    `${window.openmrsBase}/ws/rest/v1/session`,
-    window.location.origin
-  ).href;
+  const sessionPathUrl = new URL(`${window.openmrsBase}/ws/rest/v1/session`, window.location.origin).href;
 
   await messageOmrsServiceWorker({
-    type: "registerDynamicRoute",
+    type: 'registerDynamicRoute',
     url: sessionPathUrl,
-    strategy: "network-first",
+    strategy: 'network-first',
   });
 
-  await openmrsFetch("/ws/rest/v1/session").catch((e) =>
+  await openmrsFetch('/ws/rest/v1/session').catch((e) =>
     console.warn(
-      "Failed to precache the user session data from the app shell. MFs depending on this data may run into problems while offline.",
-      e
-    )
+      'Failed to precache the user session data from the app shell. MFs depending on this data may run into problems while offline.',
+      e,
+    ),
   );
 }
 
 async function precacheImportMap() {
   const importMap = await window.importMapOverrides.getCurrentPageMap();
   await messageOmrsServiceWorker({
-    type: "onImportMapChanged",
+    type: 'onImportMapChanged',
     importMap,
   });
 }
 
 function setupOfflineCssClasses() {
   subscribeConnectivity(({ online }) => {
-    const body = document.querySelector("body")!;
+    const body = document.querySelector('body')!;
     if (online) {
-      body.classList.remove("omrs-offline");
+      body.classList.remove('omrs-offline');
     } else {
-      body.classList.add("omrs-offline");
+      body.classList.add('omrs-offline');
     }
   });
 }

package/src/service-worker/caching.ts

@@ -1,9 +1,9 @@
 /* eslint-disable no-console */
-import type { ImportMap } from "@openmrs/esm-globals";
-import { retry } from "@openmrs/esm-utils";
-import { absoluteWbManifestUrls, omrsCacheName } from "./constants";
-import { fetchUrlsToCacheFromImportMap } from "./import-map-utils";
-import { ServiceWorkerDb } from "./storage";
+import type { ImportMap } from '@openmrs/esm-globals';
+import { retry } from '@openmrs/esm-utils';
+import { absoluteWbManifestUrls, omrsCacheName } from './constants';
+import { fetchUrlsToCacheFromImportMap } from './import-map-utils';
+import { ServiceWorkerDb } from './storage';
 
 /**
  * Attempts to resolve cacheable files from the specified import map (files are retrieved via convention)
@@ -43,17 +43,13 @@ export async function addToOmrsCache(urls: Array<string>) {
     urls.map(async (url) => {
       try {
         await retry(() => cache.add(url), {
-          onError: (e, attempt) =>
-            console.debug(
-              `[SW] Failure attempt ${attempt} at caching "${url}". Error: `,
-              e
-            ),
+          onError: (e, attempt) => console.debug(`[SW] Failure attempt ${attempt} at caching "${url}". Error: `, e),
         });
         return { url, success: true };
       } catch (e) {
         return { url, success: false };
       }
-    })
+    }),
   );
 
   const cached = results.filter((r) => r.success);
@@ -62,14 +58,14 @@ export async function addToOmrsCache(urls: Array<string>) {
   if (cached.length > 0) {
     console.debug(
       `[SW] Successfully added ${cached.length} URLs to the OMRS cache. URLs: `,
-      cached.map((r) => r.url)
+      cached.map((r) => r.url),
     );
   }
 
   if (failedToCache.length > 0) {
     console.error(
       `[SW] Failed to cache ${failedToCache.length} URLs. URLs: `,
-      failedToCache.map((r) => r.url)
+      failedToCache.map((r) => r.url),
     );
   }
 }
@@ -77,27 +73,23 @@ export async function addToOmrsCache(urls: Array<string>) {
 async function invalidateObsoleteCacheEntries(newImportMapUrls: Array<string>) {
   const cache = await caches.open(omrsCacheName);
   const cachedUrls = (await cache.keys()).map((x) => x.url);
-  const dynamicRoutes =
-    await new ServiceWorkerDb().dynamicRouteRegistrations.toArray();
+  const dynamicRoutes = await new ServiceWorkerDb().dynamicRouteRegistrations.toArray();
 
   const urlsToInvalidate = cachedUrls.filter(
     (cachedUrl) =>
       !absoluteWbManifestUrls.includes(cachedUrl) &&
       !newImportMapUrls.includes(cachedUrl) &&
-      !dynamicRoutes.some((route) => new RegExp(route.pattern).test(cachedUrl))
+      !dynamicRoutes.some((route) => new RegExp(route.pattern).test(cachedUrl)),
   );
 
-  console.info(
-    "[SW] Removing the following expired URLs from the cache: ",
-    urlsToInvalidate
-  );
+  console.info('[SW] Removing the following expired URLs from the cache: ', urlsToInvalidate);
 
   // eslint-disable-next-line no-console
   console.debug(
-    "[SW] The following URLs were known and not invalidated: ",
+    '[SW] The following URLs were known and not invalidated: ',
     absoluteWbManifestUrls,
     newImportMapUrls,
-    dynamicRoutes
+    dynamicRoutes,
   );
 
   await Promise.all(urlsToInvalidate.map((url) => cache.delete(url)));

package/src/service-worker/constants.ts

@@ -1,23 +1,18 @@
-import uniq from "lodash-es/uniq";
+import uniq from 'lodash-es/uniq';
 
 // note that these constants are also defined in @openmrs/esm-offline
-export const omrsOfflineResponseBodyHttpHeaderName =
-  "x-omrs-offline-response-body";
-export const omrsOfflineResponseStatusHttpHeaderName =
-  "x-omrs-offline-response-status";
-export const omrsOfflineCachingStrategyHttpHeaderName =
-  "x-omrs-offline-caching-strategy";
+export const omrsOfflineResponseBodyHttpHeaderName = 'x-omrs-offline-response-body';
+export const omrsOfflineResponseStatusHttpHeaderName = 'x-omrs-offline-response-status';
+export const omrsOfflineCachingStrategyHttpHeaderName = 'x-omrs-offline-caching-strategy';
 
-export const omrsCachePrefix = "omrs";
+export const omrsCachePrefix = 'omrs';
 export const omrsCacheName = `${omrsCachePrefix}-spa-cache-v1`;
 
 export const wbManifest = self.__WB_MANIFEST;
-export const indexUrl = prefixWithServiceWorkerLocationIfRelative("index.html");
-export const absoluteWbManifestUrls = uniq(
-  wbManifest.map(({ url }) => prefixWithServiceWorkerLocationIfRelative(url))
-);
+export const indexUrl = prefixWithServiceWorkerLocationIfRelative('index.html');
+export const absoluteWbManifestUrls = uniq(wbManifest.map(({ url }) => prefixWithServiceWorkerLocationIfRelative(url)));
 
-export const buildManifestSuffix = ".buildmanifest.json";
+export const buildManifestSuffix = '.buildmanifest.json';
 
 function prefixWithServiceWorkerLocationIfRelative(path: string) {
   return new URL(path, self.location.href).href;

package/src/service-worker/http-header-utils.ts

@@ -1,25 +1,15 @@
-import type {
-  OmrsOfflineHttpHeaderNames,
-  OmrsOfflineHttpHeaders,
-} from "@openmrs/esm-offline";
-import {
-  omrsOfflineResponseBodyHttpHeaderName,
-  omrsOfflineResponseStatusHttpHeaderName,
-} from "./constants";
+import type { OmrsOfflineHttpHeaderNames, OmrsOfflineHttpHeaders } from '@openmrs/esm-offline';
+import { omrsOfflineResponseBodyHttpHeaderName, omrsOfflineResponseStatusHttpHeaderName } from './constants';
 
 export function parseOmrsOfflineResponseBodyHeader(headers: Headers) {
   // The ?? undefined here is important as getOmrsHeader returns null by default when the header
   // is missing. undefined is different than null in this case since we want the body to be missing
   // if the header is not there (null is not missing).
-  return (
-    getOmrsHeader(headers, omrsOfflineResponseBodyHttpHeaderName) ?? undefined
-  );
+  return getOmrsHeader(headers, omrsOfflineResponseBodyHttpHeaderName) ?? undefined;
 }
 
 export function parseOmrsOfflineResponseStatusHeader(headers: Headers) {
-  const status = +(
-    getOmrsHeader(headers, omrsOfflineResponseStatusHttpHeaderName) ?? ""
-  );
+  const status = +(getOmrsHeader(headers, omrsOfflineResponseStatusHttpHeaderName) ?? '');
 
   // The Response API requires the status to be in the 200-599 range and throws otherwise.
   return isNaN(status) || status < 200 || status > 599 ? 503 : status;
@@ -27,7 +17,7 @@ export function parseOmrsOfflineResponseStatusHeader(headers: Headers) {
 
 export function getOmrsHeader<T extends OmrsOfflineHttpHeaderNames>(
   headers: Headers,
-  name: T
+  name: T,
 ): OmrsOfflineHttpHeaders[T] | null {
   return headers.get(name) as OmrsOfflineHttpHeaders[T];
 }

package/src/service-worker/import-map-utils.ts

@@ -1,25 +1,21 @@
-import type { ImportMap } from "@openmrs/esm-globals";
-import { buildManifestSuffix } from "./constants";
-import { BuildManifest } from "./types";
-import flatten from "lodash-es/flatten";
+import type { ImportMap } from '@openmrs/esm-globals';
+import { buildManifestSuffix } from './constants';
+import { BuildManifest } from './types';
+import flatten from 'lodash-es/flatten';
 
 /**
  * Given an import map object, resolves the URLs of all cacheable files defined in the import map.
  * Resolving relies on a build manifest file existing in the same location as the file referenced
  * in the import map.
  */
-export async function fetchUrlsToCacheFromImportMap({
-  imports = {},
-}: ImportMap) {
+export async function fetchUrlsToCacheFromImportMap({ imports = {} }: ImportMap) {
   const importMapUrlAddresses = Object.values(imports);
   const urlsToCache = await Promise.all(
     importMapUrlAddresses.map(async (importMapAddress) => {
       const buildManifestUrl = getBuildManifestUrl(importMapAddress);
       const buildManifest = await tryFetchBuildManifest(buildManifestUrl);
-      return buildManifest
-        ? getUrlsFromBuildManifests(importMapAddress, buildManifest)
-        : [];
-    })
+      return buildManifest ? getUrlsFromBuildManifests(importMapAddress, buildManifest) : [];
+    }),
   );
 
   return flatten(urlsToCache);
@@ -29,26 +25,19 @@ function getBuildManifestUrl(importMapAddress: string) {
   return importMapAddress + buildManifestSuffix;
 }
 
-function tryFetchBuildManifest(
-  buildManifestUrl: string
-): Promise<BuildManifest | null> {
+function tryFetchBuildManifest(buildManifestUrl: string): Promise<BuildManifest | null> {
   return fetch(buildManifestUrl)
     .then((res) => res.json())
     .catch(() => null);
 }
 
-function getUrlsFromBuildManifests(
-  importMapAddress: string,
-  buildManifest: BuildManifest
-) {
+function getUrlsFromBuildManifests(importMapAddress: string, buildManifest: BuildManifest) {
   // The try here guards against malformed JSON responses.
   // While we do expect the build manifest to have the correct format, we cannot *rely* on it.
   // Using a try/catch here seems better to me than doing defensive checks on every field/type in the response.
   try {
     const results: Array<string> = [];
-    const baseUrlForFiles = getUrlOfFileParentDir(
-      new URL(importMapAddress, self.location.href)
-    );
+    const baseUrlForFiles = getUrlOfFileParentDir(new URL(importMapAddress, self.location.href));
 
     for (const chunk of buildManifest.chunks ?? []) {
       for (const file of chunk.files ?? []) {
@@ -61,7 +50,7 @@ function getUrlsFromBuildManifests(
     console.error(
       "[SW] Failed to determine the dependencies of the module with the URL %s. Not precaching any of the module's assets. Error: ",
       importMapAddress,
-      e
+      e,
     );
 
     return [];
@@ -70,7 +59,7 @@ function getUrlsFromBuildManifests(
 
 function getUrlOfFileParentDir(url: URL) {
   const fullPath = url.origin + url.pathname; // Removes params + hash.
-  const parts = fullPath.split("/");
-  parts[parts.length - 1] = "";
-  return parts.join("/");
+  const parts = fullPath.split('/');
+  parts[parts.length - 1] = '';
+  return parts.join('/');
 }

package/src/service-worker/index.ts

@@ -1,8 +1,8 @@
-import { setCacheNameDetails } from "workbox-core";
-import { handleMessage } from "./message";
-import { precacheAppShell } from "./caching";
-import { registerAllOmrsRoutes } from "./routing";
-import { omrsCachePrefix } from "./constants";
+import { setCacheNameDetails } from 'workbox-core';
+import { handleMessage } from './message';
+import { precacheAppShell } from './caching';
+import { registerAllOmrsRoutes } from './routing';
+import { omrsCachePrefix } from './constants';
 
 self.__WB_DISABLE_DEV_LOGS = true;
 
@@ -11,9 +11,9 @@ setCacheNameDetails({ prefix: omrsCachePrefix });
 
 registerAllOmrsRoutes();
 
-self.addEventListener("message", handleMessage);
+self.addEventListener('message', handleMessage);
 
-self.addEventListener("install", (e) => {
+self.addEventListener('install', (e) => {
   self.skipWaiting();
 
   // The app shell files are special in the sense that they can immediately be cached during SW installation.
@@ -22,6 +22,6 @@ self.addEventListener("install", (e) => {
   e.waitUntil(precacheAppShell());
 });
 
-self.addEventListener("activate", (e) => {
+self.addEventListener('activate', (e) => {
   e.waitUntil(self.clients.claim());
 });

package/src/service-worker/message.ts

@@ -2,10 +2,10 @@ import type {
   MessageServiceWorkerResult,
   OnImportMapChangedMessage,
   RegisterDynamicRouteMessage,
-} from "@openmrs/esm-offline";
-import escapeRegExp from "lodash-es/escapeRegExp";
-import { cacheImportMapReferences } from "./caching";
-import { DynamicRouteRegistration, ServiceWorkerDb } from "./storage";
+} from '@openmrs/esm-offline';
+import escapeRegExp from 'lodash-es/escapeRegExp';
+import { cacheImportMapReferences } from './caching';
+import { DynamicRouteRegistration, ServiceWorkerDb } from './storage';
 
 const messageHandlers = {
   onImportMapChanged,
@@ -21,11 +21,7 @@ async function clearDynamicRoutes() {
   await new ServiceWorkerDb().dynamicRouteRegistrations.clear();
 }
 
-async function registerDynamicRoute({
-  pattern,
-  url,
-  strategy,
-}: RegisterDynamicRouteMessage) {
+async function registerDynamicRoute({ pattern, url, strategy }: RegisterDynamicRouteMessage) {
   let finalPattern = pattern;
   if (!finalPattern && url) {
     finalPattern = `^${escapeRegExp(url)}$`;
@@ -50,12 +46,10 @@ async function registerDynamicRoute({
  * @param event The event data containing the message dispatched to the Service Worker.
  */
 export async function handleMessage(event: ExtendableMessageEvent) {
-  const handler = messageHandlers[event.data?.type?.toString() ?? ""];
+  const handler = messageHandlers[event.data?.type?.toString() ?? ''];
 
   if (!handler) {
-    fail(
-      `Received an unknown message of type "${event.data?.type} which cannot be handled.`
-    );
+    fail(`Received an unknown message of type "${event.data?.type} which cannot be handled.`);
     return;
   }
 
@@ -66,11 +60,11 @@ export async function handleMessage(event: ExtendableMessageEvent) {
       result,
     });
   } catch (e) {
-    fail(e?.message ?? e?.toString() ?? "Unknown error.");
+    fail(e?.message ?? e?.toString() ?? 'Unknown error.');
   }
 
   function fail(error: string) {
-    console.warn("[SW] Handling a message resulted in an error.", error);
+    console.warn('[SW] Handling a message resulted in an error.', error);
     resolve({
       success: false,
       error,