@uxland/primary-shell 6.0.6 → 7.0.0

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/diagnostics-filter-spec.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { DiagnosticCodeSpec } from "./diagnostics-filter-spec";
-import { IActivityHistoryItem } from "../model";
-
-describe("DiagnosticCodeSpec", () => {
-  it("should return true if allowedCodes is empty", () => {
-    const spec = new DiagnosticCodeSpec([]);
-    const item: IActivityHistoryItem = {
-      diagnostics: [{ codi: "E11", descripcio: "Diabetes" }],
-    };
-    expect(spec.isSatisfiedBy(item)).toBe(true);
-  });
-
-  it("should return true if item has at least one matching diagnostic code", () => {
-    const spec = new DiagnosticCodeSpec(["I10", "E11"]);
-    const item: IActivityHistoryItem = {
-      diagnostics: [
-        { codi: "Z99", descripcio: "No relevante" },
-        { codi: "E11", descripcio: "Diabetes" },
-      ],
-    };
-    expect(spec.isSatisfiedBy(item)).toBe(true);
-  });
-
-  it("should return false if item has diagnostics but none match", () => {
-    const spec = new DiagnosticCodeSpec(["J00", "K52"]);
-    const item: IActivityHistoryItem = {
-      diagnostics: [
-        { codi: "E11", descripcio: "Diabetes" },
-        { codi: "I10", descripcio: "Hipertensió" },
-      ],
-    };
-    expect(spec.isSatisfiedBy(item)).toBe(false);
-  });
-
-  it("should return false if item has no diagnostics", () => {
-    const spec = new DiagnosticCodeSpec(["E11"]);
-    const item: IActivityHistoryItem = {
-      diagnostics: undefined,
-    };
-    expect(spec.isSatisfiedBy(item)).toBe(false);
-  });
-
-  it("should return false if item.diagnostics is an empty array", () => {
-    const spec = new DiagnosticCodeSpec(["E11"]);
-    const item: IActivityHistoryItem = {
-      diagnostics: [],
-    };
-    expect(spec.isSatisfiedBy(item)).toBe(false);
-  });
-
-  it("should be case-sensitive by default (E11 !== e11)", () => {
-    const spec = new DiagnosticCodeSpec(["e11"]);
-    const item: IActivityHistoryItem = {
-      diagnostics: [{ codi: "E11", descripcio: "Diabetes" }],
-    };
-    expect(spec.isSatisfiedBy(item)).toBe(false);
-  });
-});

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/diagnostics-filter-spec.ts

@@ -1,18 +0,0 @@
-import { IActivityHistoryItem } from "../model";
-import { Spec } from "./spec";
-
-export class DiagnosticCodeSpec extends Spec<IActivityHistoryItem> {
-  constructor(private diagnosticCodes: string[]) {
-    super();
-  }
-
-  isSatisfiedBy(item: IActivityHistoryItem): boolean {
-    if (!this.diagnosticCodes?.length) {
-      return true; // No se filtra si no se proporcionan códigos
-    }
-
-    const itemDiagnostics = item.diagnostics ?? [];
-
-    return itemDiagnostics.some((d) => this.diagnosticCodes.includes(d.codi));
-  }
-}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/false-spec.ts

@@ -1,8 +0,0 @@
-import { IActivityHistoryItem } from "../model";
-import { Spec } from "./spec";
-
-export class FalseSpec extends Spec<IActivityHistoryItem> {
-  isSatisfiedBy(): boolean {
-    return false;
-  }
-}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/own-spec.ts

@@ -1,14 +0,0 @@
-import { IUserInfo } from "../../../../../features/get-user-info/model";
-import { shellApi } from "../../../../../api/api";
-import { IActivityHistoryItem } from "../model";
-import { Spec } from "./spec";
-
-export class OwnSpec extends Spec<IActivityHistoryItem> {
-  constructor(public context: IActivityHistoryItem) {
-    super();
-  }
-  isSatisfiedBy(context: IActivityHistoryItem): boolean {
-    const userInfo = shellApi.globalStateManager.getData("userInfo") as IUserInfo;
-    return context?.professional?.id === userInfo?.userId;
-  }
-}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/prop-path-spec.ts

