@uxland/primary-shell 5.1.2 → 5.2.1

package/src/handle-views.ts

@@ -1,158 +1,122 @@
 import { shellApi } from "./api/api";
+import { registerPDFVisorMainView } from "./api/pdf-viewer-manager/handle-views";
 import { shellRegions } from "./api/region-manager/regions";
-import { clinicalMonitoringId, pdfViewerId, pocTestEventsId } from "./constants";
-import { shellEvents } from "./events";
+import { pocTestEventsId } from "./constants";
 import { ExitShell } from "./features/exit/request";
-import { ClinicalMonitoring } from "./UI/components/clinical-monitoring/clinical-monitoring";
-import { PdfVisor } from "./UI/components/pdf-visor/pdf-visor";
-import { PocEventsEcap } from "./UI/components/poc-events-ecap/poc-events-ecap";
+import { getPatientCip } from "./features/get-patient-cip/action";
+import { navigateToEcapWithoutClosingWithCip } from "./features/navigate-to-ecap/navigate-without-closing-and-with-cip";
 import { PrimariaNavItem } from "./UI/shared-components/primaria-nav-item/primaria-nav-item";
 import { PrimariaNavTreeMenu } from "./UI/shared-components/primaria-nav-tree-menu/primaria-nav-tree-menu";
 
-const getPatientCip = async (): Promise<string> => {
-  return (await shellApi.broker.send("get_patient_cip")) as string;
-};
-
-const publishEcapNoCloseWithCip = async (eventName: string) => {
-  const CIP = await getPatientCip();
-  shellApi.ecapEventManager.publish(eventName, "NO_TANCAR", { CIP });
-};
-
 const registerUpperNavMenuViews = () => {
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: pocTestEventsId,
+    id: "landing",
     factory: () => {
       const menuItem = new PrimariaNavItem({
-        icon: "bolt",
-        label: "Prova Events ECAP",
+        icon: "home",
+        label: "Pàgina inici",
         callbackFn: () => {
-          shellApi.regionManager.activateMainView(pocTestEventsId);
+          shellApi.broker.send(new ExitShell());
         },
       });
       return Promise.resolve(menuItem);
     },
     sortHint: "000100",
   });
