@uxland/primary-shell 6.0.6 → 7.0.0

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

@@ -1,239 +0,0 @@
-export interface VirtualScrollerOptions<T> {
-  items: T[];
-  estimatedItemHeight: number;
-  bufferSize: number; // percentage of viewport height
-}
-
-export interface VirtualScrollerState {
-  viewportHeight: number;
-  scrollTop: number;
-  totalHeight: number;
-  visibleRange: { start: number; end: number };
-  containerOffset: number;
-  visibleItems: any[];
-}
-
-export class VirtualScroller<T = any> {
-  private _itemHeights: Map<number, number> = new Map();
-  private _itemOffsets: Map<number, number> = new Map();
-  private _totalHeight = 0;
-  private _viewportHeight = 0;
-  private _scrollTop = 0;
-  private _visibleRange = { start: 0, end: 0 };
-  private _options: VirtualScrollerOptions<T>;
-  
-  private _viewport?: HTMLElement;
-  private _content?: HTMLElement;
-  private _resizeObserver?: ResizeObserver;
-  private _isScrolling = false;
-  private _scrollTimeout?: number;
-
-  constructor(options: VirtualScrollerOptions<T>) {
-    this._options = options;
-    this._initializeHeights();
-  }
-
-  // Initialize with estimated heights
-  private _initializeHeights() {
-    const { items, estimatedItemHeight } = this._options;
-    let totalHeight = 0;
-    
-    this._itemHeights.clear();
-    this._itemOffsets.clear();
-    
-    for (let i = 0; i < items.length; i++) {
-      this._itemOffsets.set(i, totalHeight);
-      this._itemHeights.set(i, estimatedItemHeight);
-      totalHeight += estimatedItemHeight;
-    }
-    
-    this._totalHeight = totalHeight;
-  }
-
-  // Setup DOM references and observers
-  setup(viewport: HTMLElement, content: HTMLElement, onStateChange: (state: VirtualScrollerState) => void) {
-    this._viewport = viewport;
-    this._content = content;
-    
-    // Update viewport height
-    this._viewportHeight = viewport.clientHeight;
-    
-    // Set initial content height
-    content.style.height = this._totalHeight + 'px';
-    
-    // Calculate initial visible range
-    this._updateVisibleRange();
-    
-    // Setup scroll listener
-    const onScroll = () => {
-      if (!this._viewport) return;
-      
-      this._scrollTop = this._viewport.scrollTop;
-      this._isScrolling = true;
-      
-      if (this._scrollTimeout) {
-        clearTimeout(this._scrollTimeout);
-      }
-      
-      this._scrollTimeout = window.setTimeout(() => {
-        this._isScrolling = false;
-        // Measure heights after scrolling stops
-        setTimeout(() => {
-          this._measureActualHeights();
-          onStateChange(this.getState());
-        }, 50);
-      }, 150);
-      
-      const oldRange = {...this._visibleRange};
-      this._updateVisibleRange();
-      
-      // Only update if visible range changed
-      if (Math.abs(oldRange.start - this._visibleRange.start) > 0 || 
-          Math.abs(oldRange.end - this._visibleRange.end) > 0) {
-        onStateChange(this.getState());
-      }
-    };
-    
-    viewport.addEventListener('scroll', onScroll);
-    
-    // Setup resize observer
-    this._resizeObserver = new ResizeObserver(() => {
-      this._viewportHeight = viewport.clientHeight;
-      this._updateVisibleRange();
-      onStateChange(this.getState());
-    });
-    
-    this._resizeObserver.observe(viewport);
-    
-    // Return cleanup function
-    return () => {
-      viewport.removeEventListener('scroll', onScroll);
-      this._resizeObserver?.disconnect();
-      if (this._scrollTimeout) {
-        clearTimeout(this._scrollTimeout);
-      }
-    };
-  }
-
-  // Update items (when data changes)
-  updateItems(items: T[]) {
-    this._options.items = items;
-    this._initializeHeights();
-    
-    if (this._content) {
-      this._content.style.height = this._totalHeight + 'px';
-    }
-    
-    this._updateVisibleRange();
-  }
-
-  // Measure actual heights of rendered items
-  private _measureActualHeights() {
-    if (!this._content || this._isScrolling) return;
-    
-    const visitElements = this._content.querySelectorAll('.visit');
-    if (visitElements.length === 0) return;
-    
-    let hasChanges = false;
-    
-    visitElements.forEach((element, index) => {
-      const actualHeight = element.getBoundingClientRect().height;
-      const globalIndex = this._visibleRange.start + index;
-      const currentHeight = this._itemHeights.get(globalIndex) || 0;
-      
-      // Only update if there's a significant difference
-      if (Math.abs(actualHeight - currentHeight) > 5) {
-        hasChanges = true;
-        this._itemHeights.set(globalIndex, actualHeight);
-      }
-    });
-    
-    if (hasChanges) {
-      // Recalculate offsets and total height
-      let totalHeight = 0;
-      for (let i = 0; i < this._options.items.length; i++) {
-        this._itemOffsets.set(i, totalHeight);
-        const height = this._itemHeights.get(i) || this._options.estimatedItemHeight;
-        totalHeight += height;
-      }
-      
-      this._totalHeight = totalHeight;
-      if (this._content) {
-        this._content.style.height = this._totalHeight + 'px';
-      }
-    }
-  }
-
-  // Calculate visible range based on scroll position
-  private _updateVisibleRange() {
-    if (!this._options.items.length || this._viewportHeight === 0) return;
-    
-    const buffer = Math.floor(this._viewportHeight * (this._options.bufferSize / 100));
-    const startOffset = Math.max(0, this._scrollTop - buffer);
-    const endOffset = this._scrollTop + this._viewportHeight + buffer;
-    
-    let start = 0;
-    let end = this._options.items.length - 1;
-    
-    // Find start index
-    for (let i = 0; i < this._options.items.length; i++) {
-      const offset = this._itemOffsets.get(i) || 0;
-      if (offset >= startOffset) {
-        start = Math.max(0, i - 1);
-        break;
-      }
-    }
-    
-    // Find end index
-    for (let i = start; i < this._options.items.length; i++) {
-      const offset = this._itemOffsets.get(i) || 0;
-      if (offset > endOffset) {
-        end = i;
-        break;
-      }
-    }
-    
-    this._visibleRange = { start, end };
-  }
-
-  // Scroll to specific item index
-  scrollToIndex(index: number, behavior: ScrollBehavior = 'smooth') {
-    if (!this._viewport) return;
-    
-    const offset = this._itemOffsets.get(index) || 0;
-    this._viewport.scrollTo({
-      top: offset,
-      behavior
-    });
-  }
-
-  // Get current state for rendering
-  getState(): VirtualScrollerState {
-    return {
-      viewportHeight: this._viewportHeight,
-      scrollTop: this._scrollTop,
-      totalHeight: this._totalHeight,
-      visibleRange: this._visibleRange,
-      containerOffset: this._itemOffsets.get(this._visibleRange.start) || 0,
-      visibleItems: this._options.items.slice(this._visibleRange.start, this._visibleRange.end + 1)
-    };
-  }
-
-  // Find closest item to a specific condition
-  findClosestIndex<K>(getValue: (item: T) => K, targetValue: K, compare: (a: K, b: K) => number): number {
-    let closestIndex = -1;
-    let closestDifference = Number.POSITIVE_INFINITY;
-
-    this._options.items.forEach((item, index) => {
-      const value = getValue(item);
-      const difference = Math.abs(compare(value, targetValue));
-      
-      if (difference < closestDifference) {
-        closestDifference = difference;
-        closestIndex = index;
-      }
-    });
-
-    return closestIndex;
-  }
-}

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

