@uxland/primary-shell 8.0.0-rc.0 → 8.0.0-rc.2

package/src/api/localization/localization.ts

@@ -11,44 +11,48 @@ import { getLanguage, getLocales, localizerFactory, setLocales } from "@uxland/l
  *   getCurrentLanguage: () => string,
  * }>} A promise that resolves to an object with methods for translating strings and getting translations.
  */
-export const createLocaleManager =
-  (pluginId: string) => (translations: Record<string, Record<string, string>>) => {
-    const localizer = localizerFactory(getLanguage(), translations, "", true);
-    setLocales(translations);
-    return Promise.resolve({
-      /**
-       * Translates the given path using the provided variables and the plugin's ID.
-       *
-       * @param {string} path - The path to be translated.
-       * @param {Record<string, string>} [variables] - Optional variables to be used in the translation.
-       * @return {string} The translated string, or the original path if an error occurs.
-       */
-      translate: (path: string, variables?: Record<string, string>) => {
-        try {
-          return localizer(`${pluginId}.${path}`, variables);
-        } catch (e) {
-          console.error(e);
-          return path;
-        }
-      },
-      /**
-       * Retrieves the translations for the current language and plugin.
-       *
-       * @return {Record<string, string>} The translations for the current language and plugin.
-       */
-      getTranslations: () => {
-        const translations = getLocales();
-        const language = getLanguage();
-        return translations[language][pluginId] || {};
-      },
+/** Arbre de traduccions: claus imbricades fins a arribar al text. */
+export interface LocalizationMessages {
+  [key: string]: string | LocalizationMessages;
+}
 
-      /**
-       * Retrieves the current language.
-       *
-       * @return {string} The current language.
-       */
-      getCurrentLanguage: () => {
-        return getLanguage();
-      },
-    });
-  };
+export const createLocaleManager = (pluginId: string) => (translations: Record<string, LocalizationMessages>) => {
+  const localizer = localizerFactory(getLanguage(), translations, "", true);
+  setLocales(translations);
+  return Promise.resolve({
+    /**
+     * Translates the given path using the provided variables and the plugin's ID.
+     *
+     * @param {string} path - The path to be translated.
+     * @param {Record<string, string>} [variables] - Optional variables to be used in the translation.
+     * @return {string} The translated string, or the original path if an error occurs.
+     */
+    translate: (path: string, variables?: Record<string, string>) => {
+      try {
+        return localizer(`${pluginId}.${path}`, variables);
+      } catch (e) {
+        console.error(e);
+        return path;
+      }
+    },
+    /**
+     * Retrieves the translations for the current language and plugin.
+     *
+     * @return {Record<string, string>} The translations for the current language and plugin.
+     */
+    getTranslations: () => {
+      const translations = getLocales();
+      const language = getLanguage();
+      return translations[language][pluginId] || {};
+    },
+
+    /**
+     * Retrieves the current language.
+     *
+     * @return {string} The current language.
+     */
+    getCurrentLanguage: () => {
+      return getLanguage();
+    },
+  });
+};

package/src/api/notification-service/notification-service-impl.test.ts

@@ -1,3 +1,4 @@
+// @vitest-environment happy-dom
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { PrimariaNotificationServiceImpl } from "./notification.service-impl";
 
@@ -15,7 +16,7 @@ describe("PrimariaNotificationServiceImpl", () => {
     vi.useRealTimers();
   });
 
