@uxland/primary-shell 7.41.2 → 7.41.4

package/dist/primary/shell/src/UI/shared-components/primaria-region/primaria-region.d.ts

@@ -60,6 +60,31 @@ export declare class PrimariaRegion extends PrimariaRegion_base {
      * Sets up the region definition before the parent connectedCallback runs.
      */
     connectedCallback(): void;
+    /**
+     * Mixin hook fired after `createRegions` finishes.
+     *
+     * Hydrates the freshly-created region with every view that has already been
+     * registered for this region name via `regionManager.registerViewWithRegion`.
+     * `registerViewWithRegion` only forwards to regions that exist at the moment
+     * of the call, so a plugin that registers once at `initialize` would lose
+     * its view every time the region is destroyed and re-created (e.g. when a
+     * drawer that hosts the region is closed and reopened). Pulling from the
+     * registry here makes injection transparent: any plugin can register once
+     * and any region with that name auto-populates.
+     */
+    regionsCreated(_regions: unknown): void;
+    /**
+     * Called when the component is removed from the DOM.
+     *
+     * The base mixin's `disconnectedCallback` removes the region from the manager
+     * but does NOT clear `this.region`, so on a later reconnect the mixin's
+     * `createRegions` sees `isNil(this.region) === false` and skips re-creating
+     * the region. That breaks the "drawer opens, closes, opens again" flow:
+     * the second open would render the host but never receive the plugin's
+     * view. Clear the reference (and drop the orphan container) so the next
+     * connect rebuilds everything from scratch.
+     */
+    disconnectedCallback(): void;
     /**
      * Called before the component updates.
      * Updates the region definition if the name changes.

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

@@ -1,9 +1,9 @@
 import { LitElement } from 'lit';
-import { PluginBusyTask } from '../plugin-busy-manager';
+import { PluginTask } from '../plugin-busy-manager';
 export declare class PluginBusyList extends LitElement {
     static styles: import('lit').CSSResult;
     render(): import('lit').TemplateResult<1>;
     data: {
-        busyTasks: PluginBusyTask[];
+        busyTasks: PluginTask[];
     };
 }

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

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

package/package.json

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

package/src/UI/shared-components/primaria-region/primaria-region.ts

@@ -1,6 +1,6 @@
 import { LitElement, html } from "lit";
 import { property } from "lit/decorators.js";
-import { IRegion } from "@uxland/regions";
+import { IRegion, regionManager } from "@uxland/regions";
 import { PrimariaRegionHost } from "../../../api/api";
 import { regionsProperty } from "@uxland/regions/region-decorator";
 
@@ -130,6 +130,47 @@ export class PrimariaRegion extends PrimariaRegionHost(LitElement) {
     }
   }
 
+  /**
+   * Mixin hook fired after `createRegions` finishes.
+   *
+   * Hydrates the freshly-created region with every view that has already been
+   * registered for this region name via `regionManager.registerViewWithRegion`.
+   * `registerViewWithRegion` only forwards to regions that exist at the moment
+   * of the call, so a plugin that registers once at `initialize` would lose
+   * its view every time the region is destroyed and re-created (e.g. when a
+   * drawer that hosts the region is closed and reopened). Pulling from the
+   * registry here makes injection transparent: any plugin can register once
+   * and any region with that name auto-populates.
+   */
+  regionsCreated(_regions: unknown): void {
+    if (!this.region || !this.name) return;
+    const registered = regionManager.getRegisteredViews(this.name) ?? [];
+    for (const { key, view } of registered) {
+      if (this.region.containsView(key)) continue;
+      this.region.addView(key, view).catch((e) => {
+        console.warn(`primaria-region(${this.name}): failed to addView "${key}"`, e);
+      });
+    }
+  }
+
+  /**
+   * Called when the component is removed from the DOM.
+   *
+   * The base mixin's `disconnectedCallback` removes the region from the manager
+   * but does NOT clear `this.region`, so on a later reconnect the mixin's
+   * `createRegions` sees `isNil(this.region) === false` and skips re-creating
+   * the region. That breaks the "drawer opens, closes, opens again" flow:
+   * the second open would render the host but never receive the plugin's
+   * view. Clear the reference (and drop the orphan container) so the next
+   * connect rebuilds everything from scratch.
+   */
+  disconnectedCallback(): void {
+    super.disconnectedCallback();
+    this.region = undefined;
+    const targetId = `${this.name}-container`;
+    this.querySelector(`#${targetId}`)?.remove();
+  }
+
   /**
    * Called before the component updates.
    * Updates the region definition if the name changes.

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

@@ -1,5 +1,5 @@
 import { LitElement, css, html, unsafeCSS } from "lit";
-import { PluginBusyTask } from "../plugin-busy-manager";
+import { PluginTask } from "../plugin-busy-manager";
 import styles from "./styles.css?inline";
 import { template } from "./template";
 
@@ -12,5 +12,5 @@ export class PluginBusyList extends LitElement {
     return html`${template(this)}`;
   }
 
-  data: { busyTasks: PluginBusyTask[] };
+  data: { busyTasks: PluginTask[] };
 }

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

@@ -1,14 +1,14 @@
 import { html } from "lit";
-import { PluginBusyList } from "./component";
-import { PluginBusyTask } from "../plugin-busy-manager";
 import { translate } from "../../../locales";
+import { PluginTask } from "../plugin-busy-manager";
+import { PluginBusyList } from "./component";
 
 export const template = (props: PluginBusyList) => html`
     <div class="container">
         <div class="title">${translate("busyManager.title")}</div>
         <div class="list">
             ${props.data?.busyTasks?.map(
-              (item: PluginBusyTask) => html`
+              (item: PluginTask) => html`
                 <div class="plugin-busy-item">
                     <dss-typography tag="div" variant="body-3" fontweight="regular">
                         ${item.taskDescription}

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

@@ -1,9 +1,10 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { PrimariaApi } from "../../api/api";
+import { PluginBusyList } from "../../api/plugin-busy-manager/plugin-busy-list/component";
+import { disposeShell, raiseCloseEvent, raiseCustomCloseEvent } from "../../disposer";
+import { disposePlugins } from "../../handle-plugins";
 import { ExitShellHandler } from "./handler";
 import { ExitShell } from "./request";
-import { disposePlugins } from "../../handle-plugins";
-import { disposeShell, raiseCloseEvent, raiseCustomCloseEvent } from "../../disposer";
-import { PrimariaApi } from "../../api/api";
 
 vi.mock("../../handle-plugins", () => ({
   disposePlugins: vi.fn(),
@@ -18,7 +19,13 @@ vi.mock("../../disposer", () => ({
 const createMockApi = (): PrimariaApi =>
   ({
     exitGuardManager: {
-      canExit: vi.fn(),
+      canExit: vi.fn().mockResolvedValue(true),
+    },
+    pluginBusyManager: {
+      getTasks: vi.fn().mockReturnValue([]),
+    },
+    interactionService: {
+      confirm: vi.fn(),
     },
     notificationService: {
       error: vi.fn(),
@@ -120,4 +127,57 @@ describe("ExitShellHandler", () => {
     expect(raiseCloseEvent).toHaveBeenCalled();
     expect(raiseCustomCloseEvent).not.toHaveBeenCalled();
   });
+
+  describe("legacy pluginBusyManager fallback", () => {
+    it("asks for confirmation when canExit allows but legacy busy tasks exist", async () => {
+      const busyTasks = [{ taskId: "t1", taskDescription: "saving draft" }];
+      const message = { ecapEvent: {} } as ExitShell;
+      (mockApi.exitGuardManager.canExit as any).mockResolvedValue(true);
+      (mockApi.pluginBusyManager.getTasks as any).mockReturnValue(busyTasks);
+      (mockApi.interactionService.confirm as any).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("aborts the exit when the legacy busy-task confirmation is declined", async () => {
+      const busyTasks = [{ taskId: "t1", taskDescription: "saving draft" }];
+      const message = { ecapEvent: {} } as ExitShell;
+      (mockApi.exitGuardManager.canExit as any).mockResolvedValue(true);
+      (mockApi.pluginBusyManager.getTasks as any).mockReturnValue(busyTasks);
+      (mockApi.interactionService.confirm as any).mockResolvedValue({ confirmed: false });
+
+      await handler.handle(message);
+
+      expect(mockApi.interactionService.confirm).toHaveBeenCalled();
+      expect(disposePlugins).not.toHaveBeenCalled();
+      expect(disposeShell).not.toHaveBeenCalled();
+      expect(raiseCustomCloseEvent).not.toHaveBeenCalled();
+      expect(raiseCloseEvent).not.toHaveBeenCalled();
+    });
+
+    it("does not consult legacy busy tasks when an ExitGuard already vetoed the exit", async () => {
+      const message = { ecapEvent: {} } as ExitShell;
+      (mockApi.exitGuardManager.canExit as any).mockResolvedValue(false);
+
+      await handler.handle(message);
+
+      expect(mockApi.pluginBusyManager.getTasks).not.toHaveBeenCalled();
+      expect(mockApi.interactionService.confirm).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/features/exit/handler.ts

@@ -1,10 +1,12 @@
-import { PrimariaApi } from "../../api/api";
-import { TYPES } from "../../infrastructure/ioc/types";
 import { inject } from "inversify";
-import { ExitShell } from "./request";
+import { PrimariaApi } from "../../api/api";
+import { PluginBusyList } from "../../api/plugin-busy-manager/plugin-busy-list/component";
+import { PluginTask } from "../../api/plugin-busy-manager/plugin-busy-manager";
 import { disposeShell, raiseCloseEvent, raiseCustomCloseEvent } from "../../disposer";
 import { disposePlugins } from "../../handle-plugins";
+import { TYPES } from "../../infrastructure/ioc/types";
 import { translate } from "../../locales";
+import { ExitShell } from "./request";
 
 export class ExitShellHandler {
   constructor(@inject(TYPES.primaryApi) private api: PrimariaApi) {}
@@ -15,6 +17,14 @@ export class ExitShellHandler {
       const canExit = await this.api.exitGuardManager.canExit();
       if (!canExit) return;
 
+      // Backwards-compat: external plugins still using the deprecated pluginBusyManager
+      // would otherwise lose their exit-confirmation modal. Remove once all consumers migrate.
+      const busyTasks = this.api.pluginBusyManager.getTasks();
+      if (busyTasks.length > 0) {
+        const { confirmed } = await this.askForClose(busyTasks);
+        if (!confirmed) return;
+      }
+
       // 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
@@ -32,6 +42,19 @@ export class ExitShellHandler {
     return new Promise<void>((resolve) => setTimeout(resolve, ms));
   }
 
+  private askForClose(busyTasks: PluginTask[]) {
+    return this.api.interactionService.confirm(
+      { busyTasks },
+      { component: PluginBusyList },
+      {
+        title: translate("actions.askExit"),
+        state: "error",
+        confirmButtonText: "Sí",
+        cancelButtonText: "No",
+      },
+    );
+  }
+
   private emitClose(exitEvent?: ExitShell): void {
     if (exitEvent) {
       raiseCustomCloseEvent(exitEvent);