@uxland/primary-shell 7.38.4 → 7.39.0

package/dist/primary/shell/src/api/import-data-manager/component/component.d.ts

@@ -1,15 +1,12 @@
-import { IRegion } from '@uxland/regions';
+import { LitElement } from 'lit';
 import { ConfirmationContentProps } from '../../interaction-service';
-declare const ImportDataManagerModal_base: any;
-export declare class ImportDataManagerModal extends ImportDataManagerModal_base implements ConfirmationContentProps<undefined, undefined> {
+export declare class ImportDataManagerModal extends LitElement implements ConfirmationContentProps<undefined, undefined> {
     data: undefined;
     setResult: (result: undefined) => void;
     setIsValid: (isValid: boolean) => void;
     confirm: () => void;
     cancel: () => void;
-    importDataRegion: IRegion | undefined;
     render(): import('lit').TemplateResult<1>;
     static styles: import('lit').CSSResult;
     _accept: () => void;
 }
-export {};

package/dist/primary/shell/src/api/import-data-manager/import-data-manager-impl.d.ts

@@ -1,12 +1,13 @@
-import { PrimariaImportDataManager } from './import-data-manager';
+import { ImportParams, PrimariaImportDataManager } from './import-data-manager';
 import { PrimariaInteractionService } from '../interaction-service/interaction-service';
 export declare class ImportDataManagerImpl implements PrimariaImportDataManager {
     private interactionService;
     private selectedItems;
     private currentImporterId;
+    private currentImportParams;
     private pluginTexts;
     constructor(interactionService: PrimariaInteractionService);
-    import(importerId: string): Promise<{
+    import(importerId: string, params?: ImportParams): Promise<{
         accepted: boolean;
         data: Record<string, any[]>;
         text: {
@@ -23,5 +24,6 @@ export declare class ImportDataManagerImpl implements PrimariaImportDataManager
         };
     }): void;
     getCurrentImporterId(): string;
+    getCurrentImportParams(): ImportParams | undefined;
     private getConcatenatedText;
 }

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

@@ -1,5 +1,18 @@
+export interface ImportParamsDiagnostic {
+    code: string;
+    catalog: string;
+    description: string;
+}
+export interface ImportParams {
+    /** Optional list of diagnostics the consumer wants the activity-history
+     * importer to filter by. If absent, the diagnostics filter is hidden.
+     * Plugins must map their own diagnostic shape to this common model. */
+    diagnostics?: ImportParamsDiagnostic[];
+    /** Open extension point for future per-importer parameters. */
+    [key: string]: unknown;
+}
 export interface PrimariaImportDataManager {
-    import(importerId: string): Promise<{
+    import(importerId: string, params?: ImportParams): Promise<{
         accepted: boolean;
         data: Record<string, any[]>;
         text: {
@@ -16,4 +29,7 @@ export interface PrimariaImportDataManager {
         };
     }): void;
     getCurrentImporterId(): string;
+    /** Returns the params the current importer was opened with (or undefined
+     * if no import is in progress). */
+    getCurrentImportParams(): ImportParams | undefined;
 }

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

@@ -10,6 +10,7 @@ export declare const shellRegions: {
     clinicalPathwaysSidenav: string;
     petitionerSidenav: string;
     importData: string;
+    importDataActivityHistory: string;
 };
 export declare const clinicalMonitoringRegions: {
     sidebar: string;

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

@@ -16,7 +16,7 @@ export * from './api/interaction-service';
 export { ExitShell } from './features/exit/request';
 export type { ExitShellPayload } from './features/exit/request';
 export type { IUserInfo } from './features/get-user-info/model';
-export type { IActivityHistoryItem } from '../../../plugins/activity-history/src/activity-history-item/domain/model';
+export type { IActivityHistoryItem, IHistoryDataImporterContext, IHistoryDataImporterRules, } from '../../../plugins/activity-history/src/activity-history-item/domain/model';
 export type { InjectAsyncHistoryItemsPayload } from '../../../plugins/activity-history/src/activity-history-item/add/add-async-history-items/request';
 export type { AddHistoryItemPayload } from '../../../plugins/activity-history/src/activity-history-item/add/add-history-item/request';
 export type { AddHistoryItemsPayload } from '../../../plugins/activity-history/src/activity-history-item/add/add-history-items/request';

package/package.json

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

package/src/api/import-data-manager/component/component.ts

@@ -1,25 +1,17 @@
-import { IRegion, region } from "@uxland/regions";
 import { LitElement, css, html, unsafeCSS } from "lit";
 import { customElement } from "lit/decorators.js";
+import { ConfirmationContentProps } from "../../interaction-service";
 import styles from "./styles.css?inline";
 import { template } from "./template";
-import { ConfirmationContentProps } from "../../interaction-service";
-import { PrimariaRegionHost, shellApi } from "../../api";
 
 @customElement("import-data-manager-modal")
-export class ImportDataManagerModal
-  extends PrimariaRegionHost(LitElement)
-  implements ConfirmationContentProps<undefined, undefined>
-{
+export class ImportDataManagerModal extends LitElement implements ConfirmationContentProps<undefined, undefined> {
   data: undefined;
   setResult: (result: undefined) => void;
   setIsValid: (isValid: boolean) => void;
   confirm: () => void;
   cancel: () => void;
 
-  @region({ targetId: "import-data-region", name: shellApi.regionManager.regions.shell.importData })
-  importDataRegion: IRegion | undefined;
-
   render() {
     return html`${template(this)}`;
   }

package/src/api/import-data-manager/component/styles.css

@@ -3,8 +3,8 @@
   display: flex;
   flex-direction: column;
   min-width: 500px;
-  width: 90vw;
-  height: 90vh;
+  width: 95vw;
+  height: 95vh;
   border-radius: var(--dss-radius-sm);
   overflow: hidden;
 }
@@ -27,23 +27,31 @@
 
 .content{
   display: grid;
-  height: 100%;
-  min-height: 1px;
+  flex: 1;
+  min-height: 0;
   grid-template-columns: 1fr 1fr;
-  grid-auto-rows: 1fr;
   gap: 16px;
   padding: 16px;
-  overflow-y: auto;
-  max-height: calc(90vh - 120px);
 }
 
-.content > * {
+.content > primaria-region {
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+}
+
+.content primaria-region > div {
+  width: 100%;
+  height: 100%;
   border: 1px solid var(--color-neutral-200);
   border-radius: 8px;
   padding: 16px;
-  background-color: var(--color-neutral-50);
-  min-height: 200px;
-} 
+  box-sizing: border-box;
+}
+
+.content > primaria-region[name="import-data-region"] > div {
+  overflow-y: auto;
+}
 
 .footer {
   display: flex;

package/src/api/import-data-manager/component/template.ts

@@ -1,24 +1,33 @@
 import { html } from "lit";
 import { translate } from "../../../locales";
+import { shellApi } from "../../api";
 import { ImportDataManagerModal } from "./component";
 
 export const template = (props: ImportDataManagerModal) => {
   return html`
     <div class="container">
-      <!-- <div class="header">
-        <div class="title">
-          <div>${translate("importDataManager.title")}</div>
-        </div>  
-      </div> -->
-        <div class="content" id="import-data-region"></div>
-        <div class="footer">
-    <dss-button label="${translate("importDataManager.actions.cancel")}" @click="${() => {
-        props.cancel();
-      }}" size="md" variant="secondary"></dss-button>
-      <dss-button label="${translate("importDataManager.actions.import")}" @click="${() => {
-        props._accept();
-      }}" size="md" variant="primary"></dss-button>
-  </div>
+      <div class="content">
+        <primaria-region name="${shellApi.regionManager.regions.shell.importDataActivityHistory}"></primaria-region>
+        <primaria-region name="${shellApi.regionManager.regions.shell.importData}"></primaria-region>
+      </div>
+      <div class="footer">
+        <dss-button
+          label="${translate("importDataManager.actions.cancel")}"
+          @click="${() => {
+            props.cancel();
+          }}"
+          size="md"
+          variant="secondary"
+        ></dss-button>
+        <dss-button
+          label="${translate("importDataManager.actions.import")}"
+          @click="${() => {
+            props._accept();
+          }}"
+          size="md"
+          variant="primary"
+        ></dss-button>
+      </div>
     </div>
   `;
 };

package/src/api/import-data-manager/import-data-manager-impl.test.ts

@@ -1,6 +1,11 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { ImportDataManagerImpl } from './import-data-manager-impl';
-import { PrimariaInteractionService, ConfirmationOptions, ConfirmComponentUI, ConfirmationResult } from '../interaction-service/interaction-service';
+import { ImportDataManagerImpl } from "./import-data-manager-impl";
+import {
+  PrimariaInteractionService,
+  ConfirmationOptions,
+  ConfirmComponentUI,
+  ConfirmationResult,
+} from "../interaction-service/interaction-service";
 
 // Mock del PrimariaInteractionService
 class MockInteractionService extends PrimariaInteractionService {
@@ -19,15 +24,12 @@ class MockInteractionService extends PrimariaInteractionService {
     return Promise.resolve(this.mockConfirmResult as ConfirmationResult<TResult | undefined>);
   }
 
-  async confirmMessage(
-    _message: string,
-    _options?: ConfirmationOptions | undefined,
-  ): Promise<ConfirmationResult> {
+  async confirmMessage(_message: string, _options?: ConfirmationOptions | undefined): Promise<ConfirmationResult> {
     return Promise.resolve({ confirmed: this.mockConfirmResult.confirmed, result: undefined });
   }
 }
 
-describe('ImportDataManagerImpl implements PrimariaImportDataManager', () => {
+describe("ImportDataManagerImpl implements PrimariaImportDataManager", () => {
   let importDataManager: ImportDataManagerImpl;
   let mockInteractionService: MockInteractionService;
 
@@ -36,28 +38,28 @@ describe('ImportDataManagerImpl implements PrimariaImportDataManager', () => {
     importDataManager = new ImportDataManagerImpl(mockInteractionService);
   });
 
-  describe('getCurrentImporterId', () => {
-    it('should return empty string initially', () => {
-      expect(importDataManager.getCurrentImporterId()).toBe('');
+  describe("getCurrentImporterId", () => {
+    it("should return empty string initially", () => {
+      expect(importDataManager.getCurrentImporterId()).toBe("");
     });
 
-    it('should return the current importer ID after calling import', async () => {
+    it("should return the current importer ID after calling import", async () => {
       mockInteractionService.setMockConfirmResult({ confirmed: true });
 
-      const promise = importDataManager.import('test-importer-123');
-      expect(importDataManager.getCurrentImporterId()).toBe('test-importer-123');
+      const promise = importDataManager.import("test-importer-123");
+      expect(importDataManager.getCurrentImporterId()).toBe("test-importer-123");
 
       await promise;
-      expect(importDataManager.getCurrentImporterId()).toBe('');
+      expect(importDataManager.getCurrentImporterId()).toBe("");
     });
   });
 
-  describe('selectItems', () => {
-    it('should store selected items correctly', () => {
+  describe("selectItems", () => {
+    it("should store selected items correctly", () => {
       const payload = {
-        pluginId: 'test-plugin',
-        data: [{ id: '1', name: 'Test Item' }],
-        text: { raw: 'Test Item', html: '<p>Test Item</p>' }
+        pluginId: "test-plugin",
+        data: [{ id: "1", name: "Test Item" }],
+        text: { raw: "Test Item", html: "<p>Test Item</p>" },
       };
 
       importDataManager.selectItems(payload);
@@ -66,17 +68,17 @@ describe('ImportDataManagerImpl implements PrimariaImportDataManager', () => {
       expect(() => importDataManager.selectItems(payload)).not.toThrow();
     });
 
-    it('should handle multiple plugin selections', () => {
+    it("should handle multiple plugin selections", () => {
       const payload1 = {
-        pluginId: 'plugin-1',
-        data: [{ id: '1', name: 'Item 1' }],
-        text: { raw: 'Item 1', html: '<p>Item 1</p>' }
+        pluginId: "plugin-1",
+        data: [{ id: "1", name: "Item 1" }],
+        text: { raw: "Item 1", html: "<p>Item 1</p>" },
       };
 
       const payload2 = {
-        pluginId: 'plugin-2',
-        data: [{ id: '2', name: 'Item 2' }],
-        text: { raw: 'Item 2', html: '<p>Item 2</p>' }
+        pluginId: "plugin-2",
+        data: [{ id: "2", name: "Item 2" }],
+        text: { raw: "Item 2", html: "<p>Item 2</p>" },
       };
 
       expect(() => {
@@ -85,17 +87,17 @@ describe('ImportDataManagerImpl implements PrimariaImportDataManager', () => {
       }).not.toThrow();
     });
 
-    it('should overwrite previous selections from same plugin', () => {
+    it("should overwrite previous selections from same plugin", () => {
       const payload1 = {
-        pluginId: 'test-plugin',
-        data: [{ id: '1', name: 'First Item' }],
-        text: { raw: 'First Item', html: '<p>First Item</p>' }
+        pluginId: "test-plugin",
+        data: [{ id: "1", name: "First Item" }],
+        text: { raw: "First Item", html: "<p>First Item</p>" },
       };
 
       const payload2 = {
-        pluginId: 'test-plugin',
-        data: [{ id: '2', name: 'Second Item' }],
-        text: { raw: 'Second Item', html: '<p>Second Item</p>' }
+        pluginId: "test-plugin",
+        data: [{ id: "2", name: "Second Item" }],
+        text: { raw: "Second Item", html: "<p>Second Item</p>" },
       };
 
       expect(() => {
@@ -105,178 +107,180 @@ describe('ImportDataManagerImpl implements PrimariaImportDataManager', () => {
     });
   });
 
-  describe('import', () => {
-    it('should return accepted result with concatenated text when confirmed', async () => {
+  describe("import", () => {
+    it("should return accepted result with concatenated text when confirmed", async () => {
       mockInteractionService.setMockConfirmResult({ confirmed: true });
 
       // Mock the import to allow setting up items during the import process
       const originalConfirm = mockInteractionService.confirm.bind(mockInteractionService);
-      vi.spyOn(mockInteractionService, 'confirm').mockImplementation(async (...args) => {
+      vi.spyOn(mockInteractionService, "confirm").mockImplementation(async (...args) => {
         // Setup some selected items during the import process (simulating user interaction)
         importDataManager.selectItems({
-          pluginId: 'plugin-1',
-          data: [{ id: '1', name: 'Item 1' }],
-          text: { raw: 'Item 1', html: '<p>Item 1</p>' }
+          pluginId: "plugin-1",
+          data: [{ id: "1", name: "Item 1" }],
+          text: { raw: "Item 1", html: "<p>Item 1</p>" },
         });
 
         importDataManager.selectItems({
-          pluginId: 'plugin-2',
-          data: [{ id: '2', name: 'Item 2' }],
-          text: { raw: 'Item 2', html: '<p>Item 2</p>' }
+          pluginId: "plugin-2",
+          data: [{ id: "2", name: "Item 2" }],
+          text: { raw: "Item 2", html: "<p>Item 2</p>" },
         });
 
         return originalConfirm(...args);
       });
 
-      const result = await importDataManager.import('test-importer');
+      const result = await importDataManager.import("test-importer");
 
       expect(result.accepted).toBe(true);
       expect(result.data).toEqual({
-        'plugin-1': [{ id: '1', name: 'Item 1' }],
-        'plugin-2': [{ id: '2', name: 'Item 2' }]
+        "plugin-1": [{ id: "1", name: "Item 1" }],
+        "plugin-2": [{ id: "2", name: "Item 2" }],
       });
-      expect(result.text.raw).toBe('Item 1\n\nItem 2');
-      expect(result.text.html).toBe('<p>Item 1</p><br><br><p>Item 2</p>');
+      expect(result.text.raw).toBe("Item 1\n\nItem 2");
+      expect(result.text.html).toBe("<p>Item 1</p><br><br><p>Item 2</p>");
     });
 
-    it('should return cancelled result with empty data when not confirmed', async () => {
+    it("should return cancelled result with empty data when not confirmed", async () => {
       mockInteractionService.setMockConfirmResult({ confirmed: false });
 
       // Setup some selected items
       importDataManager.selectItems({
-        pluginId: 'plugin-1',
-        data: [{ id: '1', name: 'Item 1' }],
-        text: { raw: 'Item 1', html: '<p>Item 1</p>' }
+        pluginId: "plugin-1",
+        data: [{ id: "1", name: "Item 1" }],
+        text: { raw: "Item 1", html: "<p>Item 1</p>" },
       });
 
-      const result = await importDataManager.import('test-importer');
+      const result = await importDataManager.import("test-importer");
 
       expect(result.accepted).toBe(false);
       expect(result.data).toEqual({});
-      expect(result.text.raw).toBe('');
-      expect(result.text.html).toBe('');
+      expect(result.text.raw).toBe("");
+      expect(result.text.html).toBe("");
     });
 
-    it('should clear state after successful import', async () => {
+    it("should clear state after successful import", async () => {
       mockInteractionService.setMockConfirmResult({ confirmed: true });
 
       // Setup selected items
       importDataManager.selectItems({
-        pluginId: 'test-plugin',
-        data: [{ id: '1', name: 'Test Item' }],
-        text: { raw: 'Test Item', html: '<p>Test Item</p>' }
+        pluginId: "test-plugin",
+        data: [{ id: "1", name: "Test Item" }],
+        text: { raw: "Test Item", html: "<p>Test Item</p>" },
       });
 
-      await importDataManager.import('test-importer');
+      await importDataManager.import("test-importer");
 
       // Verify state is cleared
-      expect(importDataManager.getCurrentImporterId()).toBe('');
+      expect(importDataManager.getCurrentImporterId()).toBe("");
 
       // Verify that subsequent import returns empty data
-      const result = await importDataManager.import('another-importer');
+      const result = await importDataManager.import("another-importer");
       expect(result.data).toEqual({});
-      expect(result.text.raw).toBe('');
-      expect(result.text.html).toBe('');
+      expect(result.text.raw).toBe("");
+      expect(result.text.html).toBe("");
     });
 
-    it('should clear state after cancelled import', async () => {
+    it("should clear state after cancelled import", async () => {
       mockInteractionService.setMockConfirmResult({ confirmed: false });
 
       // Setup selected items
       importDataManager.selectItems({
-        pluginId: 'test-plugin',
-        data: [{ id: '1', name: 'Test Item' }],
-        text: { raw: 'Test Item', html: '<p>Test Item</p>' }
+        pluginId: "test-plugin",
+        data: [{ id: "1", name: "Test Item" }],
+        text: { raw: "Test Item", html: "<p>Test Item</p>" },
       });
 
-      await importDataManager.import('test-importer');
+      await importDataManager.import("test-importer");
 
       // Verify state is cleared
-      expect(importDataManager.getCurrentImporterId()).toBe('');
+      expect(importDataManager.getCurrentImporterId()).toBe("");
     });
 
-    it('should handle empty selections', async () => {
+    it("should handle empty selections", async () => {
       mockInteractionService.setMockConfirmResult({ confirmed: true });
 
-      const result = await importDataManager.import('test-importer');
+      const result = await importDataManager.import("test-importer");
 
       expect(result.accepted).toBe(true);
       expect(result.data).toEqual({});
-      expect(result.text.raw).toBe('');
-      expect(result.text.html).toBe('');
+      expect(result.text.raw).toBe("");
+      expect(result.text.html).toBe("");
     });
 
-    it('should handle error and clear state', async () => {
+    it("should handle error and clear state", async () => {
       mockInteractionService.setMockConfirmResult({ confirmed: true });
 
       // Mock the interaction service to throw an error
-      vi.spyOn(mockInteractionService, 'confirm').mockRejectedValueOnce(new Error('Test error'));
+      vi.spyOn(mockInteractionService, "confirm").mockRejectedValueOnce(new Error("Test error"));
 
       // Setup selected items
       importDataManager.selectItems({
-        pluginId: 'test-plugin',
-        data: [{ id: '1', name: 'Test Item' }],
-        text: { raw: 'Test Item', html: '<p>Test Item</p>' }
+        pluginId: "test-plugin",
+        data: [{ id: "1", name: "Test Item" }],
+        text: { raw: "Test Item", html: "<p>Test Item</p>" },
       });
 
-      await expect(importDataManager.import('test-importer')).rejects.toThrow('Test error');
+      await expect(importDataManager.import("test-importer")).rejects.toThrow("Test error");
 
       // Verify state is cleared even after error
-      expect(importDataManager.getCurrentImporterId()).toBe('');
+      expect(importDataManager.getCurrentImporterId()).toBe("");
     });
 
-    it('should handle text concatenation correctly with multiple plugins', async () => {
+    it("should handle text concatenation correctly with multiple plugins", async () => {
       mockInteractionService.setMockConfirmResult({ confirmed: true });
 
       // Mock the import to allow setting up items during the import process
       const originalConfirm = mockInteractionService.confirm.bind(mockInteractionService);
-      vi.spyOn(mockInteractionService, 'confirm').mockImplementation(async (...args) => {
+      vi.spyOn(mockInteractionService, "confirm").mockImplementation(async (...args) => {
         importDataManager.selectItems({
-          pluginId: 'diagnostics',
-          data: [{ code: 'E11.9', name: 'Diabetes' }],
-          text: { raw: 'E11.9 - Diabetes', html: '<p><strong>E11.9</strong> - Diabetes</p>' }
+          pluginId: "diagnostics",
+          data: [{ code: "E11.9", name: "Diabetes" }],
+          text: { raw: "E11.9 - Diabetes", html: "<p><strong>E11.9</strong> - Diabetes</p>" },
         });
 
         importDataManager.selectItems({
-          pluginId: 'allergies',
-          data: [{ name: 'Penicillin', severity: 'High' }],
-          text: { raw: 'Penicillin - High severity', html: '<p><strong>Penicillin</strong> - High severity</p>' }
+          pluginId: "allergies",
+          data: [{ name: "Penicillin", severity: "High" }],
+          text: { raw: "Penicillin - High severity", html: "<p><strong>Penicillin</strong> - High severity</p>" },
         });
 
         return originalConfirm(...args);
       });
 
-      const result = await importDataManager.import('test-importer');
+      const result = await importDataManager.import("test-importer");
 
-      expect(result.text.raw).toBe('E11.9 - Diabetes\n\nPenicillin - High severity');
-      expect(result.text.html).toBe('<p><strong>E11.9</strong> - Diabetes</p><br><br><p><strong>Penicillin</strong> - High severity</p>');
+      expect(result.text.raw).toBe("E11.9 - Diabetes\n\nPenicillin - High severity");
+      expect(result.text.html).toBe(
+        "<p><strong>E11.9</strong> - Diabetes</p><br><br><p><strong>Penicillin</strong> - High severity</p>",
+      );
     });
 
-    it('should handle empty text values in concatenation', async () => {
+    it("should handle empty text values in concatenation", async () => {
       mockInteractionService.setMockConfirmResult({ confirmed: true });
 
       // Mock the import to allow setting up items during the import process
       const originalConfirm = mockInteractionService.confirm.bind(mockInteractionService);
-      vi.spyOn(mockInteractionService, 'confirm').mockImplementation(async (...args) => {
+      vi.spyOn(mockInteractionService, "confirm").mockImplementation(async (...args) => {
         importDataManager.selectItems({
-          pluginId: 'plugin-1',
-          data: [{ id: '1' }],
-          text: { raw: '', html: '' }
+          pluginId: "plugin-1",
+          data: [{ id: "1" }],
+          text: { raw: "", html: "" },
         });
 
         importDataManager.selectItems({
-          pluginId: 'plugin-2',
-          data: [{ id: '2' }],
-          text: { raw: 'Item 2', html: '<p>Item 2</p>' }
+          pluginId: "plugin-2",
+          data: [{ id: "2" }],
+          text: { raw: "Item 2", html: "<p>Item 2</p>" },
         });
 
         return originalConfirm(...args);
       });
 
-      const result = await importDataManager.import('test-importer');
+      const result = await importDataManager.import("test-importer");
 
-      expect(result.text.raw).toBe('Item 2');
-      expect(result.text.html).toBe('<p>Item 2</p>');
+      expect(result.text.raw).toBe("Item 2");
+      expect(result.text.html).toBe("<p>Item 2</p>");
     });
   });
-});
+});