@uxland/primary-shell 7.37.1 → 7.38.0

package/dist/primary/shell/src/api/api.d.ts

@@ -1,6 +1,7 @@
 import { ApiFactory, HarmonixApi } from '@uxland/harmonix';
 import { PrimariaBroker } from './broker/primaria-broker';
 import { EcapEventManager } from './ecap-event-manager/ecap-event-manager';
+import { ExitGuardManager } from './exit-guard-manager/exit-guard-manager';
 import { PrimariaGlobalStateManager } from './global-state/global-state';
 import { HttpClient } from './http-client/http-client';
 import { PrimariaInteractionService } from './interaction-service';
@@ -25,6 +26,7 @@ export interface PrimariaApi extends HarmonixApi {
     userManager: UserManager;
     ecapEventManager: EcapEventManager;
     pluginBusyManager: PluginBusyManager;
+    exitGuardManager: ExitGuardManager;
     quickActionBusyManager: QuickActionBusyManager;
     pdfViewerManager: PdfViewerManager;
     importDataManager: PrimariaImportDataManager;

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

@@ -0,0 +1,12 @@
+export type ExitGuardCanDispose = () => Promise<boolean>;
+export declare abstract class ExitGuardManager {
+    abstract register(id: string, canDispose: ExitGuardCanDispose): void;
+    abstract unregister(id: string): void;
+    abstract canExit(): Promise<boolean>;
+}
+export declare class ExitGuardManagerImpl implements ExitGuardManager {
+    private guards;
+    register(id: string, canDispose: ExitGuardCanDispose): void;
+    unregister(id: string): void;
+    canExit(): Promise<boolean>;
+}

package/dist/primary/shell/src/api/exit-guard-manager/exit-guard-manager.test.d.ts

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

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

@@ -2,6 +2,11 @@ export interface PluginTask {
     taskId: string;
     taskDescription: string;
 }
+/**
+ * @deprecated Use the `canDispose(api)` plugin lifecycle hook instead. Plugins should
+ * decide whether they can be disposed (e.g. show their own confirmation modal) rather
+ * than relying on shell-level busy tasks. This API is kept for backwards compatibility.
+ */
 export declare abstract class PluginBusyManager {
     abstract addTask(task: PluginTask): void;
     abstract removeTask(taskId: string): void;
@@ -9,6 +14,7 @@ export declare abstract class PluginBusyManager {
     abstract isBusy(): boolean;
     abstract getTasks(): PluginTask[];
 }
+/** @deprecated See {@link PluginBusyManager}. */
 export declare class PluginBusyManagerImpl implements PluginBusyManager {
     private tasks;
     constructor();

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

@@ -4,7 +4,6 @@ export declare class ExitShellHandler {
     private api;
     constructor(api: PrimariaApi);
     handle(exitEvent: ExitShell): Promise<void>;
-    private askForClose;
     private timeout;
     private emitClose;
 }

package/package.json

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

package/src/api/api.ts

@@ -1,15 +1,9 @@
-import {
-  ApiFactory,
-  HarmonixApi,
-  PluginInfo,
-  RegionManager,
-  createRegionHost,
-  createRegionManager,
-} from "@uxland/harmonix";
+import { ApiFactory, HarmonixApi, PluginInfo, RegionManager, createRegionHost, createRegionManager } from "@uxland/harmonix";
 import { primariaShellId } from "../constants";
 import { createBroker } from "./broker/factory";
 import { PrimariaBroker } from "./broker/primaria-broker";
 import { EcapEventManager, createEcapEventManager } from "./ecap-event-manager/ecap-event-manager";
+import { ExitGuardManager, ExitGuardManagerImpl } from "./exit-guard-manager/exit-guard-manager";
 import { PrimariaGlobalStateManager, createGlobalStateManager } from "./global-state/global-state";
 import { HttpClient, createHttpClient } from "./http-client/http-client";
 import { PrimariaInteractionService } from "./interaction-service";
@@ -18,14 +12,8 @@ import { createLocaleManager } from "./localization/localization";
 import { PrimariaNotificationService } from "./notification-service/notification-service";
 import { PrimariaNotificationServiceImpl } from "./notification-service/notification.service-impl";
 import { PdfViewerManager, createPdfViewerManager } from "./pdf-viewer-manager/pdf-viewer-manager";
-import {
-  PluginBusyManager,
-  PluginBusyManagerImpl,
-} from "./plugin-busy-manager/plugin-busy-manager";
-import {
-  QuickActionBusyManager,
-  QuickActionBusyManagerImpl,
-} from "./quick-action-busy-manager/quick-action-busy-manager";
+import { PluginBusyManager, PluginBusyManagerImpl } from "./plugin-busy-manager/plugin-busy-manager";
+import { QuickActionBusyManager, QuickActionBusyManagerImpl } from "./quick-action-busy-manager/quick-action-busy-manager";
 import { PrimariaRegionManager, createRegionManagerProxy } from "./region-manager/region-manager";
 import { TokenManager, createTokenManager } from "./token-manager/token-manager";
 import { UserManager, createUserManager } from "./user-manager/user-manager";
@@ -46,6 +34,7 @@ export interface PrimariaApi extends HarmonixApi {
   userManager: UserManager;
   ecapEventManager: EcapEventManager;
   pluginBusyManager: PluginBusyManager;
+  exitGuardManager: ExitGuardManager;
   quickActionBusyManager: QuickActionBusyManager;
   pdfViewerManager: PdfViewerManager;
   importDataManager: PrimariaImportDataManager;
@@ -58,6 +47,7 @@ const userManager = createUserManager(tokenManager);
 const globalStateManager: PrimariaGlobalStateManager = createGlobalStateManager(broker);
 const contextManager = createContextManager();
 const pluginBusyManager = new PluginBusyManagerImpl();
+const exitGuardManager = new ExitGuardManagerImpl();
 const quickActionBusyManager = new QuickActionBusyManagerImpl(broker);
 const interactionService = new ParimariaInteractionServiceImpl();
 const notificationService = new PrimariaNotificationServiceImpl();
@@ -71,9 +61,7 @@ const importDataManager = new ImportDataManagerImpl(interactionService);
  * @param {PluginInfo} pluginInfo - Information about the plugin
  * @return {PrimariaApi} The created Primaria API instance
  */
-export const primariaApiFactory: ApiFactory<PrimariaApi> = (
-  pluginInfo: PluginInfo,
-): PrimariaApi => {
+export const primariaApiFactory: ApiFactory<PrimariaApi> = (pluginInfo: PluginInfo): PrimariaApi => {
   const regionManagerProxy = createRegionManagerProxy(pluginInfo, regionManager, broker);
 
   return {
@@ -88,6 +76,7 @@ export const primariaApiFactory: ApiFactory<PrimariaApi> = (
     userManager,
     ecapEventManager,
     pluginBusyManager,
+    exitGuardManager,
     quickActionBusyManager,
     interactionService,
     notificationService,

package/src/api/exit-guard-manager/exit-guard-manager.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ExitGuardManagerImpl } from "./exit-guard-manager";
+
+describe("ExitGuardManagerImpl", () => {
+  let manager: ExitGuardManagerImpl;
+
+  beforeEach(() => {
+    manager = new ExitGuardManagerImpl();
+  });
+
+  it("canExit resolves true when no guards are registered", async () => {
+    await expect(manager.canExit()).resolves.toBe(true);
+  });
+
+  it("canExit resolves true when every guard returns true", async () => {
+    manager.register("a", async () => true);
+    manager.register("b", async () => true);
+
+    await expect(manager.canExit()).resolves.toBe(true);
+  });
+
+  it("canExit resolves false when any guard returns false", async () => {
+    manager.register("a", async () => true);
+    manager.register("b", async () => false);
+
+    await expect(manager.canExit()).resolves.toBe(false);
+  });
+
+  it("canExit short-circuits and does not run guards after a false", async () => {
+    const guardA = vi.fn(async () => false);
+    const guardB = vi.fn(async () => true);
+
+    manager.register("a", guardA);
+    manager.register("b", guardB);
+
+    await manager.canExit();
+
+    expect(guardA).toHaveBeenCalled();
+    expect(guardB).not.toHaveBeenCalled();
+  });
+
+  it("unregister removes the guard", async () => {
+    const guard = vi.fn(async () => false);
+    manager.register("a", guard);
+    manager.unregister("a");
+
+    await expect(manager.canExit()).resolves.toBe(true);
+    expect(guard).not.toHaveBeenCalled();
+  });
+
+  it("register overwrites an existing guard with the same id", async () => {
+    manager.register("a", async () => false);
+    manager.register("a", async () => true);
+
+    await expect(manager.canExit()).resolves.toBe(true);
+  });
+
+  it("swallows errors in guards and continues with the remaining ones", async () => {
+    const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const failing = vi.fn(async () => {
+      throw new Error("boom");
+    });
+    const allowing = vi.fn(async () => true);
+
+    manager.register("a", failing);
+    manager.register("b", allowing);
+
+    await expect(manager.canExit()).resolves.toBe(true);
+    expect(failing).toHaveBeenCalled();
+    expect(allowing).toHaveBeenCalled();
+    expect(consoleErrorSpy).toHaveBeenCalledWith("Exit guard failed:", expect.any(Error));
+
+    consoleErrorSpy.mockRestore();
+  });
+});

package/src/api/exit-guard-manager/exit-guard-manager.ts

@@ -0,0 +1,31 @@
+export type ExitGuardCanDispose = () => Promise<boolean>;
+
+export abstract class ExitGuardManager {
+  abstract register(id: string, canDispose: ExitGuardCanDispose): void;
+  abstract unregister(id: string): void;
+  abstract canExit(): Promise<boolean>;
+}
+
+export class ExitGuardManagerImpl implements ExitGuardManager {
+  private guards = new Map<string, ExitGuardCanDispose>();
+
+  register(id: string, canDispose: ExitGuardCanDispose): void {
+    this.guards.set(id, canDispose);
+  }
+
+  unregister(id: string): void {
+    this.guards.delete(id);
+  }
+
+  async canExit(): Promise<boolean> {
+    for (const guard of this.guards.values()) {
+      try {
+        const can = await guard();
+        if (!can) return false;
+      } catch (e) {
+        console.error("Exit guard failed:", e);
+      }
+    }
+    return true;
+  }
+}

package/src/api/pdf-viewer-manager/pdf-visor/pdf-visor.ts

@@ -46,10 +46,12 @@ export class PdfVisor extends LitElement {
     }
   }
 
-  private _getPdfSrc(pdf: IPdfDocument) {
-    if (pdf.data.url) return pdf.data.url;
-    if (pdf.data.b64) return createUrlFromBase64(pdf.data.b64);
-    return "";
+  private _getPdfSrc(pdf: IPdfDocument): string {
+    const src = pdf.data.url || (pdf.data.b64 ? createUrlFromBase64(pdf.data.b64) : "") || "";
+    if (!src) return "";
+
+    const separator = src.includes("#") ? "&" : "#";
+    return `${src}${separator}navpanes=0`;
   }
 
   private _subscribeEvents() {
@@ -101,10 +103,7 @@ export class PdfVisor extends LitElement {
       <div class="pdf-container">
         ${
           this.activePdfs.length > 0
-            ? this.activePdfs.map(
-                (pdf) =>
-                  html`<iframe height="100%" src=${this._getPdfSrc(pdf)} frameborder="0"></iframe>`,
-              )
+            ? this.activePdfs.map((pdf) => html`<iframe height="100%" src=${this._getPdfSrc(pdf)} frameborder="0"></iframe>`)
             : html`
                 <div class="no-pdf">
                   <p>${translate("pdfVisor.noPdfSelected")}</p>

package/src/api/plugin-busy-manager/plugin-busy-manager.ts

@@ -6,6 +6,11 @@ export interface PluginTask {
   taskDescription: string;
 }
 
+/**
+ * @deprecated Use the `canDispose(api)` plugin lifecycle hook instead. Plugins should
+ * decide whether they can be disposed (e.g. show their own confirmation modal) rather
+ * than relying on shell-level busy tasks. This API is kept for backwards compatibility.
+ */
 export abstract class PluginBusyManager {
   abstract addTask(task: PluginTask): void;
   abstract removeTask(taskId: string): void;
@@ -14,6 +19,7 @@ export abstract class PluginBusyManager {
   abstract getTasks(): PluginTask[];
 }
 
+/** @deprecated See {@link PluginBusyManager}. */
 export class PluginBusyManagerImpl implements PluginBusyManager {
   private tasks: PluginTask[] = [];
 

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

@@ -3,9 +3,7 @@ import { ExitShellHandler } from "./handler";
 import { ExitShell } from "./request";
 import { disposePlugins } from "../../handle-plugins";
 import { disposeShell, raiseCloseEvent, raiseCustomCloseEvent } from "../../disposer";
-import { PluginBusyTask } from "../../api/plugin-busy-manager/plugin-busy-manager";
 import { PrimariaApi } from "../../api/api";
-import { PluginBusyList } from "../../api/plugin-busy-manager/plugin-busy-list/component";
 
 vi.mock("../../handle-plugins", () => ({
   disposePlugins: vi.fn(),
@@ -19,11 +17,8 @@ vi.mock("../../disposer", () => ({
 
 const createMockApi = (): PrimariaApi =>
   ({
-    pluginBusyManager: {
-      getTasks: vi.fn(),
-    },
-    interactionService: {
-      confirm: vi.fn(),
+    exitGuardManager: {
+      canExit: vi.fn(),
     },
     notificationService: {
       error: vi.fn(),
@@ -40,21 +35,22 @@ describe("ExitShellHandler", () => {
     vi.clearAllMocks();
   });
 
-  it("should dispose and raise custom close event if no busy tasks and message has ecapEvent", async () => {
+  it("disposes and raises custom close event when canExit resolves true and message has ecapEvent", async () => {
     const message = { ecapEvent: {} } as ExitShell;
-    mockApi.pluginBusyManager.getTasks = vi.fn().mockReturnValue([]);
+    (mockApi.exitGuardManager.canExit as any).mockResolvedValue(true);
     (disposePlugins as any).mockResolvedValue(undefined);
 
     await handler.handle(message);
 
+    expect(mockApi.exitGuardManager.canExit).toHaveBeenCalled();
     expect(disposePlugins).toHaveBeenCalled();
     expect(disposeShell).toHaveBeenCalled();
     expect(raiseCustomCloseEvent).toHaveBeenCalledWith(message);
   });
 
-  it("should dispose and raise default close event if no busy tasks and no ecapEvent in message", async () => {
+  it("raises default close event when no ecapEvent is present", async () => {
     const message = {} as ExitShell;
-    mockApi.pluginBusyManager.getTasks = vi.fn().mockReturnValue([]);
+    (mockApi.exitGuardManager.canExit as any).mockResolvedValue(true);
     (disposePlugins as any).mockResolvedValue(undefined);
 
     await handler.handle(message);
@@ -65,50 +61,23 @@ describe("ExitShellHandler", () => {
     expect(raiseCustomCloseEvent).not.toHaveBeenCalled();
   });
 
-  it("should ask for confirmation if there are busy tasks", async () => {
-    const busyTasks: PluginBusyTask[] = [{ pluginId: "x" }] as any;
-    const message = { ecapEvent: {} } as ExitShell;
-    mockApi.pluginBusyManager.getTasks = vi.fn().mockReturnValue(busyTasks);
-    mockApi.interactionService.confirm = vi.fn().mockResolvedValue({ confirmed: true });
-    (disposePlugins as any).mockResolvedValue(undefined);
-
-    await handler.handle(message);
-
-    expect(mockApi.interactionService.confirm).toHaveBeenCalledWith(
-      { busyTasks },
-      { component: PluginBusyList },
-      {
-        title: "actions.askExit",
-        state: "error",
-        confirmButtonText: "Sí",
-        cancelButtonText: "No",
-      },
-    );
-    expect(disposePlugins).toHaveBeenCalled();
-    expect(disposeShell).toHaveBeenCalled();
-    expect(raiseCustomCloseEvent).toHaveBeenCalledWith(message);
-  });
-
-  it("should not continue if confirmation is declined", async () => {
-    const busyTasks: PluginBusyTask[] = [{ pluginId: "x" }] as any;
+  it("aborts the exit when any guard returns false", async () => {
     const message = { ecapEvent: {} } as ExitShell;
-    mockApi.pluginBusyManager.getTasks = vi.fn().mockReturnValue(busyTasks);
-    mockApi.interactionService.confirm = vi.fn().mockResolvedValue({ confirmed: false });
+    (mockApi.exitGuardManager.canExit as any).mockResolvedValue(false);
 
     await handler.handle(message);
 
-    expect(mockApi.interactionService.confirm).toHaveBeenCalled();
+    expect(mockApi.exitGuardManager.canExit).toHaveBeenCalled();
     expect(disposePlugins).not.toHaveBeenCalled();
     expect(disposeShell).not.toHaveBeenCalled();
     expect(raiseCustomCloseEvent).not.toHaveBeenCalled();
     expect(raiseCloseEvent).not.toHaveBeenCalled();
   });
 
-  it("should handle errors and raise custom close event if message has ecapEvent", async () => {
-    const error = new Error("Something went wrong");
+  it("notifies and raises custom close event when dispose throws and ecapEvent is present", async () => {
     const message = { ecapEvent: {} } as ExitShell;
-    mockApi.pluginBusyManager.getTasks = vi.fn().mockReturnValue([]);
-    (disposePlugins as any).mockRejectedValue(error);
+    (mockApi.exitGuardManager.canExit as any).mockResolvedValue(true);
+    (disposePlugins as any).mockRejectedValue(new Error("boom"));
 
     await handler.handle(message);
 
@@ -117,11 +86,10 @@ describe("ExitShellHandler", () => {
     expect(raiseCloseEvent).not.toHaveBeenCalled();
   });
 
-  it("should handle errors and raise default close event if message has no ecapEvent", async () => {
-    const error = new Error("Something went wrong");
+  it("notifies and raises default close event when dispose throws and no ecapEvent", async () => {
     const message = {} as ExitShell;
-    mockApi.pluginBusyManager.getTasks = vi.fn().mockReturnValue([]);
-    (disposePlugins as any).mockRejectedValue(error);
+    (mockApi.exitGuardManager.canExit as any).mockResolvedValue(true);
+    (disposePlugins as any).mockRejectedValue(new Error("boom"));
 
     await handler.handle(message);
 
@@ -130,9 +98,9 @@ describe("ExitShellHandler", () => {
     expect(raiseCustomCloseEvent).not.toHaveBeenCalled();
   });
 
-  it("should proceed if disposePlugins takes longer than 10 seconds", async () => {
+  it("proceeds if disposePlugins exceeds the 10s timeout", async () => {
     const message = { ecapEvent: {} } as ExitShell;
-    mockApi.pluginBusyManager.getTasks = vi.fn().mockReturnValue([]);
+    (mockApi.exitGuardManager.canExit as any).mockResolvedValue(true);
     (disposePlugins as any).mockImplementation(() => new Promise((resolve) => setTimeout(resolve, 11000)));
 
     await handler.handle(message);
@@ -142,8 +110,8 @@ describe("ExitShellHandler", () => {
     expect(raiseCustomCloseEvent).toHaveBeenCalledWith(message);
   }, 15000);
 
-  it("should raise raiseCloseEvent if no exitEvent is passed", async () => {
-    mockApi.pluginBusyManager.getTasks = vi.fn().mockReturnValue([]);
+  it("raises raiseCloseEvent when no exitEvent is passed", async () => {
+    (mockApi.exitGuardManager.canExit as any).mockResolvedValue(true);
     (disposePlugins as any).mockResolvedValue(undefined);
 
     await handler.handle(undefined as any);

package/src/features/exit/handler.ts

@@ -4,8 +4,6 @@ import { inject } from "inversify";
 import { ExitShell } from "./request";
 import { disposeShell, raiseCloseEvent, raiseCustomCloseEvent } from "../../disposer";
 import { disposePlugins } from "../../handle-plugins";
-import { PluginBusyTask } from "../../api/plugin-busy-manager/plugin-busy-manager";
-import { PluginBusyList } from "../../api/plugin-busy-manager/plugin-busy-list/component";
 import { translate } from "../../locales";
 
 export class ExitShellHandler {
@@ -14,11 +12,8 @@ export class ExitShellHandler {
     const evt = exitEvent && exitEvent.ecapEvent !== undefined ? exitEvent : undefined;
 
     try {
-      const busyTasks = this.api.pluginBusyManager.getTasks();
-      if (busyTasks.length > 0) {
-        const { confirmed } = await this.askForClose(busyTasks);
-        if (!confirmed) return;
-      }
+      const canExit = await this.api.exitGuardManager.canExit();
+      if (!canExit) return;
 
       // Per si un plugin tarda molt en fer dispose, màxim deixarem 5 segons, per no interrompre el tancar infinitament
       await Promise.race([
@@ -33,15 +28,6 @@ export class ExitShellHandler {
     }
   }
 
-  private askForClose(busyTasks: PluginBusyTask[]) {
-    return this.api.interactionService.confirm({ busyTasks }, {component: PluginBusyList}, {
-      title: translate("actions.askExit"),
-      state: "error",
-      confirmButtonText: "Sí",
-      cancelButtonText: "No",
-    });
-  }
-
   private timeout(ms: number) {
     return new Promise<void>((resolve) => setTimeout(resolve, ms));
   }