@uxland/primary-shell 3.5.2 → 3.5.3

package/src/internal-plugins/activity-history/{domain → activity-history-item/list}/group-history-items/group-history-items.ts

@@ -1,5 +1,9 @@
-import {IEntityDescription} from '@primaria/plugins-core';
-import {IActivityHistoryGroup, IActivityHistoryItem, IActivityHistorySubGroup} from '../model';
+import { IEntityDescription } from "@primaria/plugins-core";
+import {
+  IActivityHistoryItem,
+  IActivityHistoryGroup,
+  IActivityHistorySubGroup,
+} from "../../domain/model";
 
 const isSameVisit = (item1: IActivityHistoryItem, item2: IActivityHistoryItem): boolean => {
   const sameProfessional =
@@ -27,8 +31,8 @@ const areSameDiagnostics = (diag1: IEntityDescription[], diag2: IEntityDescripti
     return false;
   }
 
-  const sortedDiag1 = diag1.map(d => d.id).sort();
-  const sortedDiag2 = diag2.map(d => d.id).sort();
+  const sortedDiag1 = diag1.map((d) => d.id).sort();
+  const sortedDiag2 = diag2.map((d) => d.id).sort();
 
   return sortedDiag1.every((id, index) => id === sortedDiag2[index]);
 };