+
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "communication",
+    id: "processes",
     factory: () => {
       const menuItem = new PrimariaNavTreeMenu({
-        icon: "add_box",
-        label: "Comunicació",
+        icon: "account_tree",
+        label: "Vies clíniques",
         actionMenuItems: [
           {
             icon: "open_in_new",
-            label: "SMS",
-            callbackFn: async (): Promise<void> => {
-              const CIP = await getPatientCip();
-              shellApi.ecapEventManager.publish("MISSATGES_DEV", "NO_TANCAR", {
-                CIP: CIP || "",
-                TipusMissatge: "SMS",
-              });
+            label: "ARES",
+            callbackFn: async () => {
+              navigateToEcapWithoutClosingWithCip("PROCES_ATENCIO");
             },
           },
           {
             icon: "open_in_new",
-            label: "Econsulta",
+            label: "Procés Obstètric",
             callbackFn: (): void => {},
           },
           {
             icon: "open_in_new",
-            label: "Mail",
-            callbackFn: (): void => {},
+            label: "Nen sa",
+            callbackFn: async () => {
+              navigateToEcapWithoutClosingWithCip("NEN_SA");
+            },
           },
           {
             icon: "open_in_new",
-            label: "Veu IP",
-            callbackFn: async (): Promise<void> => {
-              publishEcapNoCloseWithCip("VOIP");
+            label: "Odontologia",
+            callbackFn: async () => {
+              navigateToEcapWithoutClosingWithCip("ODONTOLOGO");
             },
           },
           {
             icon: "open_in_new",
-            label: "Videoconsulta",
-            callbackFn: (): void => {},
+            label: "Situació d'especial cura",
+            callbackFn: async () => {
+              navigateToEcapWithoutClosingWithCip("SIT_ESPEC_CURA_DEV");
+            },
           },
         ],
       });
       return Promise.resolve(menuItem);
     },
-  });
-  shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "visits",
-    factory: () => {
-      const menuItem = new PrimariaNavItem({
-        icon: "add_box",
-        label: "Visites",
-        callbackFn: async (): Promise<void> => {
-          publishEcapNoCloseWithCip("CONSULTA_VISITES");
-        },
-      });
-      return Promise.resolve(menuItem);
-    },
-  });
-  shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "it",
-    factory: () => {
-      const menuItem = new PrimariaNavItem({
-        icon: "add_box",
-        label: "IT",
-        callbackFn: async (): Promise<void> => {
-          publishEcapNoCloseWithCip("REV_IT");
-        },
-      });
-      return Promise.resolve(menuItem);
-    },
+    sortHint: "000400",
   });
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
     id: "unique-petition",
     factory: () => {
       const menuItem = new PrimariaNavTreeMenu({
-        icon: "add_box",
-        label: "Petitori únic",
+        icon: "playlist_add",
+        label: "Petitori",
         actionMenuItems: [
           {
             icon: "open_in_new",
             label: "Analítiques",
             callbackFn: async (): Promise<void> => {
-              publishEcapNoCloseWithCip("LABORATORI");
+              navigateToEcapWithoutClosingWithCip("LABORATORI");
             },
           },
           {
             icon: "open_in_new",
-            label: "OC",
+            label: "Ordres Clíniques",
             callbackFn: async (): Promise<void> => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("RESULT_OC");
+              navigateToEcapWithoutClosingWithCip("RESULT_OC");
             },
           },
           {
             icon: "open_in_new",
             label: "OC Exprés",
             callbackFn: async (): Promise<void> => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("OC_EXPRES");
+              navigateToEcapWithoutClosingWithCip("OC_EXPRES");
             },
           },
           {
             icon: "open_in_new",
             label: "Sol·licitud de trasllat",
             callbackFn: async (): Promise<void> => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("TRANSPORT");
+              navigateToEcapWithoutClosingWithCip("TRANSPORT");
             },
           },
         ],
       });
       return Promise.resolve(menuItem);
     },
+    sortHint: "000500",
   });
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
     id: "results-reports",
     factory: () => {
       const menuItem = new PrimariaNavTreeMenu({
-        icon: "add_box",
-        label: "Resultats i informes",
+        icon: "folder_shared",
+        label: "Documents",
         actionMenuItems: [
           {
             icon: "open_in_new",
@@ -163,9 +127,8 @@ const registerUpperNavMenuViews = () => {
             icon: "open_in_new",
             label: "Documents usuari",
             callbackFn: async (): Promise<void> => {
-              const CIP = await getPatientCip();
               setTimeout(() => {
-                publishEcapNoCloseWithCip("CRIDA_DOCS_USU");
+                navigateToEcapWithoutClosingWithCip("CRIDA_DOCS_USU");
               }, 0);
             },
           },
@@ -173,92 +136,91 @@ const registerUpperNavMenuViews = () => {
       });
       return Promise.resolve(menuItem);
     },
+    sortHint: "000700",
   });
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "processes",
+    id: "communication",
     factory: () => {
       const menuItem = new PrimariaNavTreeMenu({
-        icon: "add_box",
-        label: "Processos",
+        icon: "3p",
+        label: "Comunicació",
         actionMenuItems: [
           {
             icon: "open_in_new",
-            label: "ARES",
-            callbackFn: async () => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("PROCES_ATENCIO");
+            label: "SMS",
+            callbackFn: async (): Promise<void> => {
+              const CIP = await getPatientCip(shellApi);
+              shellApi.ecapEventManager.publish("MISSATGES_DEV", "NO_TANCAR", {
+                CIP: CIP || "",
+                TipusMissatge: "SMS",
+              });
             },
           },
           {
             icon: "open_in_new",
-            label: "Nen sa",
-            callbackFn: async () => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("NEN_SA");
-            },
+            label: "Econsulta",
+            callbackFn: (): void => {},
           },
           {
             icon: "open_in_new",
-            label: "Procés Obstètric",
+            label: "Mail",
             callbackFn: (): void => {},
           },
           {
             icon: "open_in_new",
-            label: "Odontologia",
-            callbackFn: async () => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("ODONTOLOGO");
+            label: "Veu IP",
+            callbackFn: async (): Promise<void> => {
+              navigateToEcapWithoutClosingWithCip("VOIP");
             },
           },
           {
             icon: "open_in_new",
-            label: "Situació d'especial cura",
-            callbackFn: async () => {
-              const CIP = await getPatientCip();
-              publishEcapNoCloseWithCip("SIT_ESPEC_CURA_DEV");
-            },
+            label: "Videoconsulta",
+            callbackFn: (): void => {},
           },
         ],
       });
       return Promise.resolve(menuItem);
     },
