@uxland/primary-shell 7.11.4 → 7.12.0

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

@@ -7,6 +7,7 @@ import { PrimariaInteractionService } from './interaction-service';
 import { PrimariaNotificationService } from './notification-service/notification-service';
 import { PdfViewerManager } from './pdf-viewer-manager/pdf-viewer-manager';
 import { PluginBusyManager } from './plugin-busy-manager/plugin-busy-manager';
+import { QuickActionBusyManager } from './quick-action-busy-manager/quick-action-busy-manager';
 import { PrimariaRegionManager } from './region-manager/region-manager';
 import { TokenManager } from './token-manager/token-manager';
 import { UserManager } from './user-manager/user-manager';
@@ -22,6 +23,7 @@ export interface PrimariaApi extends HarmonixApi {
     userManager: UserManager;
     ecapEventManager: EcapEventManager;
     pluginBusyManager: PluginBusyManager;
+    quickActionBusyManager: QuickActionBusyManager;
     pdfViewerManager: PdfViewerManager;
     importDataManager: PrimariaImportDataManager;
 }

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

@@ -1,34 +1,20 @@
-import { PrimariaBroker } from '../broker/primaria-broker';
-export interface PluginBusyTask {
+export interface PluginTask {
     taskId: string;
     taskDescription: string;
 }
-export interface QuickActionBusyTask {
-    taskId: string;
-}
 export declare abstract class PluginBusyManager {
-    abstract addBusyPluginTask(busyTask: PluginBusyTask): void;
-    abstract removeBusyPluginTask(taskId: string): void;
-    abstract addBusyQuickActionTask(busyTask: QuickActionBusyTask): void;
-    abstract removeBusyQuickActionTask(taskId: string): void;
-    abstract clearAllBusyPlugins(): void;
-    abstract isAnyPluginBusy(): boolean;
-    abstract isAnyQuickActionBusy(): boolean;
-    abstract getBusyPluginTasks(): PluginBusyTask[];
+    abstract addTask(task: PluginTask): void;
+    abstract removeTask(taskId: string): void;
+    abstract clearAll(): void;
+    abstract isBusy(): boolean;
+    abstract getTasks(): PluginTask[];
 }
 export declare class PluginBusyManagerImpl implements PluginBusyManager {
-    broker: PrimariaBroker;
-    constructor(broker: PrimariaBroker);
-    private busyPluginTasks;
-    private busyQuickActionTasks;
-    addBusyPluginTask(busyTask: PluginBusyTask): void;
-    addBusyQuickActionTask(busyTask: QuickActionBusyTask): void;
-    removeBusyPluginTask(taskId: string): any;
-    removeBusyQuickActionTask(taskId: string): any;
-    isAnyPluginBusy(): boolean;
-    isAnyQuickActionBusy(): boolean;
-    clearAllBusyPlugins(): void;
-    clearAllBusyQuickActions(): void;
-    getBusyPluginTasks(): PluginBusyTask[];
-    private emitQuickActionBusyChanged;
+    private tasks;
+    constructor();
+    addTask(task: PluginTask): void;
+    removeTask(taskId: string): void;
+    isBusy(): boolean;
+    clearAll(): void;
+    getTasks(): PluginTask[];
 }

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

@@ -0,0 +1,20 @@
+import { PrimariaBroker } from '../broker/primaria-broker';
+export interface QuickActionTask {
+    taskId: string;
+}
+export declare abstract class QuickActionBusyManager {
+    abstract addTask(task: QuickActionTask): void;
+    abstract removeTask(taskId: string): void;
+    abstract clearAll(): void;
+    abstract isBusy(): boolean;
+}
+export declare class QuickActionBusyManagerImpl implements QuickActionBusyManager {
+    private broker;
+    private tasks;
+    constructor(broker: PrimariaBroker);
+    addTask(task: QuickActionTask): void;
+    removeTask(taskId: string): void;
+    isBusy(): boolean;
+    clearAll(): void;
+    private emitBusyChanged;
+}

package/dist/primary/shell/src/api/quick-action-busy-manager/quick-action-busy-manager.test.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "7.11.4",
+  "version": "7.12.0",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",
@@ -30,14 +30,14 @@
   },
   "devDependencies": {
     "@primaria/plugins-core": "^1.0.14",
-    "@salut/design-system-salut": "../../design-system-salut-2.8.0.tgz",
+    "@salut/design-system-salut": "../../design-system-salut-2.9.0.tgz",
     "@types/react": "^19.0.12",
     "@uxland/lit-utilities": "^1.0.0",
     "@uxland/localization": "^1.0.3",
     "@uxland/regions": "^1.0.0",
     "@uxland/utilities": "^1.0.5",
-    "axios": "^1.7.2",
-    "axios-mock-adapter": "^2.0.0",
+    "axios": "^1.12.2",
+    "axios-mock-adapter": "^2.1.0",
     "inversify": "^6.0.2",
     "inversify-inject-decorators": "^3.1.0",
     "jwt-decode": "^4.0.0",

package/src/api/api.ts

@@ -22,6 +22,10 @@ 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";
@@ -40,6 +44,7 @@ export interface PrimariaApi extends HarmonixApi {
   userManager: UserManager;
   ecapEventManager: EcapEventManager;
   pluginBusyManager: PluginBusyManager;
+  quickActionBusyManager: QuickActionBusyManager;
   pdfViewerManager: PdfViewerManager;
   importDataManager: PrimariaImportDataManager;
 }
@@ -49,7 +54,8 @@ export const PrimariaRegionHost: any = createRegionHost(regionManager as any);
 const tokenManager = createTokenManager();
 const userManager = createUserManager(tokenManager);
 const globalStateManager: PrimariaGlobalStateManager = createGlobalStateManager(broker);
-const pluginBusyManager = new PluginBusyManagerImpl(broker);
+const pluginBusyManager = new PluginBusyManagerImpl();
+const quickActionBusyManager = new QuickActionBusyManagerImpl(broker);
 const interactionService = new ParimariaInteractionServiceImpl();
 const notificationService = new PrimariaNotificationServiceImpl();
 const ecapEventManager = createEcapEventManager();
@@ -78,6 +84,7 @@ export const primariaApiFactory: ApiFactory<PrimariaApi> = (
     userManager,
     ecapEventManager,
     pluginBusyManager,
+    quickActionBusyManager,
     interactionService,
     notificationService,
     pdfViewerManager,

package/src/api/broker/factory.ts

@@ -110,25 +110,22 @@ class Broker implements PrimariaBroker {
   }
 }
 
-const createDynamicEventClass = (eventName: string) =>
-  createDynamicMessageClass(eventName, "Event");
-
-const createDynamicRequestClass = (requestName: string) =>
-  createDynamicMessageClass(requestName, "Request");
+const createDynamicEventClass = (eventName: string) => {
+  return new Function(`return class Event_${eventName} {
+    constructor(payload) {
+            this.payload = payload;
+        }
+    }`)();
+};
 
-const createDynamicMessageClass = (eventName: string, classPrefix: string) => {
-  return new Function(`return class ${classPrefix}_${eventName} {
+const createDynamicRequestClass = (requestName: string) => {
+  return new Function(`return class Request_${requestName} {
     constructor(payload) {
             Object.assign(this, payload);
         }
     }`)();
 };
 
-const createDynamicRequestHandler = (handler: messageHandler) =>
-  createDynamicMessageHandler(handler, "RequestHandler");
-const createDynamicEventHandler = (handler: messageHandler) =>
-  createDynamicMessageHandler(handler, "EventHandler");
-
 const usedSuffixes = new Set();
 
 function generateUniqueRandomSuffix() {
@@ -141,8 +138,8 @@ function generateUniqueRandomSuffix() {
   return suffix;
 }
 
-const createDynamicMessageHandler = (handler: messageHandler, classPrefix: string) => {
-  const className = `${classPrefix}_${generateUniqueRandomSuffix()}`; // Generate a random class name
+const createDynamicRequestHandler = (handler: messageHandler) => {
+  const className = `RequestHandler_${generateUniqueRandomSuffix()}`;
   return new Function(
     "handler",
     `return class ${className}{
@@ -154,4 +151,18 @@ const createDynamicMessageHandler = (handler: messageHandler, classPrefix: strin
   )(handler);
 };
 
+const createDynamicEventHandler = (handler: messageHandler) => {
+  const className = `EventHandler_${generateUniqueRandomSuffix()}`;
+  return new Function(
+    "handler",
+    `return class ${className}{
+        handle(notification){
+            const payload = notification.payload !== undefined ? notification.payload : {...notification};
+            const handlerResult = handler(payload);
+            return handlerResult instanceof Promise ? handlerResult : Promise.resolve(handlerResult);
+        }
+    }`,
+  )(handler);
+};
+
 export const createBroker = (): PrimariaBroker => new Broker(); 

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

@@ -1,122 +1,72 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
 import { PluginBusyManagerImpl } from "./plugin-busy-manager";
-import { shellEvents } from "../../events";
 
 describe("PluginBusyManagerImpl", () => {
-  let brokerMock: any;
   let manager: PluginBusyManagerImpl;
 
   beforeEach(() => {
-    brokerMock = {
-      publish: vi.fn(),
-    };
-    manager = new PluginBusyManagerImpl(brokerMock);
+    manager = new PluginBusyManagerImpl();
   });
 
-  describe("addBusyPluginTask", () => {
-    it("should add a plugin busy task", () => {
-    const task = { taskId: "1", taskDescription: "Loading plugin" };
-    manager.addBusyPluginTask(task);
-    expect(manager.getBusyPluginTasks()).toContain(task);
-  });
-
-  it("should not add a task if taskId already exists", () => {
-    const task1 = { taskId: "1", taskDescription: "First task" };
-    const task2 = { taskId: "1", taskDescription: "Duplicate task" }; // mismo taskId
-    manager.addBusyPluginTask(task1);
-    manager.addBusyPluginTask(task2);
-    const tasks = manager.getBusyPluginTasks();
-
-    expect(tasks.length).toBe(1);
-    expect(tasks[0]).toEqual(task1); // Asegura que no fue reemplazado ni duplicado
-  });
-  });
-
-  describe("removeBusyPluginTask", () => {
-    it("should remove a plugin busy task if it exists", () => {
+  describe("addTask", () => {
+    it("should add a task", () => {
       const task = { taskId: "1", taskDescription: "Loading plugin" };
-      manager.addBusyPluginTask(task);
-      manager.removeBusyPluginTask("1");
-      expect(manager.getBusyPluginTasks()).not.toContain(task);
+      manager.addTask(task);
+      expect(manager.getTasks()).toContain(task);
     });
 
-    it("should do nothing if task does not exist", () => {
-      const task = { taskId: "1", taskDescription: "Loading plugin" };
-      manager.addBusyPluginTask(task);
-      manager.removeBusyPluginTask("non-existent");
-      expect(manager.getBusyPluginTasks()).toContain(task);
-    });
-  });
+    it("should not add a task if taskId already exists", () => {
+      const task1 = { taskId: "1", taskDescription: "First task" };
+      const task2 = { taskId: "1", taskDescription: "Duplicate task" };
+      manager.addTask(task1);
+      manager.addTask(task2);
+      const tasks = manager.getTasks();
 
-  describe("addBusyQuickActionTask", () => {
-    it("should add a quick action busy task and emit event", () => {
-      const task = { taskId: "qa1" };
-      manager.addBusyQuickActionTask(task);
-      expect(brokerMock.publish).toHaveBeenCalledWith(shellEvents.quickActionBusyChanged, {
-        busy: true,
-      });
+      expect(tasks.length).toBe(1);
+      expect(tasks[0]).toEqual(task1);
     });
   });
 
-  describe("removeBusyQuickActionTask", () => {
-    it("should remove a quick action task and emit event", () => {
-      const task = { taskId: "qa1" };
-      manager.addBusyQuickActionTask(task);
-      manager.removeBusyQuickActionTask("qa1");
-      expect(brokerMock.publish).toHaveBeenCalledWith(shellEvents.quickActionBusyChanged, {
-        busy: false,
-      });
-    });
-
-    it("should do nothing and not emit event if task does not exist", () => {
-      manager.removeBusyQuickActionTask("non-existent");
-      expect(brokerMock.publish).not.toHaveBeenCalled();
-    });
-  });
-
-  describe("isAnyPluginBusy", () => {
-    it("should return false when no plugin tasks exist", () => {
-      expect(manager.isAnyPluginBusy()).toBe(false);
+  describe("removeTask", () => {
+    it("should remove a task if it exists", () => {
+      const task = { taskId: "1", taskDescription: "Loading plugin" };
+      manager.addTask(task);
+      manager.removeTask("1");
+      expect(manager.getTasks()).not.toContain(task);
     });
 
-    it("should return true when plugin tasks exist", () => {
-      manager.addBusyPluginTask({ taskId: "1", taskDescription: "Busy" });
-      expect(manager.isAnyPluginBusy()).toBe(true);
+    it("should do nothing if task does not exist", () => {
+      const task = { taskId: "1", taskDescription: "Loading plugin" };
+      manager.addTask(task);
+      manager.removeTask("non-existent");
+      expect(manager.getTasks()).toContain(task);
     });
   });
 
-  describe("isAnyQuickActionBusy", () => {
-    it("should return false when no quick action tasks exist", () => {
-      expect(manager.isAnyQuickActionBusy()).toBe(false);
+  describe("isBusy", () => {
+    it("should return false when no tasks exist", () => {
+      expect(manager.isBusy()).toBe(false);
     });
 
-    it("should return true when quick action tasks exist", () => {
-      manager.addBusyQuickActionTask({ taskId: "qa1" });
-      expect(manager.isAnyQuickActionBusy()).toBe(true);
-    });
-  });
-
-  describe("clearAllBusyPlugins", () => {
-    it("should clear all plugin busy tasks", () => {
-      manager.addBusyPluginTask({ taskId: "1", taskDescription: "Busy" });
-      manager.clearAllBusyPlugins();
-      expect(manager.getBusyPluginTasks()).toHaveLength(0);
+    it("should return true when tasks exist", () => {
+      manager.addTask({ taskId: "1", taskDescription: "Busy" });
+      expect(manager.isBusy()).toBe(true);
     });
   });
 
-  describe("clearAllBusyQuickActions", () => {
-    it("should clear all quick action busy tasks", () => {
-      manager.addBusyQuickActionTask({ taskId: "qa1" });
-      manager.clearAllBusyQuickActions();
-      expect(manager.isAnyQuickActionBusy()).toBe(false);
+  describe("clearAll", () => {
+    it("should clear all tasks", () => {
+      manager.addTask({ taskId: "1", taskDescription: "Busy" });
+      manager.clearAll();
+      expect(manager.getTasks()).toHaveLength(0);
     });
   });
 
-  describe("getBusyPluginTasks", () => {
-    it("should return current plugin tasks", () => {
+  describe("getTasks", () => {
+    it("should return current tasks", () => {
       const task = { taskId: "1", taskDescription: "Loading plugin" };
-      manager.addBusyPluginTask(task);
-      expect(manager.getBusyPluginTasks()).toEqual([task]);
+      manager.addTask(task);
+      expect(manager.getTasks()).toEqual([task]);
     });
   });
 });

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

@@ -1,90 +1,51 @@
 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 {
+export interface PluginTask {
   taskId: string;
   taskDescription: string;
 }
 
-export interface QuickActionBusyTask {
-  taskId: string;
-}
-
 export abstract class PluginBusyManager {
-  abstract addBusyPluginTask(busyTask: PluginBusyTask): void;
-  abstract removeBusyPluginTask(taskId: string): void;
-  abstract addBusyQuickActionTask(busyTask: QuickActionBusyTask): void;
-  abstract removeBusyQuickActionTask(taskId: string): void;
-  abstract clearAllBusyPlugins(): void;
-  abstract isAnyPluginBusy(): boolean;
-  abstract isAnyQuickActionBusy(): boolean;
-  abstract getBusyPluginTasks(): PluginBusyTask[];
+  abstract addTask(task: PluginTask): void;
+  abstract removeTask(taskId: string): void;
+  abstract clearAll(): void;
+  abstract isBusy(): boolean;
+  abstract getTasks(): PluginTask[];
 }
+
 export class PluginBusyManagerImpl implements PluginBusyManager {
-  constructor(public broker: PrimariaBroker) {
+  private tasks: PluginTask[] = [];
+
+  constructor() {
     if (!customElements.get("plugin-busy-list")) {
       customElement("plugin-busy-list")(PluginBusyList);
     }
   }
-  private busyPluginTasks: PluginBusyTask[] = [];
-  private busyQuickActionTasks: QuickActionBusyTask[] = [];
 
-  public addBusyPluginTask(busyTask: PluginBusyTask): void {
-    const exists = this.busyPluginTasks.some((task) => task.taskId === busyTask.taskId);
+  public addTask(task: PluginTask): void {
+    const exists = this.tasks.some((t) => t.taskId === task.taskId);
     if (!exists) {
-      this.busyPluginTasks.push(busyTask);
-    }
-  }
-
-  public addBusyQuickActionTask(busyTask: QuickActionBusyTask): void {
-    const index = this.busyQuickActionTasks.findIndex((item) => item.taskId === busyTask.taskId);
-    if (index > -1) {
-      return;
-    }
-
-    this.busyQuickActionTasks.push(busyTask);
-    this.emitQuickActionBusyChanged();
-  }
-
-  public removeBusyPluginTask(taskId: string): any {
-    const index = this.busyPluginTasks.findIndex((item) => item.taskId === taskId);
-    if (index > -1) {
-      this.busyPluginTasks.splice(index, 1);
+      this.tasks.push(task);
     }
   }
 
-  public removeBusyQuickActionTask(taskId: string): any {
-    const index = this.busyQuickActionTasks.findIndex((item) => item.taskId === taskId);
+  public removeTask(taskId: string): void {
+    const index = this.tasks.findIndex((item) => item.taskId === taskId);
     if (index > -1) {
-      this.busyQuickActionTasks.splice(index, 1);
-      this.emitQuickActionBusyChanged();
+      this.tasks.splice(index, 1);
     }
   }
 
-  public isAnyPluginBusy(): boolean {
-    return this.busyPluginTasks.length > 0;
-  }
-
-  public isAnyQuickActionBusy(): boolean {
-    return this.busyQuickActionTasks.length > 0;
-  }
-
-  public clearAllBusyPlugins(): void {
-    this.busyPluginTasks = [];
-  }
-
-  public clearAllBusyQuickActions(): void {
-    this.busyQuickActionTasks = [];
+  public isBusy(): boolean {
+    return this.tasks.length > 0;
   }
 
-  public getBusyPluginTasks(): PluginBusyTask[] {
-    return this.busyPluginTasks;
+  public clearAll(): void {
+    this.tasks = [];
   }
 
-  private emitQuickActionBusyChanged() {
-    const busy = this.isAnyQuickActionBusy();
-    this.broker.publish(shellEvents.quickActionBusyChanged, { busy });
+  public getTasks(): PluginTask[] {
+    return this.tasks;
   }
 }

package/src/api/quick-action-busy-manager/quick-action-busy-manager.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { QuickActionBusyManagerImpl } from "./quick-action-busy-manager";
+import { shellEvents } from "../../events";
+
+describe("QuickActionBusyManagerImpl", () => {
+  let brokerMock: any;
+  let manager: QuickActionBusyManagerImpl;
+
+  beforeEach(() => {
+    brokerMock = {
+      publish: vi.fn(),
+    };
+    manager = new QuickActionBusyManagerImpl(brokerMock);
+  });
+
+  describe("addTask", () => {
+    it("should add a task and emit event", () => {
+      const task = { taskId: "qa1" };
+      manager.addTask(task);
+      expect(brokerMock.publish).toHaveBeenCalledWith(shellEvents.quickActionBusyChanged, {
+        busy: true,
+      });
+    });
+
+    it("should not add duplicate task with same taskId", () => {
+      const task = { taskId: "qa1" };
+      manager.addTask(task);
+      manager.addTask(task);
+
+      // Should only emit once for the first addition
+      expect(brokerMock.publish).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("removeTask", () => {
+    it("should remove a task and emit event", () => {
+      const task = { taskId: "qa1" };
+      manager.addTask(task);
+      manager.removeTask("qa1");
+      expect(brokerMock.publish).toHaveBeenCalledWith(shellEvents.quickActionBusyChanged, {
+        busy: false,
+      });
+    });
+
+    it("should do nothing and not emit event if task does not exist", () => {
+      manager.removeTask("non-existent");
+      expect(brokerMock.publish).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("isBusy", () => {
+    it("should return false when no tasks exist", () => {
+      expect(manager.isBusy()).toBe(false);
+    });
+
+    it("should return true when tasks exist", () => {
+      manager.addTask({ taskId: "qa1" });
+      expect(manager.isBusy()).toBe(true);
+    });
+  });
+
+  describe("clearAll", () => {
+    it("should clear all tasks", () => {
+      manager.addTask({ taskId: "qa1" });
+      manager.clearAll();
+      expect(manager.isBusy()).toBe(false);
+    });
+  });
+});

package/src/api/quick-action-busy-manager/quick-action-busy-manager.ts

@@ -0,0 +1,50 @@
+import { shellEvents } from "../../events";
+import { PrimariaBroker } from "../broker/primaria-broker";
+
+export interface QuickActionTask {
+  taskId: string;
+}
+
+export abstract class QuickActionBusyManager {
+  abstract addTask(task: QuickActionTask): void;
+  abstract removeTask(taskId: string): void;
+  abstract clearAll(): void;
+  abstract isBusy(): boolean;
+}
+
+export class QuickActionBusyManagerImpl implements QuickActionBusyManager {
+  private tasks: QuickActionTask[] = [];
+
+  constructor(private broker: PrimariaBroker) {}
+
+  public addTask(task: QuickActionTask): void {
+    const index = this.tasks.findIndex((item) => item.taskId === task.taskId);
+    if (index > -1) {
+      return;
+    }
+
+    this.tasks.push(task);
+    this.emitBusyChanged();
+  }
+
+  public removeTask(taskId: string): void {
+    const index = this.tasks.findIndex((item) => item.taskId === taskId);
+    if (index > -1) {
+      this.tasks.splice(index, 1);
+      this.emitBusyChanged();
+    }
+  }
+
+  public isBusy(): boolean {
+    return this.tasks.length > 0;
+  }
+
+  public clearAll(): void {
+    this.tasks = [];
+  }
+
+  private emitBusyChanged(): void {
+    const busy = this.isBusy();
+    this.broker.publish(shellEvents.quickActionBusyChanged, { busy });
+  }
+}