@uxland/primary-shell 5.1.2 → 5.2.0

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";