underpost 3.2.5 → 3.2.9

package/src/client/components/core/Worker.js

@@ -12,9 +12,15 @@ import { EventsUI } from './EventsUI.js';
 import { LoadingAnimation } from './LoadingAnimation.js';
 import { loggerFactory } from './Logger.js';
 import { LoadRouter } from './Router.js';
+import { registerRoutes } from './Router.js';
 import { Translate } from './Translate.js';
 import { s } from './VanillaJs.js';
 import { getProxyPath } from './Router.js';
+import { Css } from './Css.js';
+import { TranslateCore } from './Translate.js';
+import { Responsive } from './Responsive.js';
+import { SocketIo } from './SocketIo.js';
+import { Keyboard } from './Keyboard.js';
 const logger = loggerFactory(import.meta);
 
 /**
@@ -71,17 +77,39 @@ class PwaWorker {
     return window.renderPayload.dev || location.origin.match('localhost') || location.origin.match('127.0.0.1');
   }
 
+  async runComponentInit(component, options) {
+    if (!component) return;
+    if (Array.isArray(component)) {
+      for (const item of component) await this.runComponentInit(item, options);
+      return;
+    }
+    if (typeof component.instance === 'function') {
+      await component.instance(options);
+      return;
+    }
+    if (typeof component === 'function') {
+      await component(options);
+    }
+  }
+
   /**
-   * Initializes the PWA worker, registers global/worker event listeners,
-   * checks service worker status, and renders the initial content.
-   * This is the main entry point for the worker setup.
-   * @memberof PwaWorker
-   * @param {object} options - Configuration options.
-   * @param {function(): object} options.router - Function to get the router instance.
-   * @param {function(): Promise<void>} options.render - Function to render the application's UI.
+   * Bootstraps the app with a declarative options object.
+   * Shared core inits (Css, TranslateCore, Responsive, SocketIo, Keyboard) run
+   * internally in the correct order so index entrypoints only list app-specific components.
+   *
+   * @param {object} options
+   * @param {function(): object}          options.router       - Function returning the router instance.
+   * @param {function(): Promise<string>} [options.template]   - Async function returning the landing HTML body.
+   * @param {Array}                       [options.themes]     - CSS theme array passed to Css.loadThemes().
+   * @param {object|Array}                [options.translate]  - App translate class(es) with static instance().
+   * @param {object}                      [options.render]     - AppShell class with static instance().
+   * @param {string}                      [options.socketPath] - Socket.IO path override.
+   * @param {object}                      [options.appStore]   - AppStore whose .Data is used for socket channels.
+   * @param {object}                      [options.session]    - Session components: { socket, login, signout, signup }.
+   * @param {function(): Promise<void>}   [options.render]     - Legacy raw render callback (backward-compat).
    * @returns {Promise<void>}
    */
-  async instance({ router, render }) {
+  async instance({ router, template, themes, translate, render, socketPath, appStore, session }) {
     window.ononline = async () => {
       logger.warn('ononline');
     };
@@ -131,10 +159,36 @@ class PwaWorker {
       });
     }
 
-    this.RouterInstance = router();
-    const isInstall = await this.status();
-    if (!isInstall) await this.install();
-    await render();
+    this.RouterInstance = typeof router?.instance === 'function' ? router.instance() : router();
+    if (this.RouterInstance?.Routes) registerRoutes(this.RouterInstance.Routes);
+    // Defer SW registration entirely out of the render critical path.
+    // Firefox IPC for SW registration is notably slower than Chromium;
+    // scheduling after 'load' means the first meaningful paint is not blocked.
+    this.registerServiceWorkerDeferred();
+
+    // ── declarative bootstrap path ──────────────────────────────────────────
+    // shared core inits
+    if (themes) await Css.loadThemes(themes);
+    await this.runComponentInit(TranslateCore);
+    await this.runComponentInit(translate);
+    await this.runComponentInit(Responsive);
+    // app shell render
+    if (render && typeof render.instance === 'function') {
+      const htmlMainBody = typeof template === 'function' ? template : undefined;
+      await this.runComponentInit(render, htmlMainBody ? { htmlMainBody } : undefined);
+    }
+    // socket init
+    const channels = appStore ? appStore.Data : (session && session.socket && session.socket.Data) || undefined;
+    await this.runComponentInit(SocketIo, { channels, path: socketPath });
+    if (session) {
+      await this.runComponentInit(session.socket);
+      await this.runComponentInit(session.login);
+      await this.runComponentInit(session.logout || session.signout);
+      await this.runComponentInit(session.signup);
+      await this.runComponentInit(session.account);
+    }
+    await this.runComponentInit(Keyboard);
+    // ────────────────────────────────────────────────────────────────────────
     await LoadRouter(this.RouterInstance);
     LoadingAnimation.removeSplashScreen();
     if (this.devMode()) {
@@ -178,6 +232,68 @@ class PwaWorker {
     });
   }
 