@@ -1,8 +0,0 @@
-import "./UI/timeline/activity-history-timeline";
-import "../filter/UI/active-filters-header/active-filters-header";
-import "../add/handle-error/history-full-data-error/component";
-import "../add/handle-error/history-partial-data-error/component";
-
-export const bootstrapListActivityHistoryItems = () => {
-  () => null;
-};

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

@@ -1,100 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { IActivityHistoryItem } from "../../domain/model";
-import * as diagnosticsUtils from "../../domain/validation/diagnostics/has-valid-diagnostics";
-import * as sameDiagnosticsUtils from "../../domain/validation/diagnostics/are-same-diagnostics";
-import { groupActivityHistoryItems } from "./group-history-items";
-
-vi.mock("../../domain/validation/diagnostics/has-valid-diagnostics", () => ({
-  hasValidDiagnostics: vi.fn(),
-}));
-vi.mock("../../domain/validation/diagnostics/are-same-diagnostics", () => ({
-  areSameDiagnostics: vi.fn(),
-}));
-
-const mockItem = (overrides: Partial<IActivityHistoryItem>): IActivityHistoryItem => ({
-  date: new Date().toISOString(),
-  diagnostics: [],
-  professional: {
-    id: "1",
-    role: { id: "r1" },
-    speciality: { id: "s1" },
-  },
-  ep: { id: "ep1" },
-  up: { id: "up1" },
-  center: { id: "c1" },
-  service: { id: "svc1" },
-  ...overrides,
-});
-
-describe("groupActivityHistoryItems", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("agrupa ítems que son de la misma visita y dentro de 8h", () => {
-    const date1 = new Date();
-    const date2 = new Date(date1.getTime() + 2 * 60 * 60 * 1000); // +2h
-
-    const items = [mockItem({ date: date1.toISOString() }), mockItem({ date: date2.toISOString() })];
-
-    (diagnosticsUtils.hasValidDiagnostics as any).mockReturnValue(false);
-
-    const result = groupActivityHistoryItems(items);
-
-    expect(result).toHaveLength(1);
-    expect(result[0].items).toHaveLength(2);
-  });
-
-  it("no agrupa ítems de diferente visita", () => {
-    const item1 = mockItem({ professional: { id: "1", role: { id: "r1" }, speciality: { id: "s1" } } });
-    const item2 = mockItem({ professional: { id: "2", role: { id: "r2" }, speciality: { id: "s2" } } });
-
-    (diagnosticsUtils.hasValidDiagnostics as any).mockReturnValue(false);
-
-    const result = groupActivityHistoryItems([item1, item2]);
-
-    expect(result).toHaveLength(2);
-  });
-
-  it("crea subgrupos por diagnósticos válidos e iguales", () => {
-    const diagnostics = [{ code: "A" }];
-    const item1 = mockItem({ diagnostics });
-    const item2 = mockItem({ diagnostics });
-
-    (diagnosticsUtils.hasValidDiagnostics as any).mockReturnValue(true);
-    (sameDiagnosticsUtils.areSameDiagnostics as any).mockReturnValue(true);
-
-    const result = groupActivityHistoryItems([item1, item2]);
-
-    expect(result).toHaveLength(1);
-    expect(result[0].subGroups).toHaveLength(1);
-    expect(result[0].subGroups[0].items).toHaveLength(2);
-    expect(result[0].items).toHaveLength(0); // todos se agruparon
-  });
-
-  it("deja fuera del subgrupo los ítems con diagnósticos no válidos", () => {
-    const item1 = mockItem({ diagnostics: [{ code: "A" }] });
-    const item2 = mockItem({ diagnostics: [] });
-
-    (diagnosticsUtils.hasValidDiagnostics as any).mockImplementation((d: any[]) => d.length > 0);
-    (sameDiagnosticsUtils.areSameDiagnostics as any).mockReturnValue(true);
-
-    const result = groupActivityHistoryItems([item1, item2]);
-
-    expect(result[0].subGroups).toHaveLength(1);
-    expect(result[0].subGroups[0].items).toHaveLength(1);
-    expect(result[0].items).toHaveLength(1); // el que no tiene diagnóstico válido
-  });
-
-  it("crea subgrupos distintos para diagnósticos distintos", () => {
-    const item1 = mockItem({ diagnostics: [{ code: "A" }] });
-    const item2 = mockItem({ diagnostics: [{ code: "B" }] });
-
-    (diagnosticsUtils.hasValidDiagnostics as any).mockReturnValue(true);
-    (sameDiagnosticsUtils.areSameDiagnostics as any).mockReturnValue(false);
-
-    const result = groupActivityHistoryItems([item1, item2]);
-
-    expect(result[0].subGroups).toHaveLength(2);
-  });
-});

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