@@ -36,7 +40,7 @@ const areSameDiagnostics = (diag1: IEntityDescription[], diag2: IEntityDescripti
 const groupActivityHistoryItems = (items: IActivityHistoryItem[]): IActivityHistoryGroup[] => {
   const groups: IActivityHistoryGroup[] = [];
 
-  items?.forEach(item => {
+  items?.forEach((item) => {
     let added = false;
 
     for (const group of groups) {
@@ -63,11 +67,11 @@ const groupActivityHistoryItems = (items: IActivityHistoryItem[]): IActivityHist
   });
 
   // Crear subgrupos por diagnósticos iguales. Los items que no tienen diagnostico, se quedan fuera de subgrupos (remaining items)
-  groups.forEach(group => {
+  groups.forEach((group) => {
     const subGroups: IActivityHistorySubGroup[] = [];
     const remainingItems: IActivityHistoryItem[] = [];
 
-    group.items.forEach(item => {
+    group.items.forEach((item) => {
       if (item.diagnostics?.length > 0) {
         let addedToSubGroup = false;
 
@@ -99,4 +103,4 @@ const groupActivityHistoryItems = (items: IActivityHistoryItem[]): IActivityHist
   return groups;
 };
 
-export {groupActivityHistoryItems};
+export { groupActivityHistoryItems };

package/src/internal-plugins/activity-history/activity-history-item/list/handle-busy/actions.ts

@@ -0,0 +1,4 @@
+import { activityHistoryCollectionsSlice } from "../../slice";
+
+export const { addBusyHistoryItem, removeBusyHistoryItem } =
+  activityHistoryCollectionsSlice.actions;

package/src/internal-plugins/activity-history/activity-history-item/list/handle-busy/bootstrapper.ts

@@ -0,0 +1,5 @@
+import "./busy-component/component";
+
+export const bootstrapActivityHistoryItemHandleBusy = () => {
+  () => null;
+};

package/src/internal-plugins/activity-history/activity-history-item/list/handle-busy/busy-component/component.ts

@@ -0,0 +1,27 @@
+import { LitElement, css, html, unsafeCSS } from "lit";
+import { customElement } from "lit/decorators.js";
+import styles from "./styles.css?inline";
+import { template } from "./template";
+import { connectedProperty } from "../../../../infrastructure/state/connected-property";
+import {
+  isAnyCollectionLoadingWithoutAnyLoaded,
+  isSomeCollectionLoadedAndOtherLoading,
+} from "../selectors";
+
+//@ts-ignore
+@customElement("activity-history-busy")
+export class ActivityHistoryBusy extends LitElement {
+  render() {
+    return html`${template(this)}`;
+  }
+
+  static styles = css`
+    ${unsafeCSS(styles)}
+  `;
+
+  @connectedProperty(isAnyCollectionLoadingWithoutAnyLoaded)
+  isAnyCollectionLoadingWithoutAnyLoaded: boolean;
+
+  @connectedProperty(isSomeCollectionLoadedAndOtherLoading)
+  isSomeCollectionLoadedAndOtherLoading: boolean;
+}

package/src/internal-plugins/activity-history/activity-history-item/list/handle-busy/busy-component/styles.css

@@ -0,0 +1,15 @@
+.spinner-container {
+        display: flex;
+        flex-direction: row;
+        align-items: center;
+        gap: 24px;
+        justify-content: center;
+        padding-top:16px
+      }
+      .spinner-full-container {
+        width: 100%;
+        height: 100%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+      }

package/src/internal-plugins/activity-history/activity-history-item/list/handle-busy/busy-component/template.ts

@@ -0,0 +1,10 @@
+import { html, nothing } from "lit";
+import { ActivityHistoryBusy } from "./component";
+import { translate } from "../../../../localization";
+
+export const template = (props: ActivityHistoryBusy) =>
+  props.isAnyCollectionLoadingWithoutAnyLoaded
+    ? html`<div class="spinner-full-container"><dss-spinner></dss-spinner></div>`
+    : props.isSomeCollectionLoadedAndOtherLoading
+      ? html`<div class="spinner-container"><dss-spinner size="sm"></dss-spinner><div class="busy-description">${translate("busyEntriesLoading")}</div></div>`
+      : nothing;

package/src/internal-plugins/activity-history/activity-history-item/list/handle-busy/reducers.ts

@@ -0,0 +1,8 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+
+export function addBusyHistoryItemReducer(state, action: PayloadAction<string>) {
+  state.busy.push(action.payload);
+}
+export function removeBusyHistoryItemReducer(state, action: PayloadAction<string>) {
+  state.busy = state.busy.filter((i) => i !== action.payload);
+}

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

@@ -0,0 +1,13 @@
+import { RootState } from "../../../infrastructure/state/store";
+
+const isAnyCollectionBusySelector = (state: RootState) =>
+  state.activityHistoryCollections.busy.length > 0;
+export const isAnyCollectionLoadingWithoutAnyLoaded = (state: RootState) => {
+  const collections = Object.values(state.activityHistoryCollections.collections);
+  return !collections?.length && isAnyCollectionBusySelector(state);
+};
+
+export const isSomeCollectionLoadedAndOtherLoading = (state: RootState) => {
+  const collections = Object.values(state.activityHistoryCollections.collections);
+  return collections && isAnyCollectionBusySelector(state);
+};

package/src/internal-plugins/activity-history/activity-history-item/list/handle-error/actions.ts

@@ -0,0 +1,4 @@
+import { activityHistoryCollectionsSlice } from "../../slice";
+
+export const { addErrorHistoryItem, removeErrorHistoryItem } =
+  activityHistoryCollectionsSlice.actions;

package/src/internal-plugins/activity-history/activity-history-item/list/handle-error/reducers.ts

@@ -0,0 +1,6 @@
+export function addErrorHistoryItemReducer(state, action) {
+  state.error.push(action.payload);
+}
+export function removeErrorHistoryItemReducer(state, action) {
+  state.error = state.error.filter((i) => i !== action.payload);
+}

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

@@ -0,0 +1,62 @@
+import { createSelector } from "@reduxjs/toolkit";
+import { RootState } from "../../infrastructure/state/store";
+import { commonSpecSelector } from "../filter/selectors";
+import {
+  IActivityHistoryItem,
+  IActivityHistoryItemCollection,
+  TSearchActivityHistoryItemPredicate,
+} from "../domain/model";
+import { SearchStringSpec } from "../domain/specs/search-string-spec";
+import { groupActivityHistoryItems } from "./group-history-items/group-history-items";
+import { sortGroupsByMostRecentDate } from "./sort-history-items-by-date/sort-history-items-by-date";
+import { activityHistorySearchStringSelector } from "../search/selectors";
+import { Spec } from "../domain/specs/spec";
+
+export const activityHistoryCollectionsSelector = (state: RootState) =>
+  state.activityHistoryCollections.collections;
+
+const mapItemsWithMetadata = (
+  items: IActivityHistoryItem[],
+  componentFactory: any,
+  type: string,
+  searchPredicate: TSearchActivityHistoryItemPredicate,
+) => {
+  return items.map(
+    (item) =>
+      ({
+        ...item,
+        searchPredicate,
+        componentFactory,
+        type,
+      }) as IActivityHistoryItem,
+  );
+};
+
+export const activityHistoryMappedItems = createSelector(
+  activityHistoryCollectionsSelector,
+  (collections: Record<string, IActivityHistoryItemCollection>) => {
+    return Object.values(collections).flatMap((collection: IActivityHistoryItemCollection) => {
+      return mapItemsWithMetadata(
+        collection.items,
+        collection.componentFactory,
+        collection.id,
+        collection.searchPredicate,
+      );
+    });
+  },
+);
+
+export const activityHistoryGroupedItems = createSelector(
+  activityHistoryMappedItems,
+  activityHistorySearchStringSelector,
+  commonSpecSelector,
+  (items: IActivityHistoryItem[], searchString: string, commonSpec: Spec<IActivityHistoryItem>) => {
+    const filteredItems = items.filter((item: IActivityHistoryItem) =>
+      new SearchStringSpec(searchString, item.searchPredicate).and(commonSpec).isSatisfiedBy(item),
+    );
+
+    const groupedItems = groupActivityHistoryItems(filteredItems);
+    const sortedByMostRecentDate = sortGroupsByMostRecentDate(groupedItems);
+    return sortedByMostRecentDate;
+  },
+);

package/src/internal-plugins/activity-history/{domain → activity-history-item/list}/sort-history-items-by-date/sort-history-items-by-date.ts

@@ -1,8 +1,8 @@
-import {IActivityHistoryGroup} from '../model';
+import { IActivityHistoryGroup } from "../../domain/model";
 
 export const sortGroupsByMostRecentDate = (arr: IActivityHistoryGroup[]) => {
   // Helper function to get the most recent date from a list of items
-  const getMostRecentDate = items => {
+  const getMostRecentDate = (items) => {
     return items.reduce((latest, item) => {
       const itemDate = new Date(item.date);
       return itemDate > latest ? itemDate : latest;
@@ -10,12 +10,12 @@ export const sortGroupsByMostRecentDate = (arr: IActivityHistoryGroup[]) => {
   };
 
   // Helper function to sort items within each group or subgroup
-  const sortItemsByDate = items => {
+  const sortItemsByDate = (items) => {
     return items.sort((a, b) => new Date(b.date) - new Date(a.date));
   };
 
   // Function to get the most recent date from a group (considering its items and subgroups)
-  const getGroupMostRecentDate = group => {
+  const getGroupMostRecentDate = (group) => {
     let allDates = [];
 
     // Collect dates from group items
@@ -24,7 +24,7 @@ export const sortGroupsByMostRecentDate = (arr: IActivityHistoryGroup[]) => {
     }
 
     // Collect dates from subgroups items
-    group.subGroups.forEach(subGroup => {
+    group.subGroups.forEach((subGroup) => {
       if (subGroup.items.length > 0) {
         allDates.push(getMostRecentDate(subGroup.items));
       }
@@ -35,9 +35,9 @@ export const sortGroupsByMostRecentDate = (arr: IActivityHistoryGroup[]) => {
   };
 
   // Sort each group's items and subgroups' items by date
-  arr.forEach(group => {
+  arr.forEach((group) => {
     group.items = sortItemsByDate(group.items);
-    group.subGroups.forEach(subGroup => {
+    group.subGroups.forEach((subGroup) => {
       subGroup.items = sortItemsByDate(subGroup.items);
     });
   });

package/src/internal-plugins/activity-history/activity-history-item/remove/reducer.ts

@@ -0,0 +1,5 @@
+export function removeActivityHistoryItemReducer(state, action) {
+  /* state.collections[action.payload.id]?.items = state.collections[action.payload.id]?.items.filter(
+        (i) => i !== action.payload,
+      );   */
+}

package/src/internal-plugins/activity-history/activity-history-item/search/actions.ts

@@ -0,0 +1,3 @@
+import { activityHistoryFiltersSlice } from "../filter/slice";
+
+export const { setSearchString } = activityHistoryFiltersSlice.actions;

package/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-bar/activity-history-search-bar.ts

@@ -0,0 +1,26 @@
+import { LitElement, css, html, unsafeCSS } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import styles from "./styles.css?inline";
+import { template } from "./template";
+
+//@ts-ignore
+@customElement("activity-history-search-bar")
+export class ActivityHistorySearchBar extends LitElement {
+  render() {
+    return html`${template(this)}`;
+  }
+
+  static styles = css`
+    ${unsafeCSS(styles)}
+  `;
+
+  @property()
+  searchQuery = "";
+
+  _handleSearchChange(event) {
+    const selectedItems = event.detail || [];
+    const searchQuery = selectedItems.length > 0 ? selectedItems.join(" ") : "";
+    const payload = searchQuery.length > 1 ? searchQuery : "";
+    this.dispatchEvent(new CustomEvent("onSearchChange", { detail: payload }));
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-bar/template.ts

@@ -0,0 +1,8 @@
+import { html } from "lit";
+import { ActivityHistorySearchBar } from "./activity-history-search-bar";
+
+export const template = (props: ActivityHistorySearchBar) =>
+  html`<dss-search-bar dropdownStyle=${"display: none"} @onSearchChange=${props._handleSearchChange} icon="search" inputsize="md" threshold="2" recentsearchestext="" emptydropdowntext="">
+                    <label slot="label" for="searchbar1" aria-hidden="false"></label>
+                    <input slot="input" id="searchbar1" type="text" value=${props.searchQuery} @input=${(e) => props._handleSearchChange({ detail: [e.target.value] })}>
+                </dss-search-bar>`;

package/src/internal-plugins/activity-history/{components/activity-history/activity-history-search-header/activity-history-search-header.ts → activity-history-item/search/activity-history-search-results/activity-history-search-results.ts}

@@ -4,8 +4,8 @@ import styles from "./styles.css?inline";
 import { template } from "./template";
 
 //@ts-ignore
-@customElement("activity-history-search-header")
-export class ActivityHistorySearchHeader extends LitElement {
+@customElement("activity-history-search-results")
+export class ActivityHistorySearchResults extends LitElement {
   render() {
     return html`${template(this)}`;
   }
@@ -16,5 +16,4 @@ export class ActivityHistorySearchHeader extends LitElement {
 
   @property()
   searchQuery = "";
-
 }

package/src/internal-plugins/activity-history/activity-history-item/search/activity-history-search-results/styles.css

@@ -0,0 +1,14 @@
+.search-header {
+  padding-inline: 16px;
+  padding-top: 12px;
+  padding-bottom: 12px;
+  gap: var(--dds-spacing-xs);
+  border-width: 0px 0px 1px 0px;
+  border-style: solid;
+  border-color: #D8D8D8;
+  background-color: #FFFFFF;
+  color: var(--color-neutral-900);
+  font-weight: 600;
+  font-size: 14px;
+  line-height: 24px;
+}

package/src/internal-plugins/activity-history/{components/activity-history/activity-history-search-header → activity-history-item/search/activity-history-search-results}/template.ts

@@ -1,8 +1,8 @@
 import { html } from "lit";
-import { ActivityHistorySearchHeader } from "./activity-history-search-header";
+import { ActivityHistorySearchResults } from "./activity-history-search-results";
 import { translate } from "../../../localization";
 
-export const template = (props: ActivityHistorySearchHeader) =>
+export const template = (props: ActivityHistorySearchResults) =>
   html`<div class="search-header">
     ${translate("searchBarResults")} “${props.searchQuery}”
   </div>`;

package/src/internal-plugins/activity-history/{features/search-items → activity-history-item/search}/bootstrapper.ts

@@ -2,6 +2,8 @@ import { BrokerExtensions } from "@primaria/plugins-core";
 import { SearchItemsHandler } from "./handler";
 import { SearchActivityHistoryItems } from "./request";
 import { BrokerDisposableHandler } from "../../../../api/broker/primaria-broker";
+import "./activity-history-search-results/activity-history-search-results";
+import "./activity-history-search-bar/activity-history-search-bar";
 
 let request: BrokerDisposableHandler;
 
@@ -9,6 +11,6 @@ export const bootstrapSearchItems = (broker: BrokerExtensions) => {
   request = broker.registerRequest(SearchActivityHistoryItems, SearchItemsHandler);
 };
 
-export const teardownSearchItems = (broker: BrokerExtensions) => {
+export const teardownSearchItems = () => {
   request?.dispose();
 };

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

@@ -0,0 +1,17 @@
+import { events } from "../../constants";
+import { BaseHandler } from "../../infrastructure/base-handlers";
+import { setSearchString } from "./actions";
+import { SearchActivityHistoryItems } from "./request";
+
+export class SearchItemsHandler extends BaseHandler {
+  async handle(request: SearchActivityHistoryItems) {
+    try {
+      this.store.dispatch(setSearchString(request.searchString));
+      this.api.broker.publish(events.activityHistorySearched, {
+        searchQuery: request.searchString,
+      });
+    } catch (e) {
+      console.log(e.message);
+    }
+  }
+}

package/src/internal-plugins/activity-history/activity-history-item/search/reducer.ts

@@ -0,0 +1,5 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+
+export function setSearchStringReducer(state, action: PayloadAction<string>) {
+  state.searchString = action.payload;
+}

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

@@ -0,0 +1,4 @@
+import { RootState } from "../../infrastructure/state/store";
+
+export const activityHistorySearchStringSelector = (state: RootState) =>
+  state.activityHistoryFilters.searchString;

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

@@ -0,0 +1,37 @@
+import { createSlice } from "@reduxjs/toolkit";
+import { addActivityHistoryItemReducer } from "./add/add-history-item/reducer";
+import { addActivityHistoryItemsReducer } from "./add/add-history-items/reducer";
+import {
+  IActivityHistoryItemCollection,
+  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";
+
+export const activityHistoryCollectionsSlice = createSlice({
+  name: "activity-history-collections",
+  initialState: {
+    busy: [] as IBusyHistoryItem[],
+    error: [] as IErrorHistoryItem[],
+    collections: {} as Record<string, IActivityHistoryItemCollection>,
+  },
+  reducers: {
+    addBusyHistoryItem: addBusyHistoryItemReducer,
+    removeBusyHistoryItem: removeBusyHistoryItemReducer,
+    addActivityHistoryItem: addActivityHistoryItemReducer,
+    updateActivityHistoryItem: updateActivityHistoryItemReducer,
+    addActivityHistoryItems: addActivityHistoryItemsReducer,
+    addErrorHistoryItem: addErrorHistoryItemReducer,
+    removeErrorHistoryItem: removeErrorHistoryItemReducer,
+    removeActivityHistoryItem: removeActivityHistoryItemReducer,
+  },
+});

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

@@ -0,0 +1,3 @@
+import { activityHistoryCollectionsSlice } from "../slice";
+
+export const { updateActivityHistoryItem } = activityHistoryCollectionsSlice.actions;

package/src/internal-plugins/activity-history/{features/update-history-item → activity-history-item/update}/bootstrapper.ts

@@ -9,6 +9,6 @@ export const bootstrapUpdateHistoryItem = (broker: BrokerExtensions) => {
   request = broker.registerRequest(updateHistoryItemRequest, UpdateHistoryItemHandler);
 };
 
-export const teardownUpdateHistoryItem = (broker: BrokerExtensions) => {
+export const teardownUpdateHistoryItem = () => {
   request?.dispose();
 };

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

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

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

@@ -0,0 +1,11 @@
+import { PayloadAction } from "@reduxjs/toolkit";
+import { updateItemInCollection } from "./update-item-in-collection";
+import { IActivityHistoryItem } from "../domain/model";
+
+export function updateActivityHistoryItemReducer(
+  state,
+  action: PayloadAction<{ id: string; item: IActivityHistoryItem }>,
+) {
+  const { id, item } = action.payload;
+  state.collections = updateItemInCollection(state.collections, id, item);
+}

package/src/internal-plugins/activity-history/{features/update-history-item → activity-history-item/update}/request.ts

@@ -1,4 +1,4 @@
-import { IActivityHistoryItem } from "../../domain/model";
+import { IActivityHistoryItem } from "../domain/model";
 
 export interface UpdateHistoryItemPayload {
   entityId: string;

package/src/internal-plugins/activity-history/activity-history-item/update/update-item-in-collection.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { IActivityHistoryItem } from "../..";
+import { updateItemInCollection } from "./update-item-in-collection";
+
+describe("updateItemInCollection", () => {
+  it("should return the same collections if the collection does not exist", () => {
+    const collections: Record<string, any> = {};
+    const updatedItem: IActivityHistoryItem = { id: "item1", name: "Updated Item 1" };
+
+    const result = updateItemInCollection(collections, "collection1", updatedItem);
+
+    expect(result).toEqual(collections); // Sin cambios
+  });
+
+  it("should return the same collections if the collection exists but has no items", () => {
+    const collections: Record<string, any> = {
+      collection1: {
+        id: "collection1",
+        items: [],
+      },
+    };
+    const updatedItem: IActivityHistoryItem = { id: "item1", name: "Updated Item 1" };
+
+    const result = updateItemInCollection(collections, "collection1", updatedItem);
+
+    expect(result).toEqual(collections); // Sin cambios
+  });
+
+  it("should update the item in the collection when the id matches", () => {
+    const collections: Record<string, any> = {
+      collection1: {
+        id: "collection1",
+        items: [
+          { id: "item1", name: "Item 1" },
+          { id: "item2", name: "Item 2" },
+        ],
+      },
+    };
+    const updatedItem: IActivityHistoryItem = { id: "item1", name: "Updated Item 1" };
+
+    const result = updateItemInCollection(collections, "collection1", updatedItem);
+
+    expect(result.collection1.items).toEqual([
+      { id: "item1", name: "Updated Item 1" },
+      { id: "item2", name: "Item 2" },
+    ]);
+  });
+
+  it("should return the same collections if the item with the id does not exist", () => {
+    const collections: Record<string, any> = {
+      collection1: {
+        id: "collection1",
+        items: [
+          { id: "item1", name: "Item 1" },
+          { id: "item2", name: "Item 2" },
+        ],
+      },
+    };
+    const updatedItem: IActivityHistoryItem = { id: "item3", name: "Updated Item 3" }; // No existe item3
+
+    const result = updateItemInCollection(collections, "collection1", updatedItem);
+
+    expect(result).toEqual(collections); // Sin cambios
+  });
+});

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

@@ -0,0 +1,18 @@
+import { IActivityHistoryItem } from "../domain/model";
+
+export const updateItemInCollection = (
+  collections: Record<string, any>,
+  id: string,
+  updatedItem: IActivityHistoryItem,
+) => {
+  if (!collections[id]?.items) return collections;
+  const items = collections[id]?.items ?? [];
+
+  return {
+    ...collections,
+    [id]: {
+      ...collections[id],
+      items: items.map((i: IActivityHistoryItem) => (i.id === updatedItem.id ? updatedItem : i)),
+    },
+  };
+};

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

@@ -1 +1 @@
-export * from "./domain/model";
+export * from "./activity-history-item/domain/model";

package/src/internal-plugins/activity-history/infrastructure/base-handlers.ts

@@ -0,0 +1,22 @@
+import { inject, injectable } from "inversify";
+import { TYPES } from "./ioc/types";
+import { Store } from "@reduxjs/toolkit";
+import { PrimariaApi } from "@uxland/primary-shell";
+
+@injectable()
+export class StoreBaseHandler {
+  constructor(@inject(TYPES.store) protected readonly store: Store) {}
+}
+
+@injectable()
+export class ApiBaseHandler {
+  constructor(@inject(TYPES.primaryApi) protected readonly api: PrimariaApi) {}
+}
+
+@injectable()
+export class BaseHandler {
+  constructor(
+    @inject(TYPES.store) protected readonly store: Store,
+    @inject(TYPES.primaryApi) protected readonly api: PrimariaApi,
+  ) {}
+}

package/src/internal-plugins/activity-history/infrastructure/ioc/container.ts

@@ -1,6 +1,14 @@
 import { Container } from "inversify";
 import getDecorators from "inversify-inject-decorators";
+import { PrimariaApi } from "../../../../api/api";
+import { TYPES } from "./types";
+import { store } from "../state/store";
 const container = new Container();
 const { lazyInject } = getDecorators(container, false);
 
-export { container, lazyInject };
+export { container, lazyInject };
+
+export const bindDeps = (api: PrimariaApi) => {
+  container.bind(TYPES.primaryApi).toConstantValue(api);
+  container.bind(TYPES.store).toConstantValue(store);
+};