@enbox/browser 0.3.79 → 0.3.80

package/src/prepare-browser.ts

@@ -0,0 +1,91 @@
+import type { ActivatePolyfillsOptions } from './web-features.js';
+
+import { activatePolyfills } from './web-features.js';
+
+/** Page startup options; worker registration and update policy remain application-owned. */
+export type PrepareBrowserOptions = {
+  /** Forwarded to register() only when the worker is a script URL. */
+  registrationOptions?: RegistrationOptions;
+  /** Abort this wait without unregistering or cancelling a native registration. */
+  signal?: AbortSignal;
+  /** Bounds registration and control together. Defaults to 20 seconds. */
+  timeoutMs?: number;
+  /** Page polyfills, activated after control with serviceWorker forced to false. */
+  polyfills?: Omit<ActivatePolyfillsOptions, 'path' | 'serviceWorker' | 'onCacheCheck'>;
+};
+
+/**
+ * Await an application worker controlling this page, then activate page polyfills.
+ * Existing registrations use their currently active worker, even when an update
+ * waits. Script URLs additionally require the controller's script URL to match.
+ * Obtain registrations from this page's navigator.serviceWorker; worker object
+ * identity is specific to each window, so another window's registration cannot
+ * be compared to this page's controller.
+ * This helper never forces worker takeover, reloads, or unregisters a worker.
+ */
+export async function prepareBrowser(
+  worker: string | URL | ServiceWorkerRegistration,
+  options: PrepareBrowserOptions = {},
+): Promise<ServiceWorkerRegistration> {
+  const { signal, timeoutMs = 20_000 } = options;
+  signal?.throwIfAborted();
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 2_147_483_647) {
+    throw new RangeError('prepareBrowser: timeoutMs must be between 0 and 2147483647 milliseconds.');
+  }
+  if (typeof window === 'undefined' || !('serviceWorker' in navigator)) {
+    throw new Error('prepareBrowser: service workers are unavailable in this page.');
+  }
+  const container = navigator.serviceWorker;
+  const script = typeof worker === 'string' || 'href' in worker ? new URL(worker, document.baseURI) : undefined;
+  if (script !== undefined) {
+    script.hash = '';
+  }
+
+  const registration = await new Promise<ServiceWorkerRegistration>((resolve, reject): void => {
+    let target: ServiceWorkerRegistration | undefined;
+    let settled = false;
+    const cleanup = (): void => {
+      settled = true;
+      clearTimeout(timer);
+      container.removeEventListener('controllerchange', check);
+      signal?.removeEventListener('abort', abort);
+    };
+    const fail = (cause: unknown): void => {
+      if (settled) { return; }
+      cleanup();
+      reject(cause);
+    };
+    const check = (): void => {
+      const controller = container.controller;
+      if (settled || target === undefined || controller === null || controller !== target.active) { return; }
+      if (script !== undefined && controller.scriptURL !== script.href) { return; }
+      cleanup();
+      resolve(target);
+    };
+    const abort = (): void => fail(signal?.reason);
+    const timer = setTimeout((): void => {
+      fail(new DOMException('The application service worker did not take control before the timeout.', 'TimeoutError'));
+    }, timeoutMs);
+
+    container.addEventListener('controllerchange', check);
+    signal?.addEventListener('abort', abort, { once: true });
+    try {
+      signal?.throwIfAborted();
+      if (script === undefined) {
+        target = worker as ServiceWorkerRegistration;
+        check();
+      } else {
+        void container.register(script.href, options.registrationOptions).then((registered): void => {
+          if (settled) { return; }
+          target = registered;
+          check();
+        }, fail);
+      }
+    } catch (cause: unknown) {
+      fail(cause);
+    }
+  });
+  signal?.throwIfAborted();
+  activatePolyfills({ ...options.polyfills, serviceWorker: false });
+  return registration;
+}

package/src/ui/connect-modal.ts

@@ -856,7 +856,7 @@ export function runConnectModal(options: ConnectModalOptions): Promise<ConnectRe
       setStage(
         el('p', 'stage-caption', 'This wallet can’t connect by phone here.'),
         el('p', 'stage-subline', 'You can continue in this browser instead.'),
-        stageButton('Use this browser', () => { startPopup(); }),
+        stageButton('Use this browser', () => { void startPopup(); }),
       );
     };
 
@@ -882,7 +882,7 @@ export function runConnectModal(options: ConnectModalOptions): Promise<ConnectRe
           ? `Reconnect with ${walletName}`
           : 'Connect with a wallet in this browser'),
         el('p', 'stage-subline', description),
