@openmrs/esm-app-shell 10.0.1-pre.5539 → 10.0.1-pre.5545

package/src/service-worker/message.ts

@@ -1,93 +0,0 @@
-import type {
-  MessageServiceWorkerResult,
-  OnImportMapChangedMessage,
-  RegisterDynamicRouteMessage,
-} from '@openmrs/esm-offline';
-import escapeRegExp from 'lodash-es/escapeRegExp';
-import { cacheImportMapReferences } from './caching';
-import type { DynamicRouteRegistration } from './storage';
-import { ServiceWorkerDb } from './storage';
-
-const messageHandlers = {
-  onImportMapChanged,
-  clearDynamicRoutes,
-  registerDynamicRoute,
-};
-
-async function onImportMapChanged({ importMap }: OnImportMapChangedMessage) {
-  await cacheImportMapReferences(importMap);
-}
-
-async function clearDynamicRoutes() {
-  await new ServiceWorkerDb().dynamicRouteRegistrations.clear();
-}
-
-async function registerDynamicRoute({ pattern, url, strategy }: RegisterDynamicRouteMessage) {
-  let finalPattern = pattern;
-  if (!finalPattern && url) {
-    finalPattern = `^${escapeRegExp(url)}$`;
-  }
-
-  if (finalPattern) {
-    const registration: DynamicRouteRegistration = {
-      pattern: finalPattern,
-      strategy,
-    };
-
-    await new ServiceWorkerDb().dynamicRouteRegistrations.put(registration);
-  }
-}
-
-/**
- * Invoked when the service worker receives a message.
- * Matches the message to a handler, invokes that handler and dispatches the result returned
- * by the handler back to the window.
- *
- * For this to work, the message needs to have a defined format.
- * @param event The event data containing the message dispatched to the Service Worker.
- */
-export async function handleMessage(event: ExtendableMessageEvent) {
-  // Defense-in-depth: only process messages from same-origin Client sources.
-  // Reject messages with no source or from cross-origin sources.
-  if (!event.source || !('url' in event.source)) {
-    return;
-  }
-  let sourceOrigin: string;
-  try {
-    sourceOrigin = new URL(event.source.url).origin;
-  } catch {
-    return;
-  }
-  if (sourceOrigin !== self.location.origin) {
-    return;
-  }
-
-  const handler = messageHandlers[event.data?.type?.toString() ?? ''];
-
-  if (!handler) {
-    fail(`Received an unknown message of type "${event.data?.type} which cannot be handled.`);
-    return;
-  }
-
-  try {
-    const result = await handler(event.data);
-    resolve({
-      success: true,
-      result,
-    });
-  } catch (e) {
-    fail(e?.message ?? e?.toString() ?? 'Unknown error.');
-  }
-
-  function fail(error: string) {
-    console.warn('[SW] Handling a message resulted in an error.', error);
-    resolve({
-      success: false,
-      error,
-    });
-  }
-
-  function resolve<T>(result: MessageServiceWorkerResult<T>) {
-    event.ports[0].postMessage(result ?? {});
-  }
-}

package/src/service-worker/noop.ts

@@ -1,27 +0,0 @@
-self.__WB_DISABLE_DEV_LOGS = true;
-const wbManifest = self.__WB_MANIFEST;
-
-self.addEventListener('message', () => {});
-
-self.addEventListener('install', () => {
-  // Skip over the "waiting" lifecycle state, to ensure that our
-  // new service worker is activated immediately, even if there's
-  // another tab open controlled by our older service worker code.
-  self.skipWaiting();
-});
-
-self.addEventListener('activate', () => {
-  // Optional: Get a list of all the current open windows/tabs under
-  // our service worker's control, and force them to reload.
-  // This can "unbreak" any open windows/tabs as soon as the new
-  // service worker activates, rather than users having to manually reload.
-  self.clients
-    .matchAll({
-      type: 'window',
-    })
-    .then((windowClients) => {
-      windowClients.forEach((windowClient) => {
-        windowClient.navigate(windowClient.url);
-      });
-    });
-});

package/src/service-worker/routing.ts