@@ -1,133 +0,0 @@
-import { IActivityHistoryItem, IActivityHistoryGroup, IActivityHistorySubGroup } from "../../domain/model";
-import { areSameDiagnostics } from "../../domain/validation/diagnostics/are-same-diagnostics";
-import { hasValidDiagnostics } from "../../domain/validation/diagnostics/has-valid-diagnostics";
-
-// Cache para evitar recalcular fechas
-const dateStringCache = new Map<string, string>();
-const dateObjectCache = new Map<string, Date>();
-
-const getDateString = (dateStr: string): string => {
-  if (!dateStringCache.has(dateStr)) {
-    dateStringCache.set(dateStr, new Date(dateStr).toDateString());
-  }
-  return dateStringCache.get(dateStr)!;
-};
-
-const getDateObject = (dateStr: string): Date => {
-  if (!dateObjectCache.has(dateStr)) {
-    dateObjectCache.set(dateStr, new Date(dateStr));
-  }
-  return dateObjectCache.get(dateStr)!;
-};
-
-// Crear una clave única para cada combinación de visita
-const createVisitKey = (item: IActivityHistoryItem): string => {
-  const professionalKey = `${item.professional?.id || 'null'}-${item.professional?.role?.id || 'null'}-${item.professional?.speciality?.id || 'null'}`;
-  const locationKey = `${item.ep?.id || 'null'}-${item.up?.id || 'null'}-${item.center?.id || 'null'}-${item.service?.id || 'null'}`;
-  const dayKey = getDateString(item.date);
-  
-  return `${professionalKey}|${locationKey}|${dayKey}`;
-};
-
-const withinEightHours = (date1: string, date2: string): boolean => {
-  const time1 = getDateObject(date1).getTime();
-  const time2 = getDateObject(date2).getTime();
-  return Math.abs(time1 - time2) <= 8 * 60 * 60 * 1000; // 8 hours in milliseconds
-};
-
-function groupByValidDiagnostics(groups: IActivityHistoryGroup[]) {
-  groups.forEach((group) => {
-    const subGroups: IActivityHistorySubGroup[] = [];
-    const remainingItems: IActivityHistoryItem[] = [];
-
-    group.items.forEach((item) => {
-      const diagnostics = item.diagnostics;
-      const allDiagnosticsValid = diagnostics?.length > 0 && hasValidDiagnostics(diagnostics);
-
-      if (allDiagnosticsValid) {
-        let addedToSubGroup = false;
-
-        // Optimización: usar for...of con break para salir temprano
-        for (const subGroup of subGroups) {
-          const firstSubGroupItem = subGroup.items[0];
-
-          if (areSameDiagnostics(firstSubGroupItem.diagnostics, diagnostics)) {
-            subGroup.items.push(item);
-            addedToSubGroup = true;
-            break;
-          }
-        }
-
-        if (!addedToSubGroup) {
-          subGroups.push({
-            idSubGroup: crypto.randomUUID(),
-            items: [item],
-          });
-        }
-      } else {
-        remainingItems.push(item);
-      }
-    });
-
-    group.items = remainingItems;
-    group.subGroups = subGroups;
-  });
-}
-
-const groupActivityHistoryItems = (items: IActivityHistoryItem[]): IActivityHistoryGroup[] => {
-  if (!items?.length) return [];
-
-  // Limpiar caches al inicio
-  dateStringCache.clear();
-  dateObjectCache.clear();
-
-  // Mapa para agrupar por clave de visita
-  const visitGroups = new Map<string, IActivityHistoryGroup>();
-
-  items.forEach((item) => {
-    const visitKey = createVisitKey(item);
-    
-    if (!visitGroups.has(visitKey)) {
-      // Crear nuevo grupo
-      visitGroups.set(visitKey, {
-        idGroup: Math.random().toString(36).substr(2, 9),
-        items: [item],
-      });
-    } else {
-      // Verificar si está dentro del rango de 8 horas
-      const existingGroup = visitGroups.get(visitKey)!;
-      const firstItem = existingGroup.items[0];
-      const lastItem = existingGroup.items[existingGroup.items.length - 1];
-
-      if (
-        withinEightHours(firstItem.date, item.date) &&
-        withinEightHours(lastItem.date, item.date)
-      ) {
-        existingGroup.items.push(item);
-      } else {
-        // Si no está dentro del rango, crear un nuevo grupo con un sufijo
-        let counter = 1;
-        let newKey = `${visitKey}_${counter}`;
-        
-        while (visitGroups.has(newKey)) {
-          counter++;
-          newKey = `${visitKey}_${counter}`;
-        }
-        
-        visitGroups.set(newKey, {
-          idGroup: Math.random().toString(36).substr(2, 9),
-          items: [item],
-        });
-      }
-    }
-  });
-
-  const groups = Array.from(visitGroups.values());
-
-  // Crear subgrupos por diagnósticos iguales
-  groupByValidDiagnostics(groups);
-
-  return groups;
-};
-
-export { groupActivityHistoryItems };

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

@@ -1,93 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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());
-};