@uxland/primary-shell 5.3.7 → 5.3.9

package/src/internal-plugins/activity-history/activity-history-item/list/group-history-items/group-history-items.test.ts

@@ -1,238 +1,94 @@
 import { describe, it, expect } from "vitest";
-import { groupActivityHistoryItems } from "./group-history-items";
 import { IActivityHistoryItem } from "../../domain/model";
+import { groupActivityHistoryItems } from "./group-history-items";
+
+const baseItem = (overrides: Partial<IActivityHistoryItem>): IActivityHistoryItem => ({
+  id: "1",
+  date: new Date().toISOString(),
+  professional: { id: "p1", role: { id: "r1" }, speciality: { id: "s1" } },
+  ep: { id: "ep1" },
+  up: { id: "up1" },
+  center: { id: "c1" },
+  service: { id: "sv1" },
+  diagnostics: [],
+  ...overrides,
+});
+
 describe("groupActivityHistoryItems", () => {
-  it("should group items by visit and then by diagnostics", () => {
-    const items: IActivityHistoryItem[] = [
-      {
-        id: "1",
-        date: "2024-07-04T08:00:00Z",
-        professional: {
-          name: "1",
-          id: "1",
-          role: { id: "1", description: "1" },
-          speciality: { id: "1", description: "1" },
-        },
-        relevant: true,
-        diagnostics: [{ id: "d1", description: "d1" }],
-        center: { id: "c1", description: "c1" },
-        up: { id: "up1", description: "up1" },
-        ep: { id: "ep1", description: "ep1" },
-        service: { id: "s1", description: "s1" },
-      },
-      {
-        id: "2",
-        date: "2024-07-04T10:00:00Z",
-        professional: {
-          name: "1",
-          id: "1",
-          role: { id: "1", description: "1" },
-          speciality: { id: "1", description: "1" },
-        },
-        relevant: true,
-        diagnostics: [{ id: "d1", description: "d1" }],
-        center: { id: "c1", description: "c1" },
-        up: { id: "up1", description: "up1" },
-        ep: { id: "ep1", description: "ep1" },
-        service: { id: "s1", description: "s1" },
-      },
-      {
-        id: "3",
-        date: "2024-07-04T08:00:00Z",
-        professional: {
-          name: "1",
-          id: "2",
-          role: { id: "2", description: "2" },
-          speciality: { id: "2", description: "2" },
-        },
-        relevant: true,
-        diagnostics: [{ id: "d2", description: "d2" }],
-        center: { id: "c2", description: "c2" },
-        up: { id: "up2", description: "up2" },
-        ep: { id: "ep2", description: "ep2" },
-        service: { id: "s2", description: "s2" },
-      },
-      {
-        id: "4",
-        date: "2024-07-04T08:00:00Z",
-        professional: {
-          name: "1",
-          id: "1",
-          role: { id: "1", description: "1" },
-          speciality: { id: "1", description: "1" },
-        },
-        relevant: true,
-        diagnostics: [],
-        center: { id: "c1", description: "c1" },
-        up: { id: "up1", description: "up1" },
-        ep: { id: "ep1", description: "ep1" },
-        service: { id: "s1", description: "s1" },
-      },
+  it("agrupa en un solo grupo por misma visita y dentro de 8h", () => {
+    const now = new Date();
+    const items = [
+      baseItem({ id: "1", date: now.toISOString() }),
+      baseItem({ id: "2", date: new Date(now.getTime() + 2 * 3600 * 1000).toISOString() }),
     ];
 
     const result = groupActivityHistoryItems(items);
 
-    expect(result.length).toBe(2);
-
-    const group1 = result.find((g) => g.items.some((i) => i.id === "4"));
-    const group2 = result.find((g) =>
-      g.subGroups?.some((sg) => sg.items.some((i) => i.id === "3")),
-    );
-
-    expect(group1).toBeDefined();
-    expect(group2).toBeDefined();
-
-    if (group1) {
-      expect(group1.items.length).toBe(1); // Only item with no diagnostics should be here
-      expect(group1.items[0].id).toBe("4");
-
-      expect(group1.subGroups?.length).toBe(1);
-      const subGroup1 = group1.subGroups?.[0];
-      expect(subGroup1?.items.length).toBe(2);
-      expect(subGroup1?.items.some((i) => i.id === "1")).toBe(true);
-      expect(subGroup1?.items.some((i) => i.id === "2")).toBe(true);
-    }
-
-    if (group2) {
-      expect(group2.items.length).toBe(0); // No items should be here
-      expect(group2.subGroups?.length).toBe(1);
-      const subGroup2 = group2.subGroups?.[0];
-      expect(subGroup2?.items.length).toBe(1);
-      expect(subGroup2?.items.some((i) => i.id === "3")).toBe(true);
-    }
+    expect(result).toHaveLength(1);
+    expect(result[0].sameVisit).toBe(true);
+    expect(result[0].items).toHaveLength(2);
   });
 
-  it("should create separate groups for different visits", () => {
-    const items: IActivityHistoryItem[] = [
-      {
+  it("agrupa sin misma visita pero dentro de 8h", () => {
+    const now = new Date();
+    const items = [
+      baseItem({
         id: "1",
-        date: "2024-07-04T08:00:00Z",
-        professional: {
-          name: "1",
-          id: "1",
-          role: { id: "1", description: "1" },
-          speciality: { id: "1", description: "1" },
-        },
-        relevant: true,
-        diagnostics: [{ id: "d1", description: "d1" }],
-        center: { id: "c1", description: "c1" },
-        up: { id: "up1", description: "up1" },
-        ep: { id: "ep1", description: "ep1" },
-        service: { id: "s1", description: "s1" },
-      },
-      {
+        date: now.toISOString(),
+        professional: { id: "p1", role: { id: "r1" }, speciality: { id: "s1" } },
+      }),
+      baseItem({
         id: "2",
-        date: "2024-07-05T08:00:00Z",
-        professional: {
-          name: "1",
-          id: "1",
-          role: { id: "1", description: "1" },
-          speciality: { id: "1", description: "1" },
-        },
-        relevant: true,
-        diagnostics: [{ id: "d1", description: "d1" }],
-        center: { id: "c1", description: "c1" },
-        up: { id: "up1", description: "up1" },
-        ep: { id: "ep1", description: "ep1" },
-        service: { id: "s1", description: "s1" },
-      },
+        date: new Date(now.getTime() + 2 * 3600 * 1000).toISOString(),
+        professional: { id: "p2", role: { id: "r2" }, speciality: { id: "s2" } },
+      }),
     ];
 
     const result = groupActivityHistoryItems(items);
 
-    expect(result.length).toBe(2);
-
-    const group1 = result.find((g) =>
-      g.subGroups?.some((sg) => sg.items.some((i) => i.id === "1")),
-    );
-    const group2 = result.find((g) =>
-      g.subGroups?.some((sg) => sg.items.some((i) => i.id === "2")),
-    );
-
-    expect(group1).toBeDefined();
-    expect(group2).toBeDefined();
-
-    if (group1) {
-      expect(group1.items.length).toBe(0);
-      expect(group1.subGroups?.length).toBe(1);
-      const subGroup1 = group1.subGroups?.[0];
-      expect(subGroup1?.items.length).toBe(1);
-      expect(subGroup1?.items.some((i) => i.id === "1")).toBe(true);
-    }
-
-    if (group2) {
-      expect(group2.items.length).toBe(0);
-      expect(group2.subGroups?.length).toBe(1);
-      const subGroup2 = group2.subGroups?.[0];
-      expect(subGroup2?.items.length).toBe(1);
-      expect(subGroup2?.items.some((i) => i.id === "2")).toBe(true);
-    }
+    expect(result).toHaveLength(1);
+    expect(result[0].sameVisit).toBe(false);
+    expect(result[0].items).toHaveLength(2);
   });
 
-  it("should not group items more than 8 hours apart", () => {
-    const items: IActivityHistoryItem[] = [
-      {
-        id: "1",
-        date: "2024-07-04T08:00:00Z",
-        professional: {
-          name: "1",
-          id: "1",
-          role: { id: "1", description: "1" },
-          speciality: { id: "1", description: "1" },
-        },
-        relevant: true,
-        diagnostics: [{ id: "d1", description: "d1" }],
-        center: { id: "c1", description: "c1" },
-        up: { id: "up1", description: "up1" },
-        ep: { id: "ep1", description: "ep1" },
-        service: { id: "s1", description: "s1" },
-      },
-      {
-        id: "2",
-        date: "2024-07-04T17:00:00Z",
-        professional: {
-          name: "1",
-          id: "1",
-          role: { id: "1", description: "1" },
-          speciality: { id: "1", description: "1" },
-        },
-        relevant: true,
-        diagnostics: [{ id: "d1", description: "d1" }],
-        center: { id: "c1", description: "c1" },
-        up: { id: "up1", description: "up1" },
-        ep: { id: "ep1", description: "ep1" },
-        service: { id: "s1", description: "s1" },
-      },
+  it("no agrupa si hay diferencia de más de 8h", () => {
+    const now = new Date();
+    const items = [
+      baseItem({ id: "1", date: now.toISOString() }),
+      baseItem({ id: "2", date: new Date(now.getTime() + 9 * 3600 * 1000).toISOString() }),
+    ];
+
+    const result = groupActivityHistoryItems(items);
+
+    expect(result).toHaveLength(2);
+  });
+
+  it("crea subgrupos con mismos diagnósticos", () => {
+    const now = new Date();
+    const diagnostics = [{ codi: "D1" }];
+    const items = [
+      baseItem({ id: "1", date: now.toISOString(), diagnostics }),
+      baseItem({ id: "2", date: new Date(now.getTime() + 1000).toISOString(), diagnostics }),
+    ];
+
+    const result = groupActivityHistoryItems(items);
+
+    expect(result[0].subGroups).toHaveLength(1);
+    expect(result[0].subGroups![0].items).toHaveLength(2);
+    expect(result[0].items).toHaveLength(0);
+  });
+
+  it("deja fuera de subgrupos ítems sin diagnóstico", () => {
+    const now = new Date();
+    const items = [
+      baseItem({ id: "1", date: now.toISOString(), diagnostics: [{ codi: "D1" }] }),
+      baseItem({ id: "2", date: new Date(now.getTime() + 1000).toISOString() }),
     ];
 
     const result = groupActivityHistoryItems(items);
 
-    expect(result.length).toBe(2);
-
-    const group1 = result.find((g) =>
-      g.subGroups?.some((sg) => sg.items.some((i) => i.id === "1")),
-    );
-    const group2 = result.find((g) =>
-      g.subGroups?.some((sg) => sg.items.some((i) => i.id === "2")),
-    );
-
-    expect(group1).toBeDefined();
-    expect(group2).toBeDefined();
-
-    if (group1) {
-      expect(group1.items.length).toBe(0);
-      expect(group1.subGroups?.length).toBe(1);
-      const subGroup1 = group1.subGroups?.[0];
-      expect(subGroup1?.items.length).toBe(1);
-      expect(subGroup1?.items.some((i) => i.id === "1")).toBe(true);
-    }
-
-    if (group2) {
-      expect(group2.items.length).toBe(0);
-      expect(group2.subGroups?.length).toBe(1);
-      const subGroup2 = group2.subGroups?.[0];
-      expect(subGroup2?.items.length).toBe(1);
-      expect(subGroup2?.items.some((i) => i.id === "2")).toBe(true);
-    }
+    expect(result[0].subGroups).toHaveLength(1);
+    expect(result[0].subGroups![0].items).toHaveLength(1);
+    expect(result[0].items).toHaveLength(1);
   });
 });

package/src/internal-plugins/activity-history/activity-history-item/list/group-history-items/group-history-items.ts

@@ -21,7 +21,7 @@ const isSameVisit = (item1: IActivityHistoryItem, item2: IActivityHistoryItem):
   return sameProfessional && sameLocation && sameDay;
 };
 
-const withinEightHours = (date1: Date, date2: Date): boolean => {
+const withinEightHours = (date1: string, date2: string): boolean => {
   const timeDifference = Math.abs(new Date(date1).getTime() - new Date(date2).getTime());
   return timeDifference <= 8 * 60 * 60 * 1000; // 8 hours in milliseconds
 };
@@ -46,6 +46,7 @@ const groupActivityHistoryItems = (items: IActivityHistoryItem[]): IActivityHist
   items?.forEach((item) => {
     let added = false;
 
+    // Primer intento: agrupar por misma visita y dentro de 8 horas
     for (const group of groups) {
       const firstItem = group.items[0];
       const lastItem = group.items[group.items.length - 1];
@@ -56,15 +57,37 @@ const groupActivityHistoryItems = (items: IActivityHistoryItem[]): IActivityHist
         withinEightHours(lastItem.date, item.date)
       ) {
         group.items.push(item);
+        group.sameVisit = true; // marcamos el grupo como de "misma visita"
         added = true;
         break;
       }
     }
 
+    // Segundo intento: agrupar solo por 8h, pero solo en grupos que NO son "misma visita"
+    if (!added) {
+      for (const group of groups) {
+        if (group.sameVisit) continue; // evitamos mezclar visitas
+
+        const firstItem = group.items[0];
+        const lastItem = group.items[group.items.length - 1];
+
+        if (
+          withinEightHours(firstItem.date, item.date) &&
+          withinEightHours(lastItem.date, item.date)
+        ) {
+          group.items.push(item);
+          added = true;
+          break;
+        }
+      }
+    }
+
+    // Si no se pudo agrupar, crear un nuevo grupo
     if (!added) {
       groups.push({
         idGroup: Math.random().toString(36).substr(2, 9),
         items: [item],
+        sameVisit: false,
       });
     }
   });

package/src/internal-plugins/activity-history/activity-history-item/selectors.ts

@@ -16,6 +16,8 @@ import { activityHistoryCustomFilterGroupsSelector } from "./filter/custom-filte
 import { groupActivityHistoryItems } from "./list/group-history-items/group-history-items";
 import { sortGroupsByMostRecentDate } from "./list/sort-history-items-by-date/sort-history-items-by-date";
 import { activityHistorySearchStringSelector } from "./search/selectors";
+import { diagnosticFilterEnabledValuesSelector } from "./filter/diagnostic-filters/selectors";
+import { DiagnosticCodeSpec } from "./domain/specs/diagnostics-filter-spec";
 
 export const activityHistoryCollectionsSelector = (state: RootState) =>
   state.activityHistoryCollections.collections;
@@ -71,6 +73,7 @@ export const customFilterGroupsWithOptionsSelector = createSelector(
                     collection.items,
                     f.propPathValue,
                     f.propsPathDescription,
+                    f.title
                   )
                 : []) || [],
           };
@@ -86,17 +89,20 @@ export const activityHistoryGroupedItems = createSelector(
   activityHistorySearchStringSelector,
   activityHistoryCommonFiltersSelector,
   activityHistoryCustomFilterGroupsSelector,
+  diagnosticFilterEnabledValuesSelector,
   (
     items: IActivityHistoryItem[],
     searchString: string,
     commonFilters: IActivityHistoryCommonFilter[],
     customFilters: IActivityHistoryCustomFilterGroup[],
+    diagnosticFilterEnabledValues: string[],
   ) => {
     const filteredItems = items.filter((item: IActivityHistoryItem) =>
       new SearchStringSpec(searchString, item.searchPredicate)
         .and(new CommonFilterSpec(commonFilters))
         .and(new ComposedTypeSpec(customFilters))
         .and(new CustomFilterSpec(customFilters))
+        .and(new DiagnosticCodeSpec(diagnosticFilterEnabledValues))
         .isSatisfiedBy(item),
     );
 

package/src/internal-plugins/activity-history/activity-history-item/slice.ts

@@ -6,16 +6,10 @@ import {
   IBusyHistoryItem,
   IErrorHistoryItem,
 } from "./domain/model";
-import {
-  addBusyHistoryItemReducer,
-  removeBusyHistoryItemReducer,
-} from "./list/handle-busy/reducers";
-import {
-  addErrorHistoryItemReducer,
-  removeErrorHistoryItemReducer,
-} from "./list/handle-error/reducers";
 import { removeActivityHistoryItemReducer } from "./remove/reducer";
 import { updateActivityHistoryItemReducer } from "./update/reducer";
+import { addBusyHistoryItemReducer, removeBusyHistoryItemReducer } from "./add/handle-busy/reducers";
+import { addErrorHistoryItemReducer, removeErrorHistoryItemReducer } from "./add/handle-error/reducers";
 
 export const activityHistoryCollectionsSlice = createSlice({
   name: "activity-history-collections",

package/src/internal-plugins/activity-history/activity-history-item/update/handler.ts

@@ -1,12 +1,12 @@
 import { StoreBaseHandler } from "../../infrastructure/base-handlers";
-import { ensureAreValidActivityHistoryItems } from "../domain/is-valid-history-item/is-valid-history-item";
+import { ensureAreValidBasicActivityHistoryItems } from "../domain/validation/is-valid-basic-history-item";
 import { updateActivityHistoryItem } from "./action";
 import { UpdateHistoryItemPayload } from "./request";
 
 export class UpdateHistoryItemHandler extends StoreBaseHandler {
   async handle(payload: UpdateHistoryItemPayload) {
     try {
-      ensureAreValidActivityHistoryItems([payload.item]);
+      ensureAreValidBasicActivityHistoryItems([payload.item]);
       this.store.dispatch(
         updateActivityHistoryItem({
           id: payload.entityId,

package/src/internal-plugins/activity-history/localization.ts

@@ -86,6 +86,22 @@ export const locales = {
       chipHeader: {
         selection: "Selecció:",
       },
+      error: {
+        general: {
+          title: "Hi ha hagut un problema durant la càrrega de contingut. Actualitza la pàgina o torna-ho a provar més tard.",
+          refresh: "Actualitzar pàgina",
+          noInfo: "No hi ha informació disponible.", 
+        },
+        partial: {
+          title: "Hi ha hagut un problema i no s'ha pogut carregar les notes de tipus",
+          refresh: "Actualitzar",
+          limit: "Límit de clicks superat",
+        },
+        title: "Error en la càrrega",
+        viewDetails: "Veure detalls",
+        imageAlt: "Imatge d'error",
+        errorToRefresh: "Error en l'acció d'actualitzar la pàgina",
+      },
     },
   },
 };

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

@@ -1,61 +1,86 @@
 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 filterTitle = "Centre";
+
+  it("should return unique objects with correct id and title", () => {
     const items = [
-      { data: { id: "1", label: "Item 1" } },
-      { data: { id: "2", label: "Item 2" } },
-      { data: { id: "1", label: "Item 1 (duplicate)" } }, // <- este debe sobrescribir
+      { a: { b: "1" }, c: { d: "Hospital A" } },
+      { a: { b: "2" }, c: { d: "Hospital B" } },
+      { a: { b: "1" }, c: { d: "Hospital A" } }, // duplicated
     ];
 
-    const result = getUniqueObjects(items, ["data", "id"], ["data", "label"]);
+    const result = getUniqueObjects(items, ["a", "b"], ["c", "d"], filterTitle);
 
     expect(result).toEqual([
-      { id: "1", title: "Item 1 (duplicate)" }, // 👈 el último
-      { id: "2", title: "Item 2" },
+      { id: "1", title: "Hospital A" },
+      { id: "2", title: "Hospital B" },
     ]);
   });
 
-  it("should skip items with missing id or title", () => {
+  it("should sort the results alphabetically by title", () => {
     const items = [
-      { data: { id: "1", label: "Valid" } },
-      { data: { id: 2, label: "Invalid ID" } },
-      { data: { id: "3", label: null } },
+      { a: { b: "2" }, c: { d: "Zoo" } },
+      { a: { b: "1" }, c: { d: "Apple" } },
+      { a: { b: "3" }, c: { d: "Library" } },
     ];
 
-    const result = getUniqueObjects(items, ["data", "id"], ["data", "label"]);
+    const result = getUniqueObjects(items, ["a", "b"], ["c", "d"], filterTitle);
 
-    expect(result).toEqual([{ id: "1", title: "Valid" }]);
+    expect(result).toEqual([
+      { id: "1", title: "Apple" },
+      { id: "3", title: "Library" },
+      { id: "2", title: "Zoo" },
+    ]);
   });
 
-  it("should return an empty array if input is empty", () => {
-    const result = getUniqueObjects([], ["a"], ["b"]);
-    expect(result).toEqual([]);
+  it("should add 'Sense centre' for items with missing id or title", () => {
+    const items = [
+      { a: { b: "" }, c: { d: "Hospital A" } },
+      { a: { b: "1" }, c: { d: null } },
+      { a: { b: null }, c: { d: "" } },
+    ];
+
+    const result = getUniqueObjects(items, ["a", "b"], ["c", "d"], filterTitle);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].title).toBe("Sense centre");
+    expect(result[0].id).toBe(""); // depende de implementación, aquí "" está permitido
   });
 
-  it("should handle deeply nested paths", () => {
+  it("should put 'Sense centre' entry at the end", () => {
     const items = [
-      { a: { b: { c: { id: "x1", name: "Deep 1" } } } },
-      { a: { b: { c: { id: "x2", name: "Deep 2" } } } },
+      { a: { b: "1" }, c: { d: "Beta" } },
+      { a: { b: null }, c: { d: null } },
+      { a: { b: "2" }, c: { d: "Alpha" } },
     ];
 
-    const result = getUniqueObjects(items, ["a", "b", "c", "id"], ["a", "b", "c", "name"]);
+    const result = getUniqueObjects(items, ["a", "b"], ["c", "d"], filterTitle);
 
-    expect(result).toEqual([
-      { id: "x1", title: "Deep 1" },
-      { id: "x2", title: "Deep 2" },
-    ]);
+    expect(result).toHaveLength(3);
+    expect(result[0].title).toBe("Alpha");
+    expect(result[1].title).toBe("Beta");
+    expect(result[2].title).toBe("Sense centre");
   });
 
-  it("should handle invalid path safely", () => {
+  it("should handle deep nested paths", () => {
     const items = [
-      { a: { b: { id: "1", name: "Good" } } },
-      { x: { y: { id: "2", name: "Missing Path" } } },
+      { a: { b: { c: "10" } }, x: { y: { z: "Foo" } } },
+      { a: { b: { c: "20" } }, x: { y: { z: "Bar" } } },
     ];
 
-    const result = getUniqueObjects(items, ["a", "b", "id"], ["a", "b", "name"]);
+    const result = getUniqueObjects(items, ["a", "b", "c"], ["x", "y", "z"], filterTitle);
+
+    expect(result).toEqual([
+      { id: "20", title: "Bar" },
+      { id: "10", title: "Foo" },
+    ]);
+  });
 
-    expect(result).toEqual([{ id: "1", title: "Good" }]);
+  it("should return empty array for empty input", () => {
+    const result = getUniqueObjects([], ["a"], ["b"], filterTitle);
+    expect(result).toEqual([]);
   });
-});
+});

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

@@ -2,15 +2,35 @@ export function getUniqueObjects<T>(
   items: T[],
   propPathId: string[],
   propPathDescription: string[],
+  filterTitle: string
 ): { id: string; title: string }[] {
-  return Array.from(
-    items
-      .map((item) => ({
-        id: propPathId.reduce((acc, key) => acc?.[key], item),
-        title: propPathDescription.reduce((acc, key) => acc?.[key], item),
-      }))
-      .filter((obj) => typeof obj.id === "string" && typeof obj.title === "string")
-      .reduce((map, obj) => map.set(obj.id, obj), new Map<string, { id: string; title: string }>())
-      .values(),
+  const SENSE_TITLE = `Sense ${filterTitle.toLocaleLowerCase()}`;
+  const map = new Map<string, { id: string; title: string }>();
+  let hasSenseItem = false;
+
+  for (const item of items) {
+    const id = propPathId.reduce((acc, key) => acc?.[key], item);
+    const title = propPathDescription.reduce((acc, key) => acc?.[key], item);
+
+    const isValidId = typeof id === "string" && id.trim() !== "";
+    const isValidTitle = typeof title === "string" && title.trim() !== "";
+
+    if (isValidId && isValidTitle) {
+      if (!map.has(id)) {
+        map.set(id, { id, title });
+      }
+    } else {
+      hasSenseItem = true;
+    }
+  }
+
+  const result = Array.from(map.values()).sort((a, b) =>
+    a.title.localeCompare(b.title, "ca", { sensitivity: "base" })
   );
-}
+
+  if (hasSenseItem) {
+    result.push({ id: "", title: SENSE_TITLE });
+  }
+
+  return result;
+}

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/domain/is-valid-history-item/is-valid-history-item.d.ts

@@ -1,5 +0,0 @@
-import { IActivityHistoryItem } from '../model';
-
-export declare const isValidActivityHistoryItem: (obj: IActivityHistoryItem) => any;
-export declare const ensureAreValidActivityHistoryItems: (items: IActivityHistoryItem[]) => IActivityHistoryItem[];
-export declare const validateAndFilterItems: (items: IActivityHistoryItem[]) => IActivityHistoryItem[];

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/list/handle-error/actions.d.ts

@@ -1,4 +0,0 @@
-export declare const addErrorHistoryItem: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
-    id: string;
-    message: string;
-}, "activity-history-collections/addErrorHistoryItem">, removeErrorHistoryItem: import('@reduxjs/toolkit').ActionCreatorWithPayload<string, "activity-history-collections/removeErrorHistoryItem">;