@@ -1,113 +0,0 @@
-import type { RouteHandlerCallbackOptions } from 'workbox-core';
-import { registerRoute } from 'workbox-routing';
-import { getOrCreateDefaultRouter } from 'workbox-routing/utils/getOrCreateDefaultRouter';
-import { validMethods } from 'workbox-routing/utils/constants';
-import { CacheOnly, NetworkFirst, NetworkOnly } from 'workbox-strategies';
-import { indexUrl, omrsCacheName, omrsOfflineCachingStrategyHttpHeaderName } from './constants';
-import { ServiceWorkerDb } from './storage';
-import {
-  getOmrsHeader,
-  parseOmrsOfflineResponseBodyHeader,
-  parseOmrsOfflineResponseStatusHeader,
-} from './http-header-utils';
-import type { OmrsOfflineCachingStrategy } from '@openmrs/esm-offline';
-import uniq from 'lodash-es/uniq';
-
-const networkOnly = new NetworkOnly();
-const cacheOnly = new CacheOnly({ cacheName: omrsCacheName });
-const networkFirst = new NetworkFirst({ cacheName: omrsCacheName });
-
-const defaultStrategy: OmrsOfflineCachingStrategy = 'network-only-or-cache-only';
-const knownStrategyHandlers: Record<
-  OmrsOfflineCachingStrategy,
-  (options: RouteHandlerCallbackOptions) => Promise<Response>
-> = {
-  ['network-first']: (options) => networkFirst.handle(options),
-  ['network-only-or-cache-only']: async (options: RouteHandlerCallbackOptions) => {
-    try {
-      return await networkOnly.handle(options);
-    } catch (e) {
-      return await cacheOnly.handle(options);
-    }
-  },
-};
-
-/**
- * Registers required Workbox routes used by the service worker to provide offline functionality.
- */
-export function registerAllOmrsRoutes() {
-  // Navigation requests are, when unresolvable via network (i.e. when offline), routed back
-  // to the SPA's index (which should always be precached).
-  // This ensures that the page loads correctly when a new navigation occurs to pages
-  // like `/openmrs/spa/anything/nested`.
-  registerRoute(({ request }) => request.mode === 'navigate', navigationHandler);
-
-  // Fallback routing behavior.
-  // Checks if a dynamic route registration exists and, if so, handles it using a Network First approach.
-  // Otherwise falls back to a NetworkOnly - CacheOnly behavior.
-  //
-  // The latter ensures that:
-  // a) precached files (like the app shell and files resolved from the importmap) are returned when offline.
-  // b) anything else (e.g. API requests) is not cached.
-  const router = getOrCreateDefaultRouter();
-  for (const method of validMethods) {
-    router.setDefaultHandler(defaultHandler, method);
-  }
-}
-
-async function navigationHandler(options: RouteHandlerCallbackOptions) {
-  try {
-    return await networkOnly.handle(options);
-  } catch (e) {
-    const cache = await caches.open(omrsCacheName);
-    const response = await cache.match(indexUrl);
-    return response ?? Response.error();
-  }
-}
-
-async function defaultHandler(options: RouteHandlerCallbackOptions) {
-  const { request } = options;
-  const handlerKey = options.request.method === 'GET' ? await getHandlerKey(options) : defaultStrategy;
-  const handler = knownStrategyHandlers[handlerKey] ?? knownStrategyHandlers[defaultStrategy];
-
-  try {
-    return await handler(options);
-  } catch (e) {
-    console.warn('[SW] Could not handle the request to %s (using handler %s).', request.url, handlerKey, e);
-
-    return new Response(parseOmrsOfflineResponseBodyHeader(request.headers), {
-      status: parseOmrsOfflineResponseStatusHeader(request.headers),
-    });
-  }
-}
-
-async function getHandlerKey({ request }: RouteHandlerCallbackOptions) {
-  return getHandlerKeyFromHeaders(request.headers) ?? (await getHandlerKeyFromDynamicRouteRegistrations(request.url));
-}
-
-function getHandlerKeyFromHeaders(headers: Headers) {
-  return getOmrsHeader(headers, omrsOfflineCachingStrategyHttpHeaderName);
-}
-
-async function getHandlerKeyFromDynamicRouteRegistrations(url: string) {
-  const db = new ServiceWorkerDb();
-  const allDynamicRouteRegistrations = await db.dynamicRouteRegistrations.toArray();
-  const strategies = uniq(
-    allDynamicRouteRegistrations
-      .filter((route) => new RegExp(route.pattern).test(url))
-      .map((route) => route.strategy ?? 'network-first'),
-  );
-
-  if (strategies.length <= 1) {
-    return strategies[0];
-  } else {
-    // Multiple routes can match the URL (multiple RegExps can match).
-    // In that case, prioritize the available strategies. When in doubt, cache the resource again.
-    const priorities: Array<OmrsOfflineCachingStrategy> = ['network-first', 'network-only-or-cache-only'];
-
-    return (
-      priorities.find((prioritizedStrategy) => strategies.some((strategy) => strategy === prioritizedStrategy)) ??
-      defaultStrategy
-    );
-  }
-}

package/src/service-worker/storage.ts

@@ -1,37 +0,0 @@
-import type { OmrsOfflineCachingStrategy } from '@openmrs/esm-offline';
-import type { Table } from 'dexie';
-import Dexie from 'dexie';
-
-/**
- * Contains information about dynamic route registrations.
- * Dynamic route registrations are routes which should be kept in the cache,
- * but are not by default known by the Service Worker.
- * They are typically registerd by the the window/app at runtime as soon as they are known.
- */
-export interface DynamicRouteRegistration {
-  /**
-   * A regular expression which matches against a URL.
-   * If it matches, the URL should be cached using the `strategy`.
-   */
-  pattern: string;
-  /**
-   * The caching strategy to be used for caching matching URLs.
-   * Due to historical reasons, this value might be missing.
-   * In such cases, `network-first` should be assumed (the historical default).
-   */
-  strategy?: OmrsOfflineCachingStrategy;
-}
-
-/**
- * Provides access to persistent data used by the Service Worker.
- */
-export class ServiceWorkerDb extends Dexie {
-  dynamicRouteRegistrations: Table<DynamicRouteRegistration, number>;
-
-  constructor() {
-    super('ServiceWorker');
-    this.version(1).stores({ dynamicRouteRegistrations: '++,&pattern' });
-
-    this.dynamicRouteRegistrations = this.table('dynamicRouteRegistrations');
-  }
-}

package/src/service-worker/types.ts

@@ -1,21 +0,0 @@
-import type { PrecacheEntry } from 'workbox-precaching/_types';
-
-// Globals injected by Workbox at build time.
-declare global {
-  interface Window {
-    __WB_MANIFEST: Array<PrecacheEntry>;
-    __WB_DISABLE_DEV_LOGS: boolean;
-    clients: Clients;
-    skipWaiting(): void;
-  }
-}
-
-/**
- * The expected structure of a build manifest of MFs which can, by resolved via the app's import map.
- * The manifest contains URLs to files which should be cached in order to provide offline support.
- */
-export interface BuildManifest {
-  chunks?: Array<{
-    files?: Array<string>;
-  }>;
-}