+  async clearAllCaches() {
+    const cacheNames = await caches.keys();
+    await Promise.all(cacheNames.map((cacheName) => caches.delete(cacheName)));
+    return cacheNames.length;
+  }
+
+  async clearWorkboxIndexedDb() {
+    if (!('indexedDB' in window) || typeof indexedDB.databases !== 'function') return 0;
+    const databases = await indexedDB.databases();
+    const workboxDatabases = databases
+      .map((database) => database.name)
+      .filter(
+        (name) =>
+          typeof name === 'string' &&
+          (name.toLowerCase().includes('workbox') ||
+            name.toLowerCase().includes('background-sync') ||
+            name.includes('api-mutation-queue')),
+      );
+
+    await Promise.all(
+      workboxDatabases.map(
+        (name) =>
+          new Promise((resolve) => {
+            const request = indexedDB.deleteDatabase(name);
+            request.onsuccess = () => resolve(true);
+            request.onerror = () => resolve(false);
+            request.onblocked = () => resolve(false);
+          }),
+      ),
+    );
+
+    return workboxDatabases.length;
+  }
+
+  async requestWorkboxReset() {
+    if (!(navigator.serviceWorker && navigator.serviceWorker.controller)) return false;
+
+    return new Promise((resolve) => {
+      const channel = new MessageChannel();
+      const timeoutId = setTimeout(() => resolve(false), 1500);
+
+      channel.port1.onmessage = (event) => {
+        clearTimeout(timeoutId);
+        resolve(event.data?.status === 'workbox-reset-done');
+      };
+
+      navigator.serviceWorker.controller.postMessage({ status: 'workbox-reset' }, [channel.port2]);
+    });
+  }
+
+  async resetWorkboxAndRestart() {
+    localStorage.clear();
+    sessionStorage.clear();
+
+    await this.requestWorkboxReset();
+    await this.uninstall();
+    await this.clearAllCaches();
+    await this.clearWorkboxIndexedDb();
+    await this.install();
+    await this.reload(600);
+  }
+
   /**
    * Updates the application by clearing specific caches and running the service worker update logic.
    * Cache names matching 'components/', 'services/', or '.index.js' are deleted.
@@ -197,6 +313,30 @@ class PwaWorker {
     }
   }
 
+  /**
+   * Schedules SW registration to run after the page 'load' event (or immediately
+   * if the page is already loaded). This keeps SW work off the render critical path,
+   * which is the primary cause of Firefox being slower than Chromium on first load.
+   * @memberof PwaWorker
+   * @returns {void}
+   */
+  registerServiceWorkerDeferred() {
+    if (!('serviceWorker' in navigator)) {
+      logger.warn('Service Worker Disabled in browser');
+      return;
+    }
+    const register = () => {
+      this.status().then((isInstall) => {
+        if (!isInstall) this.install();
+      });
+    };
+    if (document.readyState === 'complete') {
+      register();
+    } else {
+      window.addEventListener('load', register, { once: true });
+    }
+  }
+
   /**
    * Checks the current status of all service worker registrations and sets the
    * `updateServiceWorker` function reference if an active worker is found.
@@ -242,9 +382,7 @@ class PwaWorker {
     return new Promise((resolve) => {
       if ('serviceWorker' in navigator) {
         navigator.serviceWorker
-          .register(`${getProxyPath()}sw.js`, {
-            type: 'module',
-          })
+          .register(`${getProxyPath()}sw.js`)
           .then((...args) => {
             logger.warn('Service Worker Registered', args);
             resolve(args);
@@ -340,28 +478,26 @@ class PwaWorker {
       // Event listener for the clean cache button
       EventsUI.onClick(`.btn-clean-cache`, async (e) => {
         e.preventDefault();
-        // Clear local storage, uninstall the worker, and reload
-        localStorage.clear();
-        await this.uninstall();
-        await this.reload();
+        // Full reset: workbox runtime state + SW registrations + client storage.
+        await this.resetWorkboxAndRestart();
       });
     });
     return html` <div class="in">
-      ${await BtnIcon.Render({
+      ${await BtnIcon.instance({
         class: 'inl section-mp btn-custom btn-install-service-controller hide',
-        label: html`<i class="fas fa-download"></i> ${Translate.Render('Install control service')}`,
+        label: html`<i class="fas fa-download"></i> ${Translate.instance('Install control service')}`,
       })}
-      ${await BtnIcon.Render({
+      ${await BtnIcon.instance({
         class: 'inl section-mp btn-custom btn-uninstall-service-controller hide',
-        label: html`<i class="far fa-trash-alt"></i> ${Translate.Render('Uninstall control service')}`,
+        label: html`<i class="far fa-trash-alt"></i> ${Translate.instance('Uninstall control service')}`,
       })}
-      ${await BtnIcon.Render({
+      ${await BtnIcon.instance({
         class: 'inl section-mp btn-custom btn-clean-cache',
-        label: html`<i class="fa-solid fa-broom"></i> ${Translate.Render('clean-cache')}`,
+        label: html`<i class="fa-solid fa-broom"></i> ${Translate.instance('clean-cache')}`,
       })}
-      ${await BtnIcon.Render({
+      ${await BtnIcon.instance({
         class: 'inl section-mp btn-custom btn-reload hide',
-        label: html`<i class="fas fa-sync-alt"></i> ${Translate.Render('Reload')}`,
+        label: html`<i class="fas fa-sync-alt"></i> ${Translate.instance('Reload')}`,
       })}
     </div>`;
   }

package/src/client/components/core/windowGetDimensions.js

@@ -149,23 +149,23 @@ export class PwaWindowDimensions {
    * Get the best-available viewport height in pixels.
    *
    * Priority (from most reliable for "visible" to least):
-   * 1. window.visualViewport.height (if `preferVisualViewport` is true)
-   * 2. document.documentElement.clientHeight (Layout viewport)
-   * 3. window.innerHeight (Window size)
-   * 4. document.body.clientHeight (Body size)
-   * 5. window.visualViewport.height (if `preferVisualViewport` is false)
+   * 1. document.documentElement.clientHeight (Layout viewport, default — stable against iframe scrolls)
+   * 2. window.innerHeight (Window size)
+   * 3. document.body.clientHeight (Body size)
+   * 4. window.visualViewport.height (if `preferVisualViewport` is true; first priority; or last before screen fallbacks)
+   * 5. window.visualViewport.height (if `preferVisualViewport` is false — used as fallback after layout values)
    * 6. window.screen.availHeight / window.screen.height (Physical screen)
    * 7. window.outerHeight (Last resort)
    *
    * @memberof PwaWindowDimensions
    * @static
    * @param {Object} [options]
-   * @param {boolean} [options.preferVisualViewport=true] - When true, visualViewport is checked first (best for visible screen size, e.g., above mobile keyboard).
+   * @param {boolean} [options.preferVisualViewport=false] - When true, visualViewport is checked first (best for visible screen size, e.g., above mobile keyboard). Defaults to false to use stable layout viewport height, preventing Chrome iframe scroll from causing transient visualViewport changes that affect modal sizing.
    * @returns {number|null} Height in px (rounded integer) or null if none found.
    * @memberof PwaWindowDimensions
    */
   static getH(options = {}) {
-    const { preferVisualViewport = true } = options;
+    const { preferVisualViewport = false } = options;
 
     const vv = PwaWindowDimensions.#getFromVisualViewport();
     const de = PwaWindowDimensions.#getFromDocumentElement();