@@ -1,19 +0,0 @@
-import { IActivityHistoryItem } from "../model";
-import { Spec } from "./spec";
-
-export class PropPathSpec extends Spec<IActivityHistoryItem> {
-  constructor(
-    public propPath: string[],
-    private value: any,
-  ) {
-    super();
-  }
-
-  isSatisfiedBy(context: IActivityHistoryItem): boolean {
-    // Reducir el context siguiendo el path hasta llegar al valor final
-    const propValue = this.propPath.reduce((acc, key) => acc?.[key], context);
-
-    // Comparar con el valor esperado
-    return propValue === this.value;
-  }
-}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/relevant-spec.ts

@@ -1,11 +0,0 @@
-import { IActivityHistoryItem } from "../model";
-import { Spec } from "./spec";
-
-export class RelevantSpec extends Spec<IActivityHistoryItem> {
-  constructor(public context: IActivityHistoryItem) {
-    super();
-  }
-  isSatisfiedBy(context: IActivityHistoryItem): boolean {
-    return context?.relevant ?? false;
-  }
-}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/relevant.spec.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { IActivityHistoryItem } from "../model";
-import { RelevantSpec } from "./relevant-spec";
-
-describe("RelevantSpec", () => {
-  it("should return true if the item is relevant", () => {
-    const activityItem: IActivityHistoryItem = {
-      id: "1",
-      date: "2025-02-25",
-      relevant: true,
-      professional: { id: "user123", name: "John Doe" },
-      diagnostics: [],
-      center: { id: "center1", name: "Center A" },
-      up: { id: "up1", name: "Up A" },
-      ep: { id: "ep1", name: "EP A" },
-      service: { id: "service1", name: "Service A" },
-      componentFactory: () => document.createElement("div"),
-    };
-
-    const spec = new RelevantSpec(activityItem);
-    expect(spec.isSatisfiedBy(activityItem)).toBe(true);
-  });
-
-  it("should return false if the item is not relevant", () => {
-    const activityItem: IActivityHistoryItem = {
-      id: "2",
-      date: "2025-02-25",
-      relevant: false,
-      professional: { id: "user123", name: "John Doe" },
-      diagnostics: [],
-      center: { id: "center1", name: "Center A" },
-      up: { id: "up1", name: "Up A" },
-      ep: { id: "ep1", name: "EP A" },
-      service: { id: "service1", name: "Service A" },
-      componentFactory: () => document.createElement("div"),
-    };
-
-    const spec = new RelevantSpec(activityItem);
-    expect(spec.isSatisfiedBy(activityItem)).toBe(false);
-  });
-
-  it("should return false if the relevant field is undefined", () => {
-    const activityItem: IActivityHistoryItem = {
-      id: "3",
-      date: "2025-02-25",
-      relevant: undefined,
-      professional: { id: "user123", name: "John Doe" },
-      diagnostics: [],
-      center: { id: "center1", name: "Center A" },
-      up: { id: "up1", name: "Up A" },
-      ep: { id: "ep1", name: "EP A" },
-      service: { id: "service1", name: "Service A" },
-      componentFactory: () => document.createElement("div"),
-    };
-
-    const spec = new RelevantSpec(activityItem);
-    expect(spec.isSatisfiedBy(activityItem)).toBe(false);
-  });
-});

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/search-string-spec.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { IActivityHistoryItem, TSearchActivityHistoryItemPredicate } from "../model";
-import { SearchStringSpec } from "./search-string-spec";
-import { propContainsString } from "../../../utils/prop-contains-string";
-
-// Mocking the propContainsString function to simulate behavior
-vi.mock("../../../utils/prop-contains-string", () => ({
-  propContainsString: vi.fn(),
-}));
-
-describe("SearchStringSpec", () => {
-  let searchString: string;
-  let searchPredicate: TSearchActivityHistoryItemPredicate;
-  let item: IActivityHistoryItem;
-
-  beforeEach(() => {
-    // Default searchPredicate mock function
-    searchPredicate = vi.fn();
-
-    // Default mock item to test with
-    item = {
-      relevant: true,
-      professional: {
-        name: "John Doe",
-        speciality: { description: "Speciality1" },
-        role: { description: "Role1" },
-      },
-      center: { description: "Center1" },
-      service: { description: "Service1" },
-      diagnostics: [{ id: "123", description: "Diagnostic1" }],
-      up: { description: "Up1" },
-      ep: { description: "Ep1" },
-    } as IActivityHistoryItem;
-  });
-
-  it("should return true if searchString is empty or null", () => {
-    const spec = new SearchStringSpec("", searchPredicate);
-
-    expect(spec.isSatisfiedBy(item)).toBe(true); // should always return true
-  });
-
-  it("should return true if searchPredicate is satisfied", () => {
-    // Mock the searchPredicate to return true
-    searchPredicate.mockReturnValueOnce(true);
-    const spec = new SearchStringSpec("searchString", searchPredicate);
-
-    expect(spec.isSatisfiedBy(item)).toBe(true); // searchPredicate is true
-  });
-
-  it("should return false if searchPredicate is not satisfied", () => {
-    // Mock the searchPredicate to return false
-    searchPredicate.mockReturnValueOnce(false);
-    const spec = new SearchStringSpec("searchString", searchPredicate);
-
-    expect(spec.isSatisfiedBy(item)).toBe(false); // searchPredicate is false
-  });
-
-  it("should return true if any of the common fields match searchString", () => {
-    searchString = "Center1";
-
-    // Mocking propContainsString to return true if the center description matches
-    (propContainsString as vi.Mock).mockReturnValueOnce(true);
-    const spec = new SearchStringSpec(searchString, searchPredicate);
-
-    expect(spec.isSatisfiedBy(item)).toBe(true); // Center matches the searchString
-  });
-
-  it("should return false if no common fields or searchPredicate match", () => {
-    searchString = "nonexistent";
-
-    // Mocking propContainsString to return false for all fields
-    (propContainsString as vi.Mock).mockReturnValue(false);
-    const spec = new SearchStringSpec(searchString, searchPredicate);
-
-    expect(spec.isSatisfiedBy(item)).toBe(false); // No matches in common fields
-  });
-
-  it("should return true if searchString matches multiple fields", () => {
-    searchString = "John";
-
-    // Mocking propContainsString to return true for the professional name
-    (propContainsString as vi.Mock).mockReturnValueOnce(true);
-    const spec = new SearchStringSpec(searchString, searchPredicate);
-
-    expect(spec.isSatisfiedBy(item)).toBe(true); // Professional name matches
-  });
-
-  it("should call commonFieldsSearchPredicate and the searchPredicate with the correct arguments", () => {
-    searchString = "searchString";
-
-    // Mocking propContainsString
-    (propContainsString as vi.Mock).mockReturnValue(false); // simulating no matches in common fields
-    const spySearchPredicate = vi.fn();
-    const spec = new SearchStringSpec(searchString, spySearchPredicate);
-
-    // Simulate the searchPredicate call
-    spec.isSatisfiedBy(item);
-
-    // Verify the commonFieldsSearchPredicate is called
-    expect(propContainsString).toHaveBeenCalled();
-
-    // Verify the searchPredicate is called with the correct arguments
-    expect(spySearchPredicate).toHaveBeenCalledWith(searchString.toLowerCase(), item);
-  });
-  it("should not throw if some nested properties are null or undefined", () => {
-    const partialItem = {
-      relevant: true,
-      professional: null,
-      center: null,
-      service: undefined,
-      diagnostics: null,
-    } as unknown as IActivityHistoryItem;
-
-    searchString = "test";
-    (propContainsString as vi.Mock).mockReturnValue(false);
-    const spec = new SearchStringSpec(searchString, searchPredicate);
-
-    expect(() => spec.isSatisfiedBy(partialItem)).not.toThrow();
-  });
-});

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/search-string-spec.ts