-  const assertToast = (expectedState: string, message: string, duration: number = 5000) => {
+  const assertToast = (expectedState: string, message: string, duration = 5000) => {
     const toast = document.querySelector("dss-toast") as HTMLElement;
     expect(toast).not.toBeNull();
     expect(toast.getAttribute("isshow")).toBe("true");

package/src/api/region-manager/region-manager.test.ts

@@ -1,9 +1,10 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createRegionManagerProxy } from "./region-manager";
+// @vitest-environment happy-dom
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { BROKER_EVENTS } from "../broker/broker-events";
+import { createRegionManagerProxy } from "./region-manager";
 
 const pluginId = "test-plugin";
-const mockView = { id: "view1" };
+const mockView = { id: "view1", factory: () => Promise.resolve(document.createElement("div")) };
 
 const createMockRegion = () => ({
   activate: vi.fn(),
@@ -26,6 +27,7 @@ describe("RegionManagerProxy", () => {
       registerViewWithRegion: vi.fn(),
       unregisterViewFromRegion: vi.fn(),
       getRegion: vi.fn().mockReturnValue(regionMock),
+      getRegisteredViews: vi.fn().mockReturnValue([]),
       destroy: vi.fn(),
     };
 
@@ -123,8 +125,115 @@ describe("RegionManagerProxy", () => {
     expect(result).toBe("view1");
   });
 
+  describe("getRegisteredMainViews", () => {
+    // `id: undefined` vol dir una definicio que no en declara, no una amb l'id a undefined.
+    const registeredView = (key: string, id?: string) => ({
+      key,
+      view: id === undefined ? { factory: mockView.factory } : { ...mockView, id },
+    });
+
+    it("desglossa la clau del registry en pluginId i viewId", () => {
+      regionManager.getRegisteredViews.mockReturnValue([
+        registeredView("appointments::main", "main"),
+        registeredView("activity-history::timeline", "timeline"),
+      ]);
+
+      expect(proxy.getRegisteredMainViews()).toEqual([
+        { pluginId: "appointments", viewId: "main" },
+        { pluginId: "activity-history", viewId: "timeline" },
+      ]);
+      expect(regionManager.getRegisteredViews).toHaveBeenCalledWith(proxy.regions.shell.main);
+    });
+
+    /**
+     * El registry s'omple en registrar la vista; `getRegion(main).currentViews` només té
+     * les vistes afegides a un host ja muntat, i `getRegion` retorna `undefined` mentre la
+     * regio no hi es. Per aixo el metode no ha de dependre de la regio.
+     */
+    it("no depen que la regio main estigui muntada", () => {
+      regionManager.getRegion.mockReturnValue(undefined);
+      regionManager.getRegisteredViews.mockReturnValue([registeredView("appointments::main", "main")]);
+
+      expect(proxy.getRegisteredMainViews()).toEqual([{ pluginId: "appointments", viewId: "main" }]);
+    });
+
+    it("retorna una llista buida quan no hi ha res registrat", () => {
+      regionManager.getRegisteredViews.mockReturnValue([]);
+
+      expect(proxy.getRegisteredMainViews()).toEqual([]);
+    });
+
+    // Les vistes dels plugins de tercers (econsulta, allergies...) es poden registrar
+    // directament contra el regionManager, sense el prefix que hi posa aquest proxy.
+    it("deixa el pluginId buit si la clau no porta prefix de plugin", () => {
+      regionManager.getRegisteredViews.mockReturnValue([registeredView("legacy-view", "legacy-view")]);
+
+      expect(proxy.getRegisteredMainViews()).toEqual([{ pluginId: "", viewId: "legacy-view" }]);
+    });
+
+    it("cau a la clau quan la definicio no declara id", () => {
+      regionManager.getRegisteredViews.mockReturnValue([registeredView("appointments::main", undefined)]);
+
+      expect(proxy.getRegisteredMainViews()).toEqual([{ pluginId: "appointments", viewId: "main" }]);
+    });
+  });
+
   it("_destroy should call regionManager.destroy", () => {
     proxy._destroy();
     expect(regionManager.destroy).toHaveBeenCalled();
   });
+
+  describe("_removeAllViews", () => {
+    /**
+     * Es crida en tancar, abans del `dispose` dels plugins, perque els cleanups dels `useEffect`
+     * trobin els handlers del broker encara registrats. Ha d'esperar cada desmuntatge: el
+     * `clear()`/`destroy()` del regionManager fan `forEach` amb crides asincrones sense
+     * esperar-les, i per aixo no serveixen.
+     */
+    it("desregistra totes les vistes de totes les regions que tenen", async () => {
+      regionManager.getRegisteredViews = vi.fn((regionName: string) =>
+        regionName === "main-region"
+          ? [
+              { key: "a::v1", view: mockView },
+              { key: "b::v2", view: mockView },
+            ]
+          : [],
+      );
+
+      await proxy._removeAllViews();
+
+      expect(regionManager.unregisterViewFromRegion).toHaveBeenCalledWith("main-region", "a::v1");
+      expect(regionManager.unregisterViewFromRegion).toHaveBeenCalledWith("main-region", "b::v2");
+      expect(regionManager.unregisterViewFromRegion).toHaveBeenCalledTimes(2);
+    });
+
+    it("espera cada desmuntatge abans de continuar amb el seguent", async () => {
+      const order: string[] = [];
+      regionManager.getRegisteredViews = vi.fn((regionName: string) =>
+        regionName === "main-region"
+          ? [
+              { key: "a::v1", view: mockView },
+              { key: "b::v2", view: mockView },
+            ]
+          : [],
+      );
+      regionManager.unregisterViewFromRegion = vi.fn(async (_region: string, key: string) => {
+        order.push(`start:${key}`);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        order.push(`done:${key}`);
+      });
+
+      await proxy._removeAllViews();
+
+      expect(order).toEqual(["start:a::v1", "done:a::v1", "start:b::v2", "done:b::v2"]);
+    });
+
+    it("no fa res si cap regio te vistes", async () => {
+      regionManager.getRegisteredViews = vi.fn().mockReturnValue([]);
+
+      await proxy._removeAllViews();
+
+      expect(regionManager.unregisterViewFromRegion).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/api/region-manager/region-manager.ts

@@ -1,9 +1,15 @@
-import { HarmonixRegionManager, IRegionManager, HarmonixViewDefinition } from "@uxland/harmonix";
-import { PluginInfo } from "../../handle-plugins";
+import { HarmonixRegionManager, HarmonixViewDefinition, IRegionManager } from "@uxland/harmonix";
 import { IRegion } from "@uxland/regions";
-import { shellRegions, clinicalMonitoringRegions, activityHistoryRegions, administrativeManagementRegions } from "./regions";
-import { PrimariaBroker } from "../broker/primaria-broker";
+import { PluginInfo } from "../../handle-plugins";
 import { BROKER_EVENTS } from "../broker/broker-events";
+import { PrimariaBroker } from "../broker/primaria-broker";
+import { activityHistoryRegions, administrativeManagementRegions, clinicalMonitoringRegions, shellRegions } from "./regions";
+
+/** Una vista de la region main, amb el plugin que l'ha registrada. */
+export interface RegisteredMainView {
+  pluginId: string;
+  viewId: string;
+}
 
 export interface PrimariaRegionManager extends HarmonixRegionManager {
   regions: {
@@ -18,9 +24,19 @@ export interface PrimariaRegionManager extends HarmonixRegionManager {
   activateMainView(viewId: string): Promise<void>;
   activatePluginView(regionName: string, pluginId: string, viewId: string): Promise<void>;
   getCurrentMainViewActive(): string | undefined;
-  _destroy(): void;
+  getRegisteredMainViews(): RegisteredMainView[];
+  _removeAllViews(): Promise<void>;
+  _destroy(): Promise<void>;
 }
 
+/** Totes les regions que coneix el shell, per poder-les recórrer al tancar. */
+const ALL_REGION_NAMES: string[] = [
+  ...Object.values(shellRegions),
+  ...Object.values(clinicalMonitoringRegions),
+  ...Object.values(activityHistoryRegions),
+  ...Object.values(administrativeManagementRegions),
+];
+
 class RegionManagerProxy implements PrimariaRegionManager {
   regions = {
     shell: shellRegions,
@@ -109,14 +125,24 @@ class RegionManagerProxy implements PrimariaRegionManager {
    */
   isViewActive(regionName: string, viewId: string) {
     const region = this.regionManager.getRegion(regionName);
-    const isViewActive = region.currentActiveViews.some((view) => view.id === viewId);
+    // `ViewDefinition` de @uxland/regions no declara `id`, però el shell només hi registra
+    // `HarmonixViewDefinition`, que sí que en porta.
+    const isViewActive = region.currentActiveViews.some((view) => (view as HarmonixViewDefinition).id === viewId);
     return Promise.resolve(isViewActive);
   }
   async registerQuickAction(view: HarmonixViewDefinition): Promise<void> {
-    await this.regionManager.registerViewWithRegion(this.regions.shell.quickActions, `${this.pluginInfo.pluginId}::${view.id}`, view);
+    await this.regionManager.registerViewWithRegion(
+      this.regions.shell.quickActions,
+      `${this.pluginInfo.pluginId}::${view.id}`,
+      view,
+    );
   }
   async registerNavigationMenu(view: HarmonixViewDefinition): Promise<void> {
-    await this.regionManager.registerViewWithRegion(this.regions.shell.navigationMenu, `${this.pluginInfo.pluginId}::${view.id}`, view);
+    await this.regionManager.registerViewWithRegion(
+      this.regions.shell.navigationMenu,
+      `${this.pluginInfo.pluginId}::${view.id}`,
+      view,
+    );
   }
   async registerMainView(view: HarmonixViewDefinition): Promise<void> {
     await this.regionManager.registerViewWithRegion(this.regions.shell.main, `${this.pluginInfo.pluginId}::${view.id}`, view);
@@ -149,6 +175,32 @@ class RegionManagerProxy implements PrimariaRegionManager {
     return mainView?.id;
   }
 
+  /**
+   * Totes les vistes registrades a la region main, amb el plugin que les ha registrat.
+   *
+   * Va pel registry del regionManager i no per `getRegion(main).currentViews`, i és a
+   * propòsit: el registry s'omple en registrar la vista, mentre que `currentViews` només
+   * té les que s'han afegit a un host de regió ja muntat —i `getRegion` retorna
+   * `undefined` si la regió encara no hi és—, així que cridar-ho des de l'`initialize()`
+   * d'un plugin donaria una llista incompleta o petaria.
+   *
+   * Les claus del registry són `pluginId::viewId`. El `viewId` es llegeix de la
+   * definició, que és qui en manda; de la clau només se'n treu el prefix del plugin, que
+   * pot no ser-hi si la vista l'ha registrada un plugin de tercers directament contra el
+   * regionManager, sense passar per aquest proxy.
+   */
+  getRegisteredMainViews(): RegisteredMainView[] {
+    return this.regionManager.getRegisteredViews(this.regions.shell.main).map(({ key, view }) => {
+      const separatorIndex = key.indexOf("::");
+      const hasPluginPrefix = separatorIndex !== -1;
+
+      return {
+        pluginId: hasPluginPrefix ? key.slice(0, separatorIndex) : "",
+        viewId: (view as HarmonixViewDefinition).id ?? (hasPluginPrefix ? key.slice(separatorIndex + 2) : key),
+      };
+    });
+  }
+
   /**
    * Activates a view if it is marked as default and the region currently has no active views.
    *
@@ -173,8 +225,31 @@ class RegionManagerProxy implements PrimariaRegionManager {
     this.broker.publish(BROKER_EVENTS.shell.mainViewChanged, { viewId });
   }
 
-  _destroy() {
-    this.regionManager.destroy();
+  /**
+   * Desmunta totes les vistes de totes les regions, i espera que acabin.
+   *
+   * Es crida en tancar, ABANS de fer el `dispose` dels plugins: els cleanups dels `useEffect` que
+   * s'executen en desmuntar-se poden enviar comandes pel broker, i han de trobar el handler encara
+   * registrat. Cada plugin ja ho fa pel seu compte al `dispose`, però això només cobreix els
+   * plugins d'aquest repositori; els de tercers (econsulta, allergies…) no els controlem.
+   *
+   * Fa servir `unregisterViewFromRegion` i no `destroy()`/`clear()` del regionManager perquè
+   * aquests fan `forEach` amb crides asíncrones sense esperar-les, així que retornen abans que les
+   * vistes s'hagin desmuntat de debò.
+   *
+   * És idempotent: desregistrar una vista que ja no hi és no fa res.
+   */
+  async _removeAllViews(): Promise<void> {
+    for (const regionName of ALL_REGION_NAMES) {
+      const registered = this.regionManager.getRegisteredViews(regionName) ?? [];
+      for (const { key } of [...registered]) {
+        await this.regionManager.unregisterViewFromRegion(regionName, key);
+      }
+    }
+  }
+
+  async _destroy() {
+    await this.regionManager.destroy();
   }
 }
 

package/src/api/region-manager/remove-view-idempotency.test.ts

@@ -0,0 +1,98 @@
+// @vitest-environment happy-dom
+import { createRegionManager } from "@uxland/harmonix";
+import { type IRegionAdapter, Region } from "@uxland/regions";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+/**
+ * Aquest test NO fa servir dobles del regionManager: munta una `Region` de `@uxland/regions` i un
+ * `RegionManager` de `@uxland/harmonix` de debo.
+ *
+ * El motiu: des que el shell desmunta totes les vistes al tancar (`_removeAllViews`), l'
+ * `unregisterViews` de cada plugin s'executa DESPRES, sobre vistes que ja no hi son. Tot el
+ * disseny es sosté en que aquesta segona passada sigui inofensiva, i aixo depen del comportament
+ * intern d'aquestes dues llibreries, no del nostre codi. Amb dobles no es provaria res.
+ *
+ * Si una actualitzacio d'aquests paquets fa que la segona crida arribi a l'adaptador, el
+ * component es desmuntaria dues vegades i ara mateix nomes ho sabriem en produccio.
+ */
+const REGION = "test-region";
+const VIEW_KEY = "some-plugin::some-view";
+
+let adapter: IRegionAdapter;
+let regionManager: ReturnType<typeof createRegionManager>;
+
+const createSpyAdapter = (): IRegionAdapter => ({
+  activateView: vi.fn().mockResolvedValue(undefined),
+  deactivateView: vi.fn().mockResolvedValue(undefined),
+  removeView: vi.fn(),
+  viewAdded: vi.fn().mockResolvedValue(undefined),
+  behaviors: [],
+});
+
+const mountRegion = () => {
+  const host = document.createElement("div") as HTMLElement & { uxlRegion?: unknown };
+  const region = new Region(REGION, regionManager as never, host as never, adapter, {
+    name: REGION,
+    targetId: REGION,
+  });
+  regionManager.add(REGION, region);
+  return region;
+};
+
+const addAndActivateView = async (region: Region) => {
+  await regionManager.registerViewWithRegion(REGION, VIEW_KEY, {
+    factory: () => Promise.resolve(document.createElement("span")),
+  });
+  // Nomes les vistes actives tenen component, i `removeView` nomes crida l'adaptador si n'hi ha.
+  await region.activate(VIEW_KEY);
+};
+
+beforeEach(() => {
+  adapter = createSpyAdapter();
+  regionManager = createRegionManager("test");
+});
+
+describe("treure una vista dues vegades (shell + plugin)", () => {
+  it("la primera passada desmunta la vista de debo", async () => {
+    const region = mountRegion();
+    await addAndActivateView(region);
+
+    await regionManager.unregisterViewFromRegion(REGION, VIEW_KEY);
+
+    expect(adapter.deactivateView).toHaveBeenCalledOnce();
+    expect(adapter.removeView).toHaveBeenCalledOnce();
+  });
+
+  it("la segona no torna a tocar l'adaptador", async () => {
+    const region = mountRegion();
+    await addAndActivateView(region);
+
+    await regionManager.unregisterViewFromRegion(REGION, VIEW_KEY);
+    vi.mocked(adapter.deactivateView).mockClear();
+    vi.mocked(adapter.removeView).mockClear();
+
+    // El que fa `unregisterViews` del plugin despres que el shell ja ho hagi tret tot.
+    await regionManager.unregisterViewFromRegion(REGION, VIEW_KEY);
+
+    expect(adapter.deactivateView).not.toHaveBeenCalled();
+    expect(adapter.removeView).not.toHaveBeenCalled();
+  });
+
+  it("la segona passada no llanca ni deixa la vista registrada", async () => {
+    const region = mountRegion();
+    await addAndActivateView(region);
+
+    await regionManager.unregisterViewFromRegion(REGION, VIEW_KEY);
+
+    await expect(regionManager.unregisterViewFromRegion(REGION, VIEW_KEY)).resolves.toBeDefined();
+    expect(region.containsView(VIEW_KEY)).toBe(false);
+    expect(regionManager.getRegisteredViews(REGION)).toEqual([]);
+  });
+
+  it("treure una vista que no s'ha registrat mai tampoc fa res", async () => {
+    mountRegion();
+
+    await expect(regionManager.unregisterViewFromRegion(REGION, "mai::registrada")).resolves.toBeDefined();
+    expect(adapter.removeView).not.toHaveBeenCalled();
+  });
+});

package/src/api/token-manager/token-manager.test.ts

@@ -1,3 +1,4 @@
+// @vitest-environment happy-dom
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import axios from "axios";
 import { BROKER_EVENTS } from "../broker/broker-events";
@@ -68,17 +69,13 @@ describe("TokenManager", () => {
     it("should throw error if tokens are already initialized", () => {
       const tokenManager = new TokenManagerImpl(mockBroker);
       tokenManager.setInitialTokens("manual_access", "manual_refresh");
-      expect(() => tokenManager.setInitialTokens("another_access", "another_refresh")).toThrow(
-        "Token already initialized",
-      );
+      expect(() => tokenManager.setInitialTokens("another_access", "another_refresh")).toThrow("Token already initialized");
     });
 
     it("should throw error if tokens were already initialized from URL", () => {
       const tokenManager = new TokenManagerImpl(mockBroker);
       tokenManager.getToken();
-      expect(() => tokenManager.setInitialTokens("manual_access", "manual_refresh")).toThrow(
-        "Token already initialized",
-      );
+      expect(() => tokenManager.setInitialTokens("manual_access", "manual_refresh")).toThrow("Token already initialized");
     });
   });
 

package/src/disposer.ts

@@ -1,8 +1,8 @@
 import { activityMonitor, sessionRefreshTimer, shellApi } from "./api/api";
 import { disposeFeatures } from "./features/bootstrapper";
 import { ExitShellPayload } from "./features/exit/request";
-export const disposeShell = () => {
-  disposeFeatures(shellApi);
+export const disposeShell = async () => {
+  await disposeFeatures(shellApi);
   shellApi.interactionService.dispose();
   sessionRefreshTimer.stop();
   activityMonitor.stop();

package/src/features/bootstrapper.ts

@@ -12,10 +12,10 @@ export const useFeatures = (api: PrimariaApi) => {
   api.broker.send(new GetUserInfo());
 };
 
-export const disposeFeatures = (api: PrimariaApi) => {
+export const disposeFeatures = async (api: PrimariaApi) => {
   disposeGetUserInfo();
   disposeExitShell();
   container.unbindAll();
-  api.regionManager._destroy();
+  await api.regionManager._destroy();
   api.broker._clear();
 };

package/src/features/exit/handler.test.ts

@@ -23,6 +23,9 @@ const createMockApi = (): PrimariaApi =>
     notificationService: {
       error: vi.fn(),
     },
+    regionManager: {
+      _removeAllViews: vi.fn().mockResolvedValue(undefined),
+    },
   }) as any;
 
 describe("ExitShellHandler", () => {
@@ -120,4 +123,61 @@ describe("ExitShellHandler", () => {
     expect(raiseCloseEvent).toHaveBeenCalled();
     expect(raiseCustomCloseEvent).not.toHaveBeenCalled();
   });
+
+  describe("ordre de tancament: vistes abans que plugins", () => {
+    /**
+     * Els cleanups dels `useEffect` s'executen en desmuntar-se el component i poden enviar
+     * comandes pel broker (p. ex. `ClearTransportDetail` a petitioner). Si el `dispose` dels
+     * plugins corre primer, el handler ja no hi es i el `send` rebutja. Cada plugin d'aquest
+     * repositori ja ho ordena be, pero els de tercers no els controlem: aquest ordre els cobreix.
+     */
+    it("desmunta totes les vistes abans de disposar els plugins", async () => {
+      const order: string[] = [];
+      (mockApi.regionManager._removeAllViews as any).mockImplementation(async () => {
+        order.push("removeAllViews");
+      });
+      (disposePlugins as any).mockImplementation(async () => {
+        order.push("disposePlugins");
+      });
+
+      await handler.handle({} as ExitShell);
+
+      expect(order).toEqual(["removeAllViews", "disposePlugins"]);
+    });
+
+    it("no comenca a disposar fins que el desmuntatge ha acabat", async () => {
+      let finishUnmount: () => void = () => {};
+      (mockApi.regionManager._removeAllViews as any).mockImplementation(
+        () =>
+          new Promise<void>((resolve) => {
+            finishUnmount = resolve;
+          }),
+      );
+      (disposePlugins as any).mockResolvedValue(undefined);
+
+      const handled = handler.handle({} as ExitShell);
+      await Promise.resolve();
+      await Promise.resolve();
+      expect(disposePlugins).not.toHaveBeenCalled();
+
+      finishUnmount();
+      await handled;
+
+      expect(disposePlugins).toHaveBeenCalled();
+    });
+
+    it("el limit de temps del tancament segueix cobrint tot el proces", async () => {
+      vi.useFakeTimers();
+      (mockApi.regionManager._removeAllViews as any).mockImplementation(() => new Promise<void>(() => {}));
+
+      const handled = handler.handle({} as ExitShell);
+      await vi.advanceTimersByTimeAsync(10000);
+      await handled;
+
+      // Encara que el desmuntatge no acabi mai, el tancament continua.
+      expect(disposeShell).toHaveBeenCalled();
+      expect(raiseCloseEvent).toHaveBeenCalled();
+      vi.useRealTimers();
+    });
+  });
 });

package/src/features/exit/handler.ts

@@ -17,10 +17,10 @@ export class ExitShellHandler {
 
       // Per si un plugin tarda molt en fer dispose, màxim deixarem 5 segons, per no interrompre el tancar infinitament
       await Promise.race([
-        disposePlugins(), // S'intenta executar un dispose normal
-        this.timeout(10000), // Si passen 5s, es segueix amb l'execució
+        this.unmountViewsAndDisposePlugins(), // S'intenta executar un dispose normal
+        this.timeout(10000), // Si passen 10s, es segueix amb l'execució
       ]);
-      disposeShell();
+      await disposeShell();
       this.emitClose(evt);
     } catch (error) {
       this.api.notificationService.error(translate("errors.exit"));
@@ -28,6 +28,22 @@ export class ExitShellHandler {
     }
   }
 
+  /**
+   * Desmunta les vistes de tots els plugins abans de fer-los el `dispose`.
+   *
+   * Els cleanups dels `useEffect` s'executen en desmuntar-se el component i poden enviar comandes
+   * pel broker (p. ex. `ClearTransportDetail` a petitioner). Si el `dispose` s'executa primer, el
+   * handler ja no hi és i el `send` rebutja. Cada plugin d'aquest repositori ja desmunta les seves
+   * vistes primer, però els de tercers no els controlem: fer-ho aquí els cobreix tots.
+   *
+   * Va dins del mateix `Promise.race` que el `dispose`, així que el límit de temps del tancament
+   * no canvia.
+   */
+  private async unmountViewsAndDisposePlugins(): Promise<void> {
+    await this.api.regionManager._removeAllViews();
+    await disposePlugins();
+  }
+
   private timeout(ms: number) {
     return new Promise<void>((resolve) => setTimeout(resolve, ms));
   }