@uxland/primary-shell 7.47.4 → 7.47.5

package/dist/primary/shell/src/api/region-manager/region-manager.d.ts

@@ -1,7 +1,7 @@
-import { HarmonixRegionManager, IRegionManager, HarmonixViewDefinition } from '@uxland/harmonix';
+import { HarmonixRegionManager, HarmonixViewDefinition, IRegionManager } from '@uxland/harmonix';
 import { PluginInfo } from '../../handle-plugins';
-import { shellRegions, clinicalMonitoringRegions, activityHistoryRegions, administrativeManagementRegions } from './regions';
 import { PrimariaBroker } from '../broker/primaria-broker';
+import { activityHistoryRegions, administrativeManagementRegions, clinicalMonitoringRegions, shellRegions } from './regions';
 export interface PrimariaRegionManager extends HarmonixRegionManager {
     regions: {
         shell: typeof shellRegions;
@@ -15,6 +15,7 @@ export interface PrimariaRegionManager extends HarmonixRegionManager {
     activateMainView(viewId: string): Promise<void>;
     activatePluginView(regionName: string, pluginId: string, viewId: string): Promise<void>;
     getCurrentMainViewActive(): string | undefined;
+    _removeAllViews(): Promise<void>;
     _destroy(): void;
 }
 /**

package/dist/primary/shell/src/api/region-manager/remove-view-idempotency.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/primary/shell/src/features/exit/handler.d.ts

@@ -4,6 +4,18 @@ export declare class ExitShellHandler {
     private api;
     constructor(api: PrimariaApi);
     handle(exitEvent: ExitShell): Promise<void>;
+    /**
+     * 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 unmountViewsAndDisposePlugins;
     private timeout;
     private askForClose;
     private emitClose;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "7.47.4",
+  "version": "7.47.5",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",

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

@@ -1,7 +1,7 @@
 // @vitest-environment happy-dom
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createRegionManagerProxy } from "./region-manager";
+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", factory: () => Promise.resolve(document.createElement("div")) };
@@ -27,6 +27,7 @@ describe("RegionManagerProxy", () => {
       registerViewWithRegion: vi.fn(),
       unregisterViewFromRegion: vi.fn(),
       getRegion: vi.fn().mockReturnValue(regionMock),
+      getRegisteredViews: vi.fn().mockReturnValue([]),
       destroy: vi.fn(),
     };
 
@@ -128,4 +129,58 @@ describe("RegionManagerProxy", () => {
     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,9 @@
-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";
 
 export interface PrimariaRegionManager extends HarmonixRegionManager {
   regions: {
@@ -18,9 +18,18 @@ export interface PrimariaRegionManager extends HarmonixRegionManager {
   activateMainView(viewId: string): Promise<void>;
   activatePluginView(regionName: string, pluginId: string, viewId: string): Promise<void>;
   getCurrentMainViewActive(): string | undefined;
+  _removeAllViews(): Promise<void>;
   _destroy(): 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,
@@ -183,6 +192,29 @@ class RegionManagerProxy implements PrimariaRegionManager {
     this.broker.publish(BROKER_EVENTS.shell.mainViewChanged, { viewId });
   }
 
+  /**
+   * 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);
+      }
+    }
+  }
+
   _destroy() {
     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/features/exit/handler.test.ts

@@ -30,6 +30,9 @@ const createMockApi = (): PrimariaApi =>
     notificationService: {
       error: vi.fn(),
     },
+    regionManager: {
+      _removeAllViews: vi.fn().mockResolvedValue(undefined),
+    },
   }) as any;
 
 describe("ExitShellHandler", () => {
@@ -180,4 +183,61 @@ describe("ExitShellHandler", () => {
       expect(mockApi.interactionService.confirm).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

@@ -27,7 +27,7 @@ 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.unmountViewsAndDisposePlugins(), // S'intenta executar un dispose normal
         this.timeout(10000), // Si passen 5s, es segueix amb l'execució
       ]);
       disposeShell();
@@ -38,6 +38,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));
   }