@@ -1,50 +0,0 @@
-import { IActivityHistoryItem, TSearchActivityHistoryItemPredicate } from "../model";
-import { Spec } from "./spec";
-import { propContainsString } from "../../../utils/prop-contains-string";
-
-const commonFieldsSearchPredicate = (item: IActivityHistoryItem, searchString: string) => {
-  const professionalNameContainsSearchString =
-    item.professional?.name && propContainsString(item.professional?.name, searchString);
-  const centerNameContainsSearchString = item.center?.description && propContainsString(item.center.description, searchString);
-  const specialityNameContainsSearchString =
-    item.professional?.speciality?.description && propContainsString(item.professional?.speciality.description, searchString);
-  const roleNameContainsSearchString =
-    item.professional?.role?.description && propContainsString(item.professional?.role.description, searchString);
-  const serviceNameContainsSearchString = item.service?.description && propContainsString(item.service.description, searchString);
-  const diagnosticsMatch = item.diagnostics?.some(
-    (diagnostic) => propContainsString(diagnostic.descripcio, searchString),
-  );
-  return (
-    professionalNameContainsSearchString ||
-    centerNameContainsSearchString ||
-    specialityNameContainsSearchString ||
-    roleNameContainsSearchString ||
-    serviceNameContainsSearchString ||
-    diagnosticsMatch
-  );
-};
-
-export class SearchStringSpec extends Spec<IActivityHistoryItem> {
-  constructor(
-    public searchString: string,
-    public searchPredicate: TSearchActivityHistoryItemPredicate,
-  ) {
-    super();
-  }
-
-  isSatisfiedBy(context: IActivityHistoryItem): boolean {
-    // Si searchString está vacío o solo tiene espacios, no filtramos y devolvemos true
-    if (!this.searchString?.trim()) {
-      return true;
-    }
-
-    // Verificamos coincidencias en los campos comunes
-    const matchesCommonFields = commonFieldsSearchPredicate(context, this.searchString);
-
-    // Verificamos coincidencias con el searchPredicate
-    const matchesSearchPredicate = this.searchPredicate ? this.searchPredicate(this.searchString.toLowerCase(), context) : false;
-
-    // Aseguramos que siempre se retorne un valor booleano
-    return !!(matchesCommonFields || matchesSearchPredicate);
-  }
-}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/spec.ts