+    sortHint: "001200",
   });
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "variable activities",
+    id: "visits",
     factory: () => {
       const menuItem = new PrimariaNavItem({
-        icon: "add_box",
-        label: "Activitats variables",
-        callbackFn: async () => {
-          const CIP = await getPatientCip();
-          publishEcapNoCloseWithCip("SIA_DEV");
+        icon: "event",
+        label: "Visites",
+        callbackFn: async (): Promise<void> => {
+          navigateToEcapWithoutClosingWithCip("CONSULTA_VISITES");
         },
       });
       return Promise.resolve(menuItem);
     },
+    sortHint: "001300",
   });
+
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: clinicalMonitoringId,
+    id: "it",
     factory: () => {
       const menuItem = new PrimariaNavItem({
         icon: "add_box",
-        label: "Seguiment clínic",
-        callbackFn: () => {
-          shellApi.regionManager.activateMainView(clinicalMonitoringId);
-          shellApi.broker.publish(shellEvents.openClinicalMonitoringRequested);
+        label: "IT",
+        callbackFn: async (): Promise<void> => {
+          navigateToEcapWithoutClosingWithCip("REV_IT");
         },
       });
       return Promise.resolve(menuItem);
     },
   });
+
   shellApi.regionManager.registerView(shellRegions.navigationMenu, {
-    id: "landing",
+    id: "variable activities",
     factory: () => {
       const menuItem = new PrimariaNavItem({
         icon: "add_box",
-        label: "Pàgina inici",
-        callbackFn: () => {
-          shellApi.broker.send(new ExitShell());
+        label: "Activitats variables",
+        callbackFn: async () => {
+          navigateToEcapWithoutClosingWithCip("SIA_DEV");
         },
       });
       return Promise.resolve(menuItem);
@@ -271,7 +233,7 @@ const registerLowerNavMenuViews = () => {
     id: "configuration-center",
     factory: () => {
       const menuItem = new PrimariaNavItem({
-        icon: "add_box",
+        icon: "settings",
         label: "Centre de configuració",
         callbackFn: () => {
           // shellApi.regionManager.activateView(shellRegions.main, "");
@@ -283,37 +245,11 @@ const registerLowerNavMenuViews = () => {
 };
 
 const registerMainViews = () => {
-  shellApi.regionManager.registerMainView({
-    id: clinicalMonitoringId,
-    factory: () => {
-      const mainItem = new ClinicalMonitoring();
-      return Promise.resolve(mainItem as unknown as HTMLElement);
-    },
-    isDefault: true,
-  });
-  shellApi.regionManager.registerMainView({
-    id: pocTestEventsId,
-    factory: () => {
-      const mainItem = new PocEventsEcap();
-      return Promise.resolve(mainItem as unknown as HTMLElement);
-    },
-  });
-
-  shellApi.regionManager.registerMainView({
-    id: pdfViewerId,
-    factory: () => {
-      const mainItem = new PdfVisor();
-      return Promise.resolve(mainItem as unknown as HTMLElement);
-    },
-  });
+  registerPDFVisorMainView();
 };
 
-export const registerInternalViews = () => {
+export const useInternalViews = () => {
   registerMainViews();
   registerUpperNavMenuViews();
   registerLowerNavMenuViews();
 };
-
-export const activateDefaultView = () => {
-  shellApi.regionManager.activateMainView(clinicalMonitoringId);
-};

package/src/internal-plugins/activity-history/utils/get-unique-values-by-prop-path.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect } from "vitest";
+import { getUniqueObjects } from "./get-unique-values-by-prop-path";
+
+describe("getUniqueObjects", () => {
+  it("should return unique objects by id, keeping the last occurrence", () => {
+    const items = [
+      { data: { id: "1", label: "Item 1" } },
+      { data: { id: "2", label: "Item 2" } },
+      { data: { id: "1", label: "Item 1 (duplicate)" } }, // <- este debe sobrescribir
+    ];
+
+    const result = getUniqueObjects(items, ["data", "id"], ["data", "label"]);
+
+    expect(result).toEqual([
+      { id: "1", description: "Item 1 (duplicate)" }, // 👈 el último
+      { id: "2", description: "Item 2" },
+    ]);
+  });
+
+  it("should skip items with missing id or title", () => {
+    const items = [
+      { data: { id: "1", label: "Valid" } },
+      { data: { id: 2, label: "Invalid ID" } },
+      { data: { id: "3", label: null } },
+    ];
+
+    const result = getUniqueObjects(items, ["data", "id"], ["data", "label"]);
+
+    expect(result).toEqual([{ id: "1", description: "Valid" }]);
+  });
+
+  it("should return an empty array if input is empty", () => {
+    const result = getUniqueObjects([], ["a"], ["b"]);
+    expect(result).toEqual([]);
+  });
+
+  it("should handle deeply nested paths", () => {
+    const items = [
+      { a: { b: { c: { id: "x1", name: "Deep 1" } } } },
+      { a: { b: { c: { id: "x2", name: "Deep 2" } } } },
+    ];
+
+    const result = getUniqueObjects(items, ["a", "b", "c", "id"], ["a", "b", "c", "name"]);
+
+    expect(result).toEqual([
+      { id: "x1", description: "Deep 1" },
+      { id: "x2", description: "Deep 2" },
+    ]);
+  });
+
+  it("should handle invalid path safely", () => {
+    const items = [
+      { a: { b: { id: "1", name: "Good" } } },
+      { x: { y: { id: "2", name: "Missing Path" } } },
+    ];
+
+    const result = getUniqueObjects(items, ["a", "b", "id"], ["a", "b", "name"]);
+
+    expect(result).toEqual([{ id: "1", description: "Good" }]);
+  });
+});

package/src/internal-plugins/activity-history/utils/get-unique-values-by-prop-path.ts

@@ -7,9 +7,9 @@ export function getUniqueObjects<T>(
     items
       .map((item) => ({
         id: propPathId.reduce((acc, key) => acc?.[key], item),
-        title: propPathDescription.reduce((acc, key) => acc?.[key], item),
+        description: propPathDescription.reduce((acc, key) => acc?.[key], item),
       }))
-      .filter((obj) => typeof obj.id === "string" && typeof obj.title === "string")
+      .filter((obj) => typeof obj.id === "string" && typeof obj.description === "string")
       .reduce(
         (map, obj) => map.set(obj.id, obj),
         new Map<string, { id: string; description: string }>(),

package/src/internal-plugins/activity-history/utils/normalize-string.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from "vitest";
+import { normalizeStringToNFD } from "./normalize-string";
+
+describe("normalizeStringToNFD", () => {
+  it("should remove accents and convert to lowercase", () => {
+    expect(normalizeStringToNFD("Árbol")).toBe("arbol");
+    expect(normalizeStringToNFD("ÉLÉPHANT")).toBe("elephant");
+    expect(normalizeStringToNFD("Niño")).toBe("nino");
+    expect(normalizeStringToNFD("Cañón")).toBe("canon");
+  });
+
+  it("should convert only to lowercase if no accents", () => {
+    expect(normalizeStringToNFD("HELLO")).toBe("hello");
+    expect(normalizeStringToNFD("WORLD")).toBe("world");
+  });
+
+  it("should handle empty string", () => {
+    expect(normalizeStringToNFD("")).toBe("");
+  });
+
+  it("should return lowercase even if no normalization is needed", () => {
+    expect(normalizeStringToNFD("AlreadyClean")).toBe("alreadyclean");
+  });
+
+  it("should remove accents from multicharacter words", () => {
+    expect(normalizeStringToNFD("José Álvarez")).toBe("jose alvarez");
+    expect(normalizeStringToNFD("mañana será otro día")).toBe("manana sera otro dia");
+  });
+});

package/src/internal-plugins/activity-history/utils/normalize-string.ts

@@ -1,4 +1,6 @@
-export const normalizeStringToNFD = (text: string) => {
-  const normalized = text.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
-  return normalized ? normalized.toLocaleLowerCase() : text;
+export const normalizeStringToNFD = (text: string | number | boolean | null | undefined) => {
+  if (text == null) return "";
+  const str = String(text);
+  const normalized = str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+  return normalized.toLocaleLowerCase();
 };

package/src/internal-plugins/activity-history/utils/prop-contains-string.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "vitest";
+import { propContainsString } from "./prop-contains-string";
+
+describe("propContainsString", () => {
+  it("should return true if string contains search string (case-insensitive)", () => {
+    expect(propContainsString("Leo Messi", "messi")).toBe(true);
+  });
+
+  it("should return true if string contains search string with accents", () => {
+    expect(propContainsString("José Álvarez", "alvarez")).toBe(true);
+    expect(propContainsString("mañana", "manana")).toBe(true);
+  });
+
+  it("should return true for numeric values", () => {
+    expect(propContainsString(12345, "234")).toBe(true);
+    expect(propContainsString(2024, "202")).toBe(true);
+  });
+
+  it("should return false if no match", () => {
+    expect(propContainsString("Barcelona", "Madrid")).toBe(false);
+  });
+
+  it("should return true if match is exact", () => {
+    expect(propContainsString("Hola", "Hola")).toBe(true);
+    expect(propContainsString("hola", "HOLA")).toBe(true);
+  });
+
+  it("should handle boolean props", () => {
+    expect(propContainsString(true, "tru")).toBe(true);
+    expect(propContainsString(false, "false")).toBe(true);
+    expect(propContainsString(true, "nope")).toBe(false);
+  });
+
+  it("should return false if prop is null or undefined", () => {
+    expect(propContainsString(null, "a")).toBe(false);
+    expect(propContainsString(undefined, "a")).toBe(false);
+  });
+
+  it("should return false if search string is not in prop", () => {
+    expect(propContainsString("casa", "zzz")).toBe(false);
+  });
+
+  it("should be accent-insensitive and case-insensitive", () => {
+    expect(propContainsString("Éxito", "exito")).toBe(true);
+    expect(propContainsString("árbol", "ARBOL")).toBe(true);
+  });
+});

package/src/locales.ts

@@ -4,7 +4,7 @@ import { primariaShellId } from "./constants";
 
 let shellLocaleManager;
 
-export const initializeLocalization = async (api: PrimariaApi) => {
+export const useLocalization = async (api: PrimariaApi) => {
   setLanguage("ca");
   const localeManager = await api.createLocaleManager(locales);
   shellLocaleManager = localeManager;

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

@@ -1 +0,0 @@
-

package/dist/primary/shell/src/UI/components/shell-header/template.d.ts

@@ -1,3 +0,0 @@
-import { ShellHeader } from './shell-header';
-
-export declare const template: (props: ShellHeader) => import('lit').TemplateResult<1>;

package/src/UI/components/index.ts

@@ -1,7 +0,0 @@
-import "./primaria-shell/primaria-shell";
-import "./clinical-monitoring/clinical-monitoring";
-import "../shared-components";
-import "./shell-header/shell-header";
-import "./quick-actions-menu/quick-actions-menu";
-import "../../api/plugin-busy-manager/plugin-busy-list/component";
-import "./pdf-visor/pdf-selector/pdf-selector";