-        stageButton(buttonLabel, () => { startPopup(); }),
+        stageButton(buttonLabel, () => { void startPopup(); }),
       );
     };
 
@@ -899,7 +899,7 @@ export function runConnectModal(options: ConnectModalOptions): Promise<ConnectRe
         el('p', 'stage-caption', blocked
           ? `Your browser blocked the wallet ${popupSurface}.`
           : `The wallet ${popupSurface} was closed.`),
-        stageButton(blocked ? 'Open it now' : `Reopen ${popupSurface}`, () => { startPopup(); }),
+        stageButton(blocked ? 'Open it now' : `Reopen ${popupSurface}`, () => { void startPopup(); }),
         ...(savedRoute !== undefined
           ? [stageLinkButton(savedRouteEscapeLabel, escapeSavedRoute)]
           : [stageLinkButton(isMobile ? 'Use a code instead' : 'Use your phone instead', () => { void switchMethod('phone'); })]),
@@ -1124,7 +1124,7 @@ export function runConnectModal(options: ConnectModalOptions): Promise<ConnectRe
         // popup channel actually buys the visitor is skipping the code.
         alt.textContent = isMobile ? 'Or connect without a code →' : 'No phone? Use this browser →';
         // startPopup runs synchronously in this click handler.
-        alt.addEventListener('click', () => { startPopup(); });
+        alt.addEventListener('click', () => { void startPopup(); });
         row.appendChild(alt);
       } else if (method === 'browser' && savedRoute === undefined) {
         const alt = document.createElement('button');

package/src/web-features.ts

@@ -4,9 +4,9 @@
   so take care to gate additions to only activate code in the right env, such as a Service Worker scope or page window.
 */
 
-import type { DidMethodResolver } from '@enbox/dids';
+import type { DidDhtNetworkConfig, DidMethodResolver } from '@enbox/dids';
 
-import { DidDht, DidResolverCacheMemory, DidWeb, resolveDwnEndpointStatus, UniversalResolver } from '@enbox/dids';
+import { createDidDhtMethod, DidDht, DidResolverCacheMemory, DidWeb, resolveDwnEndpointStatus, UniversalResolver } from '@enbox/dids';
 
 /**
  * Result returned by the `onCacheCheck` callback.
@@ -51,6 +51,13 @@ export type ActivatePolyfillsOptions = {
    * Pass a custom array to add or replace DID methods (e.g., `[DidDht, DidWeb, DidJwk]`).
    */
   didResolvers?: DidMethodResolver[];
+  /**
+   * Configure the realm-wide default `did:dht` resolver for this page or worker.
+   * Cannot be combined with `didResolvers`. Call `activatePolyfills()` in each service worker
+   * with the same actor-scoped bootstrap configuration used by its page. A later call in the same
+   * realm replaces the resolver and cache for that realm.
+   */
+  didDhtNetwork?: DidDhtNetworkConfig;
 };
 
 /**
@@ -67,6 +74,21 @@ let didResolver = new UniversalResolver({
   cache        : new DidResolverCacheMemory(),
 });
 
+function configureDidResolver({ didDhtNetwork, didResolvers }: ActivatePolyfillsOptions): void {
+  if (didResolvers !== undefined && didDhtNetwork !== undefined) {
+    throw new Error('activatePolyfills: didDhtNetwork cannot be combined with didResolvers. Configure the resolver list directly.');
+  }
+  if (didResolvers === undefined && didDhtNetwork === undefined) {
+    return;
+  }
+
+  const didDht = didDhtNetwork === undefined ? DidDht : createDidDhtMethod(didDhtNetwork);
+  didResolver = new UniversalResolver({
+    didResolvers : didResolvers ?? [didDht, DidWeb],
+    cache        : new DidResolverCacheMemory(),
+  });
+}
+
 import { parseDrlUrl } from './drl-url-parser.js';
 export { parseDrlUrl } from './drl-url-parser.js';
 
@@ -581,12 +603,7 @@ async function resetContextMenuTarget(e?: Event): Promise<void> {
  * activatePolyfills({ didResolvers: [DidDht, DidWeb, DidJwk] });
  */
 export function activatePolyfills(options: ActivatePolyfillsOptions = {}): void {
-  if (options.didResolvers) {
-    didResolver = new UniversalResolver({
-      didResolvers : options.didResolvers,
-      cache        : new DidResolverCacheMemory(),
-    });
-  }
+  configureDidResolver(options);
   if (options.serviceWorker !== false) {
     installWorker(options);
   }