@@ -1,54 +0,0 @@
-export interface ISpec<TContext> {
-  isSatisfiedBy(context: TContext): boolean;
-  and(spec: ISpec<TContext>): ISpec<TContext>;
-  or(spec: ISpec<TContext>): ISpec<TContext>;
-  not(): ISpec<TContext>;
-}
-
-
-export abstract class Spec<TContext> implements ISpec<TContext> {
-  abstract isSatisfiedBy(context: TContext): boolean;
-  and(spec: ISpec<TContext>): ISpec<TContext> {
-    return new AndSpec(this as unknown as ISpec<TContext>, spec);
-  }
-    or(spec: ISpec<TContext>): ISpec<TContext> {
-        return new OrSpec(this as unknown as ISpec<TContext>, spec);
-    }
-    not(): ISpec<TContext> {
-      return new NotSpec(this as unknown as ISpec<TContext>);
-    }
-}
-export class AndSpec<TContext> extends Spec<TContext> {
-  constructor(
-    private left: ISpec<TContext>,
-    private right: ISpec<TContext>,
-  ) {
-    super();
-  }
-  isSatisfiedBy(context: TContext): boolean {
-    return this.left.isSatisfiedBy(context) && this.right.isSatisfiedBy(context);
-  }
-}
-
-export class OrSpec<TContext> extends Spec<TContext> {
-  constructor(
-    private left: ISpec<TContext>,
-    private right: ISpec<TContext>,
-  ) {
-    super();
-  }
-
-  isSatisfiedBy(context: TContext): boolean {
-    return this.left.isSatisfiedBy(context) || this.right.isSatisfiedBy(context);
-  }
-}
-
-export class NotSpec<TContext> extends Spec<TContext> {
-  constructor(private spec: ISpec<TContext>) {
-    super();
-  }
-
-  isSatisfiedBy(context: TContext): boolean {
-    return !this.spec.isSatisfiedBy(context);
-  }
-}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/true-spec.ts

@@ -1,8 +0,0 @@
-import { IActivityHistoryItem } from "../model";
-import { Spec } from "./spec";
-
-export class TrueSpec extends Spec<IActivityHistoryItem> {
-  isSatisfiedBy(): boolean {
-    return true;
-  }
-}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/type-spec.ts

