@uxland/primary-shell 5.1.2 → 5.2.1

package/src/api/api.ts

@@ -1,28 +1,29 @@
 import {
   ApiFactory,
   HarmonixApi,
-  IRegionManager,
   PluginInfo,
+  RegionManager,
   createRegionHost,
   createRegionManager,
 } from "@uxland/harmonix";
-import { PrimariaRegionManager, createRegionManagerProxy } from "./region-manager/region-manager";
+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 { PrimariaGlobalStateManager, createGlobalStateManager } from "./global-state/global-state";
 import { HttpClient, createHttpClient } from "./http-client/http-client";
+import { PrimariaInteractionService } from "./interaction-service";
+import { ParimariaInteractionServiceImpl } from "./interaction-service/interaction-service-impl";
 import { createLocaleManager } from "./localization/localization";
-import { TokenManager, createTokenManager } from "./token-manager/token-manager";
-import { EcapEventManager, createEcapEventManager } from "./ecap-event-manager/ecap-event-manager";
+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 { PrimariaInteractionService } from "./interaction-service";
-import { ParimariaInteractionServiceImpl } from "./interaction-service/interaction-service-impl";
-import { PrimariaNotificationService } from "./notification-service/notification-service";
-import { PrimariaNotificationServiceImpl } from "./notification-service/notification.service-impl";
-import { createPdfViewerManager, PdfViewerManager } from "./pdf-viewer-manager/pdf-viewer-manager";
+import { PrimariaRegionManager, createRegionManagerProxy } from "./region-manager/region-manager";
+import { TokenManager, createTokenManager } from "./token-manager/token-manager";
 
 const broker = createBroker();
 
@@ -39,13 +40,15 @@ export interface PrimariaApi extends HarmonixApi {
   pdfViewerManager: PdfViewerManager;
 }
 
-const regionManager: IRegionManager = createRegionManager("primaria");
+const regionManager: RegionManager = createRegionManager("primaria");
 export const PrimariaRegionHost: any = createRegionHost(regionManager as any);
 const tokenManager = createTokenManager();
 const globalStateManager: PrimariaGlobalStateManager = createGlobalStateManager(broker);
 const pluginBusyManager = new PluginBusyManagerImpl(broker);
 const interactionService = new ParimariaInteractionServiceImpl();
 const notificationService = new PrimariaNotificationServiceImpl();
