@uxland/primary-shell 5.3.6 → 5.3.7

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/list/merge-history-items-and-subgroups/merge-history-items-and-subgroups.d.ts

@@ -0,0 +1,12 @@
+import { IActivityHistoryGroup, IActivityHistoryItemWithComponent, IActivityHistorySubGroup } from '../../domain/model';
+
+export type ActivityHistoryEntry = {
+    type: "item";
+    date: Date;
+    item: IActivityHistoryItemWithComponent;
+} | {
+    type: "subGroup";
+    date: Date;
+    subGroup: IActivityHistorySubGroup;
+};
+export declare const mergeHistoryItemsAndSubgroups: (group: IActivityHistoryGroup) => ActivityHistoryEntry[];

package/dist/primary/shell/src/internal-plugins/activity-history/activity-history-item/list/merge-history-items-and-subgroups/merge-history-items-and-subgroups.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

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

package/src/internal-plugins/activity-history/activity-history-item/list/UI/timeline/template.ts

@@ -14,6 +14,10 @@ import {
 import { translate } from "../../../../localization";
 import { virtualize } from "@lit-labs/virtualizer/virtualize.js";
 import { hasItemDivider, shouldShowRole } from "../../../domain/business-rules";
+import {
+  ActivityHistoryEntry,
+  mergeHistoryItemsAndSubgroups,
+} from "../../merge-history-items-and-subgroups/merge-history-items-and-subgroups";
 
 export const template = (props: ActivityHistoryTimeline) => {
   if (!props._hasUpdatedOnce) {
@@ -32,26 +36,41 @@ export const template = (props: ActivityHistoryTimeline) => {
                   ${visitHeaderTemplate(props, itemGroup.items[0] || itemGroup.subGroups[0]?.items[0])}
                   <div class="visit__items">
                     ${repeat(
-                      itemGroup.items,
-                      (item) => item.id,
-                      (item: IActivityHistoryItemWithComponent) =>
-                        html`<div class="item" ?has-divider=${hasItemDivider(item, itemGroup.items as IActivityHistoryItemWithComponent[])}>${item.component}</div> `,
-                    )}
-                    ${repeat(
-                      itemGroup.subGroups,
-                      (subGroup: IActivityHistorySubGroup) => html`
-                        <div class="diagnostics">
-                          ${diagnosticHeaderTemplate(subGroup.items[0])}
-                          <div class="diagnostics__items">
-                            ${repeat(
-                              subGroup.items,
-                              (item) => item.id,
-                              (item: IActivityHistoryItemWithComponent) =>
-                                html`<div class="item" ?has-divider=${hasItemDivider(item, subGroup.items as IActivityHistoryItemWithComponent[])}>${item?.component}</div>`,
-                            )}
-                          </div>
-                        </div>
-                      `,
+                      mergeHistoryItemsAndSubgroups(itemGroup),
+                      (entry) => (entry.type === "item" ? entry.item.id : entry.subGroup.id),
+                      (entry: ActivityHistoryEntry) => {
+                        if (entry.type === "item") {
+                          const item = entry.item;
+                          return html`
+                            <div
+                              class="item"
+                              ?has-divider=${hasItemDivider(item, itemGroup.items as IActivityHistoryItemWithComponent[])}
+                            >
+                              ${item.component}
+                            </div>
+                          `;
+                        }
+                        const subGroup = entry.subGroup;
+                        return html`
+                            <div class="diagnostics">
+                              ${diagnosticHeaderTemplate(subGroup.items[0])}
+                              <div class="diagnostics__items">
+                                ${repeat(
+                                  subGroup.items,
+                                  (item) => item.id,
+                                  (item: IActivityHistoryItemWithComponent) => html`
+                                    <div
+                                      class="item"
+                                      ?has-divider=${hasItemDivider(item, subGroup.items as IActivityHistoryItemWithComponent[])}
+                                    >
+                                      ${item.component}
+                                    </div>
+                                  `,
+                                )}
+                              </div>
+                            </div>
+                          `;
+                      },
                     )}
                   </div>
                 </div>
@@ -96,7 +115,7 @@ const renderProfessionalValues = (props: ActivityHistoryTimeline, item: IActivit
   const professionalItems = [
     props.highlighted(item.professional.name),
     showRole ? props.highlighted(item.professional.role.description) : null,
-    props.highlighted(item.center.description),
+    props.highlighted(item.up.description) ?? props.highlighted(item.center.description),
     props.highlighted(item.professional.speciality.description),
     props.highlighted(item.service.description),
   ].filter(Boolean);

package/src/internal-plugins/activity-history/activity-history-item/list/merge-history-items-and-subgroups/merge-history-items-and-subgroups.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from "vitest";
+import { mergeHistoryItemsAndSubgroups } from "./merge-history-items-and-subgroups";
+import {
+  IActivityHistoryGroup,
+  IActivityHistoryItemWithComponent,
+  IActivityHistorySubGroup,
+} from "../../domain/model";
+
+type RenderEntry =
+  | { type: "item"; date: Date; item: IActivityHistoryItemWithComponent }
+  | { type: "subGroup"; date: Date; subGroup: IActivityHistorySubGroup };
+
+describe("mergeHistoryItemsAndSubgroups", () => {
+  it("should sort only items by date descending", () => {
+    const group: IActivityHistoryGroup = {
+      id: "g1",
+      items: [
+        { id: "i1", date: "2025-05-05T10:00:00Z", component: "<div/>" },
+        { id: "i2", date: "2025-05-05T12:00:00Z", component: "<div/>" },
+        { id: "i3", date: "2025-05-05T08:00:00Z", component: "<div/>" },
+      ],
+      subGroups: [],
+    };
+
+    const result = mergeHistoryItemsAndSubgroups(group) as RenderEntry[];
+    const ids = result.map((e) => (e.type === "item" ? e.item.id : e.subGroup.id));
+
+    expect(ids).toEqual(["i2", "i1", "i3"]);
+  });
+
+  it("should sort only subGroups by their most recent item", () => {
+    const subGroupA: IActivityHistorySubGroup = {
+      id: "sgA",
+      items: [{ id: "a1", date: "2025-05-05T09:00:00Z", component: "<div/>" }],
+    };
+    const subGroupB: IActivityHistorySubGroup = {
+      id: "sgB",
+      items: [
+        { id: "b1", date: "2025-05-05T15:00:00Z", component: "<div/>" },
+        { id: "b2", date: "2025-05-05T14:00:00Z", component: "<div/>" },
+      ],
+    };
+    const group: IActivityHistoryGroup = {
+      id: "g2",
+      items: [],
+      subGroups: [subGroupA, subGroupB],
+    };
+
+    const result = mergeHistoryItemsAndSubgroups(group) as RenderEntry[];
+    const ids = result.map((e) => (e.type === "item" ? e.item.id : e.subGroup.id));
+
+    expect(ids).toEqual(["sgB", "sgA"]);
+  });
+
+  it("should interleave items and subGroups by date", () => {
+    const group: IActivityHistoryGroup = {
+      id: "g3",
+      items: [
+        { id: "i1", date: "2025-05-05T10:00:00Z", component: "<div/>" },
+        { id: "i2", date: "2025-05-05T14:00:00Z", component: "<div/>" },
+      ],
+      subGroups: [
+        {
+          id: "sg1",
+          items: [{ id: "s1", date: "2025-05-05T12:00:00Z", component: "<div/>" }],
+        },
+      ],
+    };
+
+    const result = mergeHistoryItemsAndSubgroups(group) as RenderEntry[];
+    const ids = result.map((e) => (e.type === "item" ? e.item.id : e.subGroup.id));
+
+    // Expected order: i2 (14:00), sg1 (12:00), i1 (10:00)
+    expect(ids).toEqual(["i2", "sg1", "i1"]);
+  });
+
+  it("should place subGroups without items at the end", () => {
+    const emptySubGroup: IActivityHistorySubGroup = {
+      id: "sgEmpty",
+      items: [],
+    };
+    const group: IActivityHistoryGroup = {
+      id: "g4",
+      items: [{ id: "i1", date: "2025-05-05T11:00:00Z", component: "<div/>" }],
+      subGroups: [emptySubGroup],
+    };
+
+    const result = mergeHistoryItemsAndSubgroups(group) as RenderEntry[];
+    const ids = result.map((e) => (e.type === "item" ? e.item.id : e.subGroup.id));
+
+    expect(ids).toEqual(["i1", "sgEmpty"]);
+  });
+});

package/src/internal-plugins/activity-history/activity-history-item/list/merge-history-items-and-subgroups/merge-history-items-and-subgroups.ts

@@ -0,0 +1,34 @@
+import {
+  IActivityHistoryGroup,
+  IActivityHistoryItemWithComponent,
+  IActivityHistorySubGroup,
+} from "../../domain/model";
+
+export type ActivityHistoryEntry =
+  | { type: "item"; date: Date; item: IActivityHistoryItemWithComponent }
+  | { type: "subGroup"; date: Date; subGroup: IActivityHistorySubGroup };
+
+export const mergeHistoryItemsAndSubgroups = (
+  group: IActivityHistoryGroup,
+): ActivityHistoryEntry[] => {
+  // 1. Prepara los items sueltos
+  const itemEntries: ActivityHistoryEntry[] = group.items.map((item) => ({
+    type: "item",
+    date: new Date(item.date),
+    item,
+  }));
+
+  // 2. Prepara los subGroups, usando la fecha del ítem más reciente de cada subgrupo
+  const subGroupEntries: ActivityHistoryEntry[] = group.subGroups.map((subGroup) => {
+    // Asumimos que subGroup.items ya está ordenado de más reciente a más antiguo
+    const mostRecent = subGroup.items.length ? new Date(subGroup.items[0].date) : new Date(0);
+    return {
+      type: "subGroup",
+      date: mostRecent,
+      subGroup,
+    };
+  });
+
+  // 3. Fusiona y ordena
+  return [...itemEntries, ...subGroupEntries].sort((a, b) => b.date.getTime() - a.date.getTime());
+};

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

@@ -1,47 +1,52 @@
 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) => {
+  // Helper: obtener la fecha más reciente de una lista de items
+  const getMostRecentDate = (items: { date: string }[]): Date => {
     return items.reduce((latest, item) => {
       const itemDate = new Date(item.date);
       return itemDate > latest ? itemDate : latest;
-    }, new Date(0)); // Default to an old date
+    }, new Date(0));
   };
 
-  // Helper function to sort items within each group or subgroup
-  const sortItemsByDate = (items) => {
-    return items.sort((a, b) => new Date(b.date) - new Date(a.date));
+  // Ordenar items de más reciente a más antiguo
+  const sortItemsByDate = (items: { date: string }[]) => {
+    return items.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
   };
 
-  // Function to get the most recent date from a group (considering its items and subgroups)
-  const getGroupMostRecentDate = (group) => {
-    let allDates = [];
-
-    // Collect dates from group items
-    if (group.items.length > 0) {
-      allDates.push(getMostRecentDate(group.items));
-    }
-
-    // Collect dates from subgroups items
-    group.subGroups.forEach((subGroup) => {
-      if (subGroup.items.length > 0) {
-        allDates.push(getMostRecentDate(subGroup.items));
-      }
-    });
+  // Obtener la fecha más reciente de un subgrupo
+  const getSubGroupMostRecentDate = (subGroup: { items: { date: string }[] }): Date => {
+    return getMostRecentDate(subGroup.items);
+  };
 
-    // Return the most recent date found in the group and subgroups
-    return allDates.length > 0 ? new Date(Math.max(...allDates)) : new Date(0);
+  // Obtener la fecha más reciente de un grupo (considerando sus items y subgroups)
+  const getGroupMostRecentDate = (group: IActivityHistoryGroup): Date => {
+    const itemDates = group.items.length > 0 ? [getMostRecentDate(group.items)] : [];
+    const subGroupDates = group.subGroups.map(getSubGroupMostRecentDate);
+    const allDates = [...itemDates, ...subGroupDates];
+    return allDates.length > 0
+      ? new Date(Math.max(...allDates.map((d) => d.getTime())))
+      : new Date(0);
   };
 
-  // Sort each group's items and subgroups' items by date
+  // Procesar cada grupo
   arr.forEach((group) => {
+    // Ordenar items del grupo
     group.items = sortItemsByDate(group.items);
+
+    // Ordenar items de cada subgrupo
     group.subGroups.forEach((subGroup) => {
       subGroup.items = sortItemsByDate(subGroup.items);
     });
+
+    // Ordenar subgrupos según el item más reciente en cada uno
+    group.subGroups.sort(
+      (a, b) => getSubGroupMostRecentDate(b).getTime() - getSubGroupMostRecentDate(a).getTime(),
+    );
   });
 
-  // Sort groups by the most recent date of their items and subgroups
-  return arr.sort((a, b) => getGroupMostRecentDate(b) - getGroupMostRecentDate(a));
+  // Finalmente, ordenar los grupos por su fecha más reciente
+  return arr.sort(
+    (a, b) => getGroupMostRecentDate(b).getTime() - getGroupMostRecentDate(a).getTime(),
+  );
 };