@@ -1,26 +0,0 @@
-import { IActivityHistoryCustomFilterGroup } from "../../filter";
-import { IActivityHistoryItem } from "../model";
-import { FalseSpec } from "./false-spec";
-import { Spec } from "./spec";
-
-export class TypeSpec extends Spec<IActivityHistoryItem> {
-  constructor(public itemType: string) {
-    super();
-  }
-  isSatisfiedBy(context: IActivityHistoryItem): boolean {
-    return context?.type === this.itemType;
-  }
-}
-
-export class ComposedTypeSpec extends Spec<IActivityHistoryItem> {
-  constructor(public filters: IActivityHistoryCustomFilterGroup[]) {
-    super();
-  }
-  isSatisfiedBy(item: IActivityHistoryItem): boolean {
-    const enabledGroupTypes = this.filters.filter((f) => f.enabled).map((f) => f.id);
-    const finalSpec = enabledGroupTypes.reduce((acc, groupId) => {
-      return acc.or(new TypeSpec(groupId));
-    }, new FalseSpec());
-    return finalSpec.isSatisfiedBy(item);
-  }
-}

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/up-filter-spec.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { IActivityHistoryItem } from '../model';
-import { UpFilterSpec } from './up-filter-spec';
-
-
-describe('UpFilterSpec', () => {
-  const makeItem = (upId: string | undefined, description: string | undefined): IActivityHistoryItem => ({
-    up: { id: upId, description },
-  } as IActivityHistoryItem);
-
-  it('should return true if up filter is empty', () => {
-    const spec = new UpFilterSpec([]);
-    const item =  makeItem('00461', 'EAP Barcelona 2D - Universitat');
-
-    expect(spec.isSatisfiedBy(item)).toBe(true);
-  });
-
-  it('should return true if item has at least one matching up', () => {
-    const spec = new UpFilterSpec(['00001', '00461', '99999']);
-    const item = makeItem('00461', 'EAP Barcelona 2D - Universitat');
-
-    expect(spec.isSatisfiedBy(item)).toBe(true);
-  });
-
-  it('should return false if item has up but none match', () => {
-    const spec = new UpFilterSpec(['00001', '00002', '00003']);
-    const item = makeItem('00461', 'EAP Barcelona 2D - Universitat');
-
-    expect(spec.isSatisfiedBy(item)).toBe(false);
-  });
-
-  it('should return false if item has no up', () => {
-    const spec = new UpFilterSpec(['a']);
-    const item = makeItem(undefined, undefined);
-
-    expect(spec.isSatisfiedBy(item)).toBe(false);
-  });
-});

package/src/internal-plugins/activity-history/activity-history-item/domain/specs/up-filter-spec.ts

@@ -1,18 +0,0 @@
-import { IActivityHistoryItem } from "../model";
-import { Spec } from "./spec";
-
-export class UpFilterSpec extends Spec<IActivityHistoryItem> {
-  constructor(private upIds: string[]) {
-    super();
-  }
-
-  isSatisfiedBy(item: IActivityHistoryItem): boolean {
-    if (!this.upIds?.length) {
-      return true; // No se filtra si no se proporcionan códigos
-    }
-
-    const itemUp = item.up ?? null;
-
-    return this.upIds.some((upId) => itemUp.id === upId);
-  }
-}

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/are-same-diagnostics.test.ts

@@ -1,48 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { areSameDiagnostics } from "./are-same-diagnostics";
-
-describe("areSameDiagnostics", () => {
-  it("returns true for identical diagnostics in same order", () => {
-    const d1 = [{ codi: "A" }, { codi: "B" }];
-    const d2 = [{ codi: "A" }, { codi: "B" }];
-    expect(areSameDiagnostics(d1, d2)).toBe(true);
-  });
-
-  it("returns true for identical diagnostics in different order", () => {
-    const d1 = [{ codi: "B" }, { codi: "A" }];
-    const d2 = [{ codi: "A" }, { codi: "B" }];
-    expect(areSameDiagnostics(d1, d2)).toBe(true);
-  });
-
-  it("returns false if one diagnostic has extra item", () => {
-    const d1 = [{ codi: "A" }, { codi: "B" }];
-    const d2 = [{ codi: "A" }];
-    expect(areSameDiagnostics(d1, d2)).toBe(false);
-  });
-
-  it("returns false if codes are different", () => {
-    const d1 = [{ codi: "A" }, { codi: "B" }];
-    const d2 = [{ codi: "A" }, { codi: "C" }];
-    expect(areSameDiagnostics(d1, d2)).toBe(false);
-  });
-
-  it("returns true for both empty arrays", () => {
-    expect(areSameDiagnostics([], [])).toBe(true);
-  });
-
-  it("returns false if one is empty and the other is not", () => {
-    expect(areSameDiagnostics([], [{ codi: "X" }])).toBe(false);
-  });
-
-  it("returns true for duplicated codes in both arrays", () => {
-    const d1 = [{ codi: "A" }, { codi: "A" }];
-    const d2 = [{ codi: "A" }, { codi: "A" }];
-    expect(areSameDiagnostics(d1, d2)).toBe(true);
-  });
-
-  it("returns false if duplicated codes differ in count", () => {
-    const d1 = [{ codi: "A" }, { codi: "A" }];
-    const d2 = [{ codi: "A" }];
-    expect(areSameDiagnostics(d1, d2)).toBe(false);
-  });
-});

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/are-same-diagnostics.ts