+const ecapEventManager = createEcapEventManager();
+const pdfViewerManager = createPdfViewerManager(broker, notificationService);
 
 /**
  * Factory function that creates a Primaria API instance.
@@ -62,16 +65,16 @@ export const primariaApiFactory: ApiFactory<PrimariaApi> = (
     pluginInfo: pluginInfo,
     regionManager: regionManagerProxy,
     httpClient: createHttpClient(tokenManager, broker),
-    broker: broker,
+    broker,
     createLocaleManager: createLocaleManager(pluginInfo.pluginId) as any,
     globalStateManager,
     tokenManager,
-    ecapEventManager: createEcapEventManager(),
+    ecapEventManager,
     pluginBusyManager,
     interactionService,
     notificationService,
-    pdfViewerManager: createPdfViewerManager(broker, notificationService, regionManagerProxy),
+    pdfViewerManager,
   };
 };
 
-export const shellApi = primariaApiFactory({ pluginId: "primaria-shell" }) as PrimariaApi;
+export const shellApi = primariaApiFactory({ pluginId: primariaShellId }) as PrimariaApi;

package/src/api/ecap-event-manager/ecap-event-manager.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createEcapEventManager } from "./ecap-event-manager";
+
+describe("EcapEventManagerImpl", () => {
+  const mockPostMessage = vi.fn();
+  const mockConsoleLog = vi.fn();
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.stubGlobal("console", {
+      ...console,
+      log: mockConsoleLog,
+    });
+    (window.parent as any) = {
+      postMessage: mockPostMessage,
+    };
+  });
+
+  it("should publish and post the event correctly", () => {
+    const eventManager = createEcapEventManager();
+    const payload = { url: "https://example.com", user: "john" };
+
+    eventManager.publish("click", "navigate", payload);
+
+    const expectedEvent = {
+      TipusEvent: "click",
+      Accio: "navigate",
+      ...payload,
+    };
+
+    expect(mockPostMessage).toHaveBeenCalledWith(JSON.stringify(expectedEvent), "*");
+    expect(mockConsoleLog).toHaveBeenCalledWith("method", JSON.stringify(expectedEvent));
+  });
+
+  it("should not fail if window.parent is undefined", () => {
+    (window as any).parent = undefined;
+
+    const eventManager = createEcapEventManager();
+    const payload = { id: "123" };
+
+    // No error should be thrown
+    expect(() => {
+      eventManager.publish("custom", "action", payload);
+    }).not.toThrow();
+
+    expect(mockConsoleLog).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,56 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { PrimariaNotificationServiceImpl } from "./notification.service-impl";
+
+describe("PrimariaNotificationServiceImpl", () => {
+  let service: PrimariaNotificationServiceImpl;
+
+  beforeEach(() => {
+    service = new PrimariaNotificationServiceImpl();
+    document.body.innerHTML = ""; // limpia el DOM antes de cada test
+    vi.useFakeTimers(); // usamos timers falsos para testear setTimeout
+  });
+
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+  });
+
+  const assertToast = (expectedState: string, message: string, duration: number = 3000) => {
+    const toast = document.querySelector("dss-toast") as HTMLElement;
+    expect(toast).not.toBeNull();
+    expect(toast.getAttribute("isshow")).toBe("true");
+    expect(toast.getAttribute("state")).toBe(expectedState);
+    expect(toast.getAttribute("position")).toBe("bottom-left");
+    expect(toast.getAttribute("text")).toBe(message);
+    expect(toast.getAttribute("hasicon")).toBe("true");
+    expect(toast.getAttribute("duration")).toBe(duration.toString());
+  };
+
+  it.each([
+    ["info", "info"],
+    ["warning", "warning"],
+    ["error", "error"],
+    ["success", "success"],
+  ] as const)("should create a '%s' toast", (method, state) => {
+    const message = `Test ${state}`;
+    (service[method] as any)(message);
+    assertToast(state, message);
+  });
+
+  it("should remove the toast after the duration", () => {
+    service.info("Temporary toast", 2000);
+
+    let toast = document.querySelector("dss-toast") as HTMLElement;
+    expect(toast).not.toBeNull();
+    expect(toast.getAttribute("isshow")).toBe("true");
+
+    // Avanza el primer timeout (esconde el toast)
+    vi.advanceTimersByTime(2000);
+    expect(toast.getAttribute("isshow")).toBe("false");
+
+    // Avanza el segundo timeout (remueve del DOM)
+    vi.advanceTimersByTime(300);
+    toast = document.querySelector("dss-toast") as HTMLElement;
+    expect(toast).toBeNull();
+  });
+});

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

@@ -0,0 +1 @@
+export const pdfViewerId = "pdf-viewer";

package/src/api/pdf-viewer-manager/handle-views.ts

@@ -0,0 +1,32 @@
+import { pdfViewerId } from "./constants";
+import { translate } from "../../locales";
+import { PrimariaNavItem } from "../../UI/shared-components/primaria-nav-item/primaria-nav-item";
+import { shellApi } from "../api";
+import { shellRegions } from "../region-manager/regions";
+import { PdfVisor } from "./pdf-visor/pdf-visor";
+
+export const registerPdfViewerNavItem = () => {
+  shellApi.regionManager.registerView(shellRegions.navigationMenu, {
+    id: pdfViewerId,
+    factory: () => {
+      const menuItem = new PrimariaNavItem({
+        icon: "picture_as_pdf",
+        label: translate("pdfManager.navButtonLabel"),
+        callbackFn: () => {
+          shellApi.regionManager.activateMainView(pdfViewerId);
+        },
+      });
+      return Promise.resolve(menuItem);
+    },
+  });
+};
+
+export const registerPDFVisorMainView = () => {
+  shellApi.regionManager.registerMainView({
+    id: pdfViewerId,
+    factory: () => {
+      const mainItem = new PdfVisor();
+      return Promise.resolve(mainItem as unknown as HTMLElement);
+    },
+  });
+};

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

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createPdfViewerManager } from "./pdf-viewer-manager";
+import { pdfViwerEvents } from "./events";
+import { registerPdfViewerNavItem } from "./handle-views";
+
+vi.mock("@primaria/plugins-core", () => ({
+  generateId: () => "generated-id",
+}));
+
+vi.mock("./handle-views", () => ({
+  registerPdfViewerNavItem: vi.fn(),
+}));
+
+vi.mock("../../locales", () => ({
+  translate: (key: string) => key,
+}));
+
+describe("PdfViewerManager", () => {
+  let manager: ReturnType<typeof createPdfViewerManager>;
+  let broker: any;
+  let notificationService: any;
+
+  beforeEach(() => {
+    broker = {
+      publish: vi.fn(),
+    };
+
+    notificationService = {
+      error: vi.fn(),
+      warning: vi.fn(),
+      success: vi.fn(),
+    };
+
+    manager = createPdfViewerManager(broker, notificationService);
+
+    vi.clearAllMocks();
+  });
+
+  it("should show error if neither url nor b64 is provided", () => {
+    manager.add("Doc1", {});
+    expect(notificationService.error).toHaveBeenCalledWith("pdfManager.missingData");
+    expect(manager.getPdfs()).toHaveLength(0);
+  });
+
+  it("should show error if both url and b64 are provided", () => {
+    manager.add("Doc1", { url: "url", b64: "b64" });
+    expect(notificationService.error).toHaveBeenCalledWith("pdfManager.duplicatedSource");
+    expect(manager.getPdfs()).toHaveLength(0);
+  });
+
+  it("should add a valid pdf and notify success", () => {
+    manager.add("Doc1", { url: "https://test.com/doc1.pdf" });
+
+    expect(manager.getPdfs()).toHaveLength(1);
+    expect(notificationService.success).toHaveBeenCalledWith("pdfManager.uploaded");
+    expect(broker.publish).toHaveBeenCalledWith(pdfViwerEvents.added, {
+      id: "generated-id",
+      pdfName: "Doc1",
+      data: { url: "https://test.com/doc1.pdf" },
+    });
+  });
+
+  it("should warn if pdf with same name already exists", () => {
+    manager.add("Doc1", { b64: "xxx" });
+    manager.add("Doc1", { b64: "xxx" });
+
+    expect(notificationService.warning).toHaveBeenCalledWith("pdfManager.alreadyUploaded");
+    expect(manager.getPdfs()).toHaveLength(1); // solo el primero
+  });
+
+  it("should call registerNavButton only once", () => {
+    manager.add("Doc1", { url: "u" });
+    manager.add("Doc2", { url: "u2" });
+
+    expect(registerPdfViewerNavItem).toHaveBeenCalledTimes(1);
+  });
+
+  it("should delete a pdf and publish deletion event", () => {
+    manager.add("Doc1", { url: "u" });
+    const id = manager.getPdfs()[0].id;
+
+    manager.delete(id);
+
+    expect(manager.getPdfs()).toHaveLength(0);
+    expect(broker.publish).toHaveBeenCalledWith(pdfViwerEvents.deleted, { id });
+  });
+
+  it("should clear activePdf if deleted", () => {
+    manager.add("Doc1", { url: "u" });
+    const id = manager.getPdfs()[0].id;
+
+    // simula que esté activo
+    (manager as any).activePdf = { id } as any;
+
+    manager.delete(id);
+
+    expect((manager as any).activePdf).toBeNull();
+  });
+});

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

@@ -1,12 +1,12 @@
+import { generateId } from "@primaria/plugins-core";
+import { customElement } from "lit/decorators.js";
+import { registerPdfViewerNavItem } from "./handle-views";
 import { translate } from "../../locales";
-import { PrimariaNavItem } from "../../UI/shared-components/primaria-nav-item/primaria-nav-item";
 import { PrimariaBroker } from "../broker/primaria-broker";
 import { PrimariaNotificationService } from "../notification-service/notification-service";
-import { shellRegions } from "../region-manager/regions";
 import { pdfViwerEvents } from "./events";
-import { pdfViewerId } from "../../constants";
-import { PrimariaRegionManager } from "../region-manager/region-manager";
-import { generateId } from "@primaria/plugins-core";
+import { PdfSelector } from "./pdf-visor/pdf-selector/pdf-selector";
+import { PdfVisor } from "./pdf-visor/pdf-visor";
 
 export interface IPdfDocument {
   pdfName: string;
@@ -23,8 +23,14 @@ export class PdfViewerManager {
   constructor(
     private broker: PrimariaBroker,
     private notificationService: PrimariaNotificationService,
-    private regionManager: PrimariaRegionManager,
-  ) {}
+  ) {
+    if (!customElements.get("pdf-visor")) {
+      customElement("pdf-visor")(PdfVisor);
+    }
+    if (!customElements.get("pdf-selector")) {
+      customElement("pdf-selector")(PdfSelector);
+    }
+  }
 
   private pdfs: IPdfDocument[] = [];
   private activePdf: IPdfDocument | null = null;
@@ -71,27 +77,11 @@ export class PdfViewerManager {
   }
 
   private registerNavButton() {
-    this.regionManager.registerView(shellRegions.navigationMenu, {
-      id: pdfViewerId,
-      factory: () => {
-        const menuItem = new PrimariaNavItem({
-          icon: "picture_as_pdf",
-          label: translate("pdfManager.navButtonLabel"),
-          callbackFn: () => {
-            this.regionManager.activateMainView(pdfViewerId);
-          },
-        });
-        return Promise.resolve(menuItem);
-      },
-    });
+    registerPdfViewerNavItem();
   }
 }
 
-const pdfViewerManager = (broker, interactionManager, regionManager) =>
-  new PdfViewerManager(broker, interactionManager, regionManager);
-
 export const createPdfViewerManager = (
   broker: PrimariaBroker,
   notificationService: PrimariaNotificationService,
-  regionManager: PrimariaRegionManager,
-) => pdfViewerManager(broker, notificationService, regionManager);
+) => new PdfViewerManager(broker, notificationService);

package/src/{UI/components → api/pdf-viewer-manager}/pdf-visor/pdf-selector/pdf-selector.ts

@@ -1,11 +1,10 @@
 import { LitElement, css, unsafeCSS } from "lit";
-import { customElement, property } from "lit/decorators.js";
+import { property } from "lit/decorators.js";
 import { IPdfDocument } from "../../../../../src/api/pdf-viewer-manager/pdf-viewer-manager";
-import { template } from "./template";
-import styles from "./styles.css?inline";
 import { createUrlFromBase64 } from "../utils";
+import styles from "./styles.css?inline";
+import { template } from "./template";
 
-@customElement("pdf-selector")
 export class PdfSelector extends LitElement {
   render() {
     return template(this);

package/src/{UI/components → api/pdf-viewer-manager}/pdf-visor/pdf-visor.ts

@@ -1,16 +1,15 @@
-import styles from "./styles.css?inline";
-import { html, LitElement, css, unsafeCSS } from "lit";
-import { customElement, property } from "lit/decorators.js";
-import { BrokerDisposableHandler } from "../../../api/broker/primaria-broker";
-import { PrimariaApi } from "../../../api/api";
-import { TYPES } from "../../../../src/infrastructure/ioc/types";
-import { lazyInject } from "../../../../src/infrastructure/ioc/container";
+import { css, html, LitElement, unsafeCSS } from "lit";
+import { property } from "lit/decorators.js";
 import { pdfViwerEvents } from "../../../../src/api/pdf-viewer-manager/events";
-import { IPdfDocument } from "../../../api/pdf-viewer-manager/pdf-viewer-manager";
+import { lazyInject } from "../../../../src/infrastructure/ioc/container";
+import { TYPES } from "../../../../src/infrastructure/ioc/types";
 import { translate } from "../../../../src/locales";
+import { PrimariaApi } from "../../../api/api";
+import { BrokerDisposableHandler } from "../../../api/broker/primaria-broker";
+import { IPdfDocument } from "../../../api/pdf-viewer-manager/pdf-viewer-manager";
+import styles from "./styles.css?inline";
 import { createUrlFromBase64 } from "./utils";
 
-@customElement("pdf-visor")
 export class PdfVisor extends LitElement {
   static styles = css`${unsafeCSS(styles)}`;
 

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

@@ -1,10 +1,8 @@
 import { LitElement, css, html, unsafeCSS } from "lit";
-import { customElement } from "lit/decorators.js";
 import { PluginBusyTask } from "../plugin-busy-manager";
 import styles from "./styles.css?inline";
 import { template } from "./template";
 
-@customElement("plugin-busy-list")
 export class PluginBusyList extends LitElement {
   static styles = css`
     ${unsafeCSS(styles)}

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

@@ -1,5 +1,7 @@
+import { customElement } from "lit/decorators.js";
 import { shellEvents } from "../../events";
 import { PrimariaBroker } from "../broker/primaria-broker";
+import { PluginBusyList } from "./plugin-busy-list/component";
 
 export interface PluginBusyTask {
   taskId: string;
@@ -21,7 +23,11 @@ export abstract class PluginBusyManager {
   abstract getBusyPluginTasks(): PluginBusyTask[];
 }
 export class PluginBusyManagerImpl implements PluginBusyManager {
-  constructor(public broker: PrimariaBroker) {}
+  constructor(public broker: PrimariaBroker) {
+    if (!customElements.get("plugin-busy-list")) {
+      customElement("plugin-busy-list")(PluginBusyList);
+    }
+  }
   private busyPluginTasks: PluginBusyTask[] = [];
   private busyQuickActionTasks: QuickActionBusyTask[] = [];
 

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

@@ -0,0 +1,123 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createRegionManagerProxy } from "./region-manager";
+import { shellRegions } from "./regions";
+import { shellEvents } from "../../events";
+
+const pluginId = "test-plugin";
+const mockView = { id: "view1" };
+
+const createMockRegion = () => ({
+  activate: vi.fn(),
+  deactivate: vi.fn(),
+  removeView: vi.fn(),
+  containsView: vi.fn().mockReturnValue(true),
+  isViewActive: vi.fn().mockReturnValue(false),
+  currentActiveViews: [{ id: "view1" }],
+});
+
+describe("RegionManagerProxy", () => {
+  let proxy: ReturnType<typeof createRegionManagerProxy>;
+  let regionManager: any;
+  let broker: any;
+  let regionMock: any;
+
+  beforeEach(() => {
+    regionMock = createMockRegion();
+    regionManager = {
+      registerViewWithRegion: vi.fn(),
+      getRegion: vi.fn().mockReturnValue(regionMock),
+      destroy: vi.fn(),
+    };
+
+    broker = {
+      publish: vi.fn(),
+    };
+
+    proxy = createRegionManagerProxy({ pluginId }, regionManager, broker);
+  });
+
+  it("registerView should delegate to regionManager", async () => {
+    await proxy.registerView("test-region", mockView);
+    expect(regionManager.registerViewWithRegion).toHaveBeenCalledWith(
+      "test-region",
+      `${pluginId}::${mockView.id}`,
+      mockView,
+    );
+  });
+
+  it("removeView should remove view from region", async () => {
+    await proxy.removeView("main", "view1");
+    expect(regionMock.removeView).toHaveBeenCalledWith(`${pluginId}::view1`);
+  });
+
+  it("activateView should activate the view and notify if region is main", async () => {
+    await proxy.activateView(shellRegions.main, "view1");
+    expect(regionMock.activate).toHaveBeenCalledWith(`${pluginId}::view1`);
+    expect(broker.publish).toHaveBeenCalledWith(shellEvents.mainViewChanged, { viewId: "view1" });
+  });
+
+  it("deactivateView should deactivate the view", async () => {
+    await proxy.deactivateView("main", "view1");
+    expect(regionMock.deactivate).toHaveBeenCalledWith(`${pluginId}::view1`);
+  });
+
+  it("getRegion should return the region", async () => {
+    const region = await proxy.getRegion("main");
+    expect(region).toEqual(regionMock);
+  });
+
+  it("containsView should check for view existence", async () => {
+    const result = await proxy.containsView("main", "view1");
+    expect(regionMock.containsView).toHaveBeenCalledWith(`${pluginId}::view1`);
+    expect(result).toBe(true);
+  });
+
+  it("isViewActive should check if view is active", async () => {
+    const result = await proxy.isViewActive("main", "view1");
+    expect(regionMock.isViewActive).toHaveBeenCalledWith(`${pluginId}::view1`);
+    expect(result).toBe(false);
+  });
+
+  it("registerQuickAction should register in quickActions region", async () => {
+    await proxy.registerQuickAction(mockView);
+    expect(regionManager.registerViewWithRegion).toHaveBeenCalledWith(
+      shellRegions.quickActions,
+      `${pluginId}::${mockView.id}`,
+      mockView,
+    );
+  });
+
+  it("registerNavigationMenu should register in navigationMenu region", async () => {
+    await proxy.registerNavigationMenu(mockView);
+    expect(regionManager.registerViewWithRegion).toHaveBeenCalledWith(
+      shellRegions.navigationMenu,
+      `${pluginId}::${mockView.id}`,
+      mockView,
+    );
+  });
+
+  it("registerMainView should register in main region", async () => {
+    await proxy.registerMainView(mockView);
+    expect(regionManager.registerViewWithRegion).toHaveBeenCalledWith(
+      shellRegions.main,
+      `${pluginId}::${mockView.id}`,
+      mockView,
+    );
+  });
+
+  it("activateMainView should activate main view and notify broker", async () => {
+    await proxy.activateMainView("view1");
+    expect(regionMock.activate).toHaveBeenCalledWith(`${pluginId}::view1`);
+    expect(broker.publish).toHaveBeenCalledWith(shellEvents.mainViewChanged, { viewId: "view1" });
+  });
+
+  it("getCurrentMainViewActive should return id of the active main view", () => {
+    const result = proxy.getCurrentMainViewActive();
+    expect(result).toBe("view1");
+  });
+
+  it("_destroy should call regionManager.destroy", () => {
+    proxy._destroy();
+    expect(regionManager.destroy).toHaveBeenCalled();
+  });
+});

package/src/bootstrapper.ts

@@ -1,16 +1,15 @@
-import { selectableAdapterFactory as factory, regionAdapterRegistry } from "@uxland/regions";
-import "./UI/components/primaria-error-view/component";
 import { PrimariaShell } from "./UI/components/primaria-shell/primaria-shell";
 import { shellApi } from "./api/api";
-import { bootstrapFeatures } from "./features/bootstrapper";
-import { registerInternalViews } from "./handle-views";
-import { initializeLocalization } from "./locales";
+import { useFeatures } from "./features/bootstrapper";
+import { useInternalViews } from "./handle-views";
+import { useLocalization } from "./locales";
+import { useUI } from "./UI/bootstrapper";
 
 export const initializeShell = (hostAppElement: HTMLElement) => {
-  initializeLocalization(shellApi);
-  regionAdapterRegistry.registerAdapterFactory("primaria-content-switcher", factory);
+  useLocalization(shellApi);
+  useUI();
+  useInternalViews();
+  useFeatures(shellApi);
   const shell = new PrimariaShell();
   hostAppElement.appendChild(shell as any);
-  registerInternalViews();
-  bootstrapFeatures(shellApi);
 };

package/src/constants.ts

@@ -1,4 +1,2 @@
 export const primariaShellId = "primaria-shell";
-export const clinicalMonitoringId = "clinical-monitoring";
 export const pocTestEventsId = "poc-events-ecap";
-export const pdfViewerId = "pdf-viewer";

package/src/disposer.ts

@@ -1,7 +1,7 @@
 import { shellApi } from "./api/api";
-import { teardownFeatures } from "./features/bootstrapper";
+import { disposeFeatures } from "./features/bootstrapper";
 export const disposeShell = () => {
-  teardownFeatures(shellApi);
+  disposeFeatures(shellApi);
 };
 
 export const raiseCloseEvent = () => {

package/src/features/bootstrapper.ts

@@ -2,20 +2,26 @@ import { mediatorSettings } from "mediatr-ts";
 import { PrimariaApi } from "../api/api";
 import { container } from "../infrastructure/ioc/container";
 import { TYPES } from "../infrastructure/ioc/types";
-import { bootstrapExitShell, teardownExitShell } from "./exit/bootstrapper";
-import { bootstrapGetUserInfo, teardownGetUserInfo } from "./get-user-info/bootstrapper";
+import { useExitShell, disposeExitShell } from "./exit/bootstrapper";
+import { useGetUserInfo, disposeGetUserInfo } from "./get-user-info/bootstrapper";
 import { GetUserInfo } from "./get-user-info/request";
+import {
+  disposeClinicalMonitoring,
+  useClinicalMonitoring,
+} from "./clinical-monitoring/bootstrapper";
 
-export const bootstrapFeatures = (api: PrimariaApi) => {
+export const useFeatures = (api: PrimariaApi) => {
   container.bind(TYPES.primaryApi).toConstantValue(api);
-  bootstrapGetUserInfo();
-  bootstrapExitShell();
+  useGetUserInfo(api);
+  useExitShell(api);
+  useClinicalMonitoring(api);
   api.broker.send(new GetUserInfo());
 };
 
-export const teardownFeatures = (api: PrimariaApi) => {
-  teardownGetUserInfo();
-  teardownExitShell();
+export const disposeFeatures = (api: PrimariaApi) => {
+  disposeGetUserInfo();
+  disposeExitShell();
+  disposeClinicalMonitoring(api);
   container.unbindAll();
   api.regionManager._destroy();
   mediatorSettings.resolver.clear();