@@ -1,15 +0,0 @@
-import { IActivityHistoryDiagnostic } from "../../model";
-
-export const areSameDiagnostics = (
-  diag1: IActivityHistoryDiagnostic[],
-  diag2: IActivityHistoryDiagnostic[],
-): boolean => {
-  if (diag1.length !== diag2.length) {
-    return false;
-  }
-
-  const sortedDiag1 = diag1.map((d) => d.codi).sort();
-  const sortedDiag2 = diag2.map((d) => d.codi).sort();
-
-  return sortedDiag1.every((id, index) => id === sortedDiag2[index]);
-};

package/src/internal-plugins/activity-history/activity-history-item/domain/validation/diagnostics/has-valid-diagnostics.test.ts

@@ -1,79 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { hasValidDiagnostic, hasValidDiagnostics } from "./has-valid-diagnostics";
-
-interface IActivityHistoryDiagnostic {
-  codi?: any;
-  cataleg?: any;
-  descripcio?: any;
-}
-
-describe("hasValidDiagnostic", () => {
-  it("returns true for a valid diagnostic", () => {
-    const diag: IActivityHistoryDiagnostic = {
-      codi: "A123",
-      cataleg: "ICD-10",
-      descripcio: "Dolor lumbar",
-    };
-    expect(hasValidDiagnostic(diag)).toBe(true);
-  });
-
-  it("returns false for null", () => {
-    expect(hasValidDiagnostic(null as any)).toBe(false);
-  });
-
-  it("returns false for undefined", () => {
-    expect(hasValidDiagnostic(undefined as any)).toBe(false);
-  });
-
-  it("returns false if one property is missing", () => {
-    const diag: IActivityHistoryDiagnostic = {
-      codi: "B123",
-      cataleg: "CIM10",
-      // description missing
-    };
-    expect(hasValidDiagnostic(diag)).toBe(false);
-  });
-
-  it("returns false if any property is not a string", () => {
-    const diag: IActivityHistoryDiagnostic = {
-      codi: 123,
-      cataleg: "ICD",
-      descripcio: "Texto",
-    };
-    expect(hasValidDiagnostic(diag)).toBe(false);
-  });
-});
-
-describe("hasValidDiagnostics", () => {
-  it("returns true for a valid array of diagnostics", () => {
-    const diagnostics = [
-      { codi: "A", cataleg: "X", descripcio: "D1" },
-      { codi: "B", cataleg: "Y", descripcio: "D2" },
-    ];
-    expect(hasValidDiagnostics(diagnostics)).toBe(true);
-  });
-
-  it("returns true for null input", () => {
-    expect(hasValidDiagnostics(null as any)).toBe(true);
-  });
-
-  it("returns true for undefined input", () => {
-    expect(hasValidDiagnostics(undefined as any)).toBe(true);
-  });
-
-  it("returns false if not all diagnostics are valid", () => {
-    const diagnostics = [
-      { codi: "A", cataleg: "X", descripcio: "D1" },
-      { codi: "", cataleg: 42, descripcio: null },
-    ];
-    expect(hasValidDiagnostics(diagnostics)).toBe(false);
-  });
-
-  it("returns false if diagnostics is not an array", () => {
-    expect(hasValidDiagnostics({} as any)).toBe(false);
-  });
-
-  it("returns true for empty array", () => {
-    expect(hasValidDiagnostics([])).toBe(true);
-  });
-});