@sparted/shared-library 1.9.5 → 1.10.0

package/src/array/__tests__/left-outter-join.test.ts

@@ -1,55 +0,0 @@
-import { leftOutterJoin } from '../left-outter-join';
-
-describe('leftOutterJoin', () => {
-  it('should return left outter joined of simple arrays', () => {
-    const arr1 = [1, 2, 3];
-    const arr2 = [3, 4, 5];
-
-    const leftOutterJoinedArr = leftOutterJoin(
-      arr1,
-      arr2,
-      (item) => item,
-      (item) => item,
-    );
-
-    expect(leftOutterJoinedArr).toEqual([1, 2]);
-  });
-
-  it('should return left outter joined of complex array', () => {
-    const arr1 = [
-      { id: 1, name: 'John' },
-      { id: 2, name: 'Doe' },
-      { id: 3, name: 'Jane' },
-      { id: 4, name: 'Jack' },
-      { id: 5, name: 'Jill' },
-      { id: 6, name: 'Maurice' },
-    ];
-    const arr2 = [
-      { id: 3, name: 'Jane' },
-      { id: 4, name: 'Jack' },
-      { id: 5, name: 'Jill' },
-    ];
-
-    const leftOutterJoinedArr = leftOutterJoin(
-      arr1,
-      arr2,
-      (item) => item.id,
-      (item) => item.id,
-    );
-
-    expect(leftOutterJoinedArr).toEqual([
-      {
-        id: 1,
-        name: 'John',
-      },
-      {
-        id: 2,
-        name: 'Doe',
-      },
-      {
-        id: 6,
-        name: 'Maurice',
-      },
-    ]);
-  });
-});

package/src/array/array-to-map.ts

@@ -1,32 +0,0 @@
-export type ArrayToMapOptions<InitialValue, ModifiedValue = InitialValue> = {
-  /**
-   * Function to return the key used in the map.
-   */
-  selectKey: (value: InitialValue) => string,
-  /**
-   * Transform the initial data into another value
-   */
-  dataModifier?: (value: InitialValue, map: Readonly<Record<string, ModifiedValue>>) => ModifiedValue;
-};
-
-/**
- * Transform an array to a map.
- */
-export const arrayToMap = <InitialValue, ModifiedValue = InitialValue>(
-  array: ReadonlyArray<InitialValue>,
-  options: ArrayToMapOptions<InitialValue, ModifiedValue>,
-) => {
-  const { selectKey } = options;
-
-  return array.reduce<Record<string, ModifiedValue>>((acc, current) => {
-    const key = selectKey(current);
-    const value = options.dataModifier
-      ? options.dataModifier(current, acc)
-      : current;
-
-    return {
-      ...acc,
-      [key]: value as ModifiedValue,
-    };
-  }, {});
-};

package/src/array/get-values-from-keys.ts

@@ -1,3 +0,0 @@
-export const valuesFromKeys = <T>(keys: string[], map: Record<string, T>) => (
-  keys.map((key) => map[key])
-);

package/src/array/index.ts

@@ -1,4 +0,0 @@
-export * from './array-to-map';
-export * from './get-values-from-keys';
-export * from './left-outter-join';
-export * from './inner-join';

package/src/array/inner-join.ts

@@ -1,10 +0,0 @@
-export const innerJoin = <T, U>(
-  arr1: T[],
-  arr2: U[],
-  selectKey1: (item: T) => string | number,
-  selectKey2: (item: U) => string | number,
-) => {
-  const arr2Set = new Set(arr2.map(selectKey2));
-
-  return arr1.filter((item) => arr2Set.has(selectKey1(item)));
-};

package/src/array/left-outter-join.ts

@@ -1,10 +0,0 @@
-export const leftOutterJoin = <T, U>(
-  arr1: T[],
-  arr2: U[],
-  selectKey1: (item: T) => string | number,
-  selectKey2: (item: U) => string | number,
-) => {
-  const arr2Set = new Set(arr2.map(selectKey2));
-
-  return arr1.filter((item) => !arr2Set.has(selectKey1(item)));
-};

package/src/business/campaign/__tests__/compute-current-session.test.ts

@@ -1,189 +0,0 @@
-import { computeCurrentSession } from '../live-campaign';
-
-jest.useFakeTimers();
-
-describe('computeCurrentSession', () => {
-  it('Flexible Type with Last Session Played Less Than Session Count', () => {
-    const card = {
-      details: {
-        type: 'flexible',
-        sessionCount: 5,
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-12-31T23:59:59Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-      achievement: {
-        lastSessionPlayed: 2,
-      },
-    };
-    expect(computeCurrentSession(card as any)).toBe(3);
-  });
-
-  it('Flexible Type with Last Session Played Equal to Session Count', () => {
-    const card = {
-      details: {
-        type: 'flexible',
-        sessionCount: 5,
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-12-31T23:59:59Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-      achievement: {
-        lastSessionPlayed: 5,
-      },
-    };
-    expect(computeCurrentSession(card as any)).toBe(5);
-  });
-
-  it('Flexible Type with forceComputeCalendar=true within normal date range', () => {
-    const card = {
-      details: {
-        type: 'flexible',
-        sessionCount: 10,
-        utcStartDate: '2024-01-01T00:00:00Z',
-        utcEndDate: '2024-01-31T23:59:59Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-      achievement: {
-        lastSessionPlayed: 0,
-      },
-    };
-    jest.setSystemTime(new Date('2024-01-09T00:00:00Z'));
-    expect(computeCurrentSession(card as any, true)).toBe(7);
-  });
-
-  it('Flexible Type with forceComputeCalendar=true within extra days', () => {
-    const card = {
-      details: {
-        type: 'flexible',
-        sessionCount: 10,
-        utcStartDate: '2024-01-01T00:00:00Z',
-        utcEndDate: '2024-01-31T23:59:59Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-      achievement: {
-        lastSessionPlayed: 0,
-      },
-    };
-    jest.setSystemTime(new Date('2024-01-30T00:00:00Z'));
-    expect(computeCurrentSession(card as any, true)).toBe(10);
-  });
-
-  it('Intense Type Before Start Date', () => {
-    const card = {
-      details: {
-        type: 'intense',
-        sessionCount: 10,
-        utcStartDate: '2024-12-31T00:00:00Z',
-        utcEndDate: '2025-12-31T23:59:59Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-      achievement: {
-        lastSessionPlayed: 0,
-      },
-    };
-    jest.setSystemTime(new Date('2024-12-01T00:00:00Z'));
-    expect(computeCurrentSession(card as any)).toBe(1);
-  });
-
-  it('Intense Type Within Date Range with Enabled Weekday', () => {
-    const card = {
-      details: {
-        type: 'intense',
-        sessionCount: 10,
-        utcStartDate: '2023-03-01T00:00:00Z',
-        utcEndDate: '2023-03-31T23:59:59Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-      achievement: {
-        lastSessionPlayed: 0,
-      },
-    };
-
-    jest.setSystemTime(new Date('2023-03-06T00:00:00Z'));
-
-    expect(computeCurrentSession(card as any)).toBe(4);
-  });
-
-  it('Intense Type Within Date Range with Disabled Date', () => {
-    const card = {
-      details: {
-        type: 'intense',
-        sessionCount: 10,
-        utcStartDate: '2023-03-01T00:00:00Z',
-        utcEndDate: '2023-03-31T23:59:59Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: ['2023-03-03'],
-      },
-      achievement: {
-        lastSessionPlayed: 0,
-      },
-    };
-
-    jest.setSystemTime(new Date('2023-03-06T00:00:00Z'));
-
-    expect(computeCurrentSession(card as any)).toBe(3);
-  });
-
-  it('Intense Type Beyond End Date', () => {
-    const card = {
-      details: {
-        type: 'intense',
-        sessionCount: 10,
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-12-31T23:59:59Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-      achievement: {
-        lastSessionPlayed: 0,
-      },
-    };
-    jest.setSystemTime(new Date('2024-01-01T00:00:00Z'));
-    expect(computeCurrentSession(card as any)).toBe(10);
-  });
-
-  it('Intense Type on Weekend', () => {
-    const card = {
-      details: {
-        type: 'intense',
-        sessionCount: 10,
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-12-31T23:59:59Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-      achievement: {
-        lastSessionPlayed: 0,
-      },
-    };
-    jest.setSystemTime(new Date('2023-01-07T00:00:00Z')); // Saturday
-    expect(computeCurrentSession(card as any)).toBe(6);
-  });
-
-  it('Intense Type with forceComputeCalendar=true behaves normally', () => {
-    const card = {
-      details: {
-        type: 'intense',
-        sessionCount: 10,
-        utcStartDate: '2023-03-01T00:00:00Z',
-        utcEndDate: '2023-03-31T23:59:59Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-      achievement: {
-        lastSessionPlayed: 0,
-      },
-    };
-
-    jest.setSystemTime(new Date('2023-03-06T00:00:00Z'));
-
-    expect(computeCurrentSession(card as any, true)).toBe(4);
-  });
-});

package/src/business/campaign/__tests__/compute-intense-calendar.test.ts

@@ -1,134 +0,0 @@
-import { computeIntenseCalendar } from '../live-campaign';
-
-describe('computeIntenseCalendar', () => {
-  it('Valid Dates and Weekdays', () => {
-    const card = {
-      details: {
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-01-07T00:00:00Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-    };
-    const expectedOutput = [
-      new Date('2023-01-02'),
-      new Date('2023-01-03'),
-      new Date('2023-01-04'),
-      new Date('2023-01-05'),
-      new Date('2023-01-06'),
-    ];
-    expect(computeIntenseCalendar(card as any)).toEqual(expectedOutput);
-  });
-
-  it('Disabled Dates', () => {
-    const card = {
-      details: {
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-01-07T00:00:00Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: ['2023-01-03'],
-      },
-    };
-    const expectedOutput = [
-      new Date('2023-01-02'),
-      new Date('2023-01-04'),
-      new Date('2023-01-05'),
-      new Date('2023-01-06'),
-    ];
-    expect(computeIntenseCalendar(card as any)).toEqual(expectedOutput);
-  });
-
-  it('Start Date Equals End Date', () => {
-    const card = {
-      details: {
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-01-01T00:00:00Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-    };
-    const expectedOutput: Date[] = [];
-    expect(computeIntenseCalendar(card as any)).toEqual(expectedOutput);
-  });
-
-  it('No Enabled Weekdays', () => {
-    const card = {
-      details: {
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-01-07T00:00:00Z',
-        enabledWeekDays: [],
-        disabledDates: [],
-      },
-    };
-
-    const expectedOutput: Date[] = [];
-
-    expect(computeIntenseCalendar(card as any)).toEqual(expectedOutput);
-  });
-
-  it('All Weekdays Enabled', () => {
-    const card = {
-      details: {
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-01-07T00:00:00Z',
-        enabledWeekDays: [1, 2, 3, 4, 5, 6, 7],
-        disabledDates: [],
-      },
-    };
-    const expectedOutput = [
-      new Date('2023-01-01'),
-      new Date('2023-01-02'),
-      new Date('2023-01-03'),
-      new Date('2023-01-04'),
-      new Date('2023-01-05'),
-      new Date('2023-01-06'),
-      new Date('2023-01-07'),
-    ];
-    expect(computeIntenseCalendar(card as any)).toEqual(expectedOutput);
-  });
-
-  it('Date Range Spans Across Months', () => {
-    const card = {
-      details: {
-        utcStartDate: '2023-01-30T00:00:00Z',
-        utcEndDate: '2023-02-05T00:00:00Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: [],
-      },
-    };
-    const expectedOutput = [
-      new Date('2023-01-30'),
-      new Date('2023-01-31'),
-      new Date('2023-02-01'),
-      new Date('2023-02-02'),
-      new Date('2023-02-03'),
-    ];
-    expect(computeIntenseCalendar(card as any)).toEqual(expectedOutput);
-  });
-
-  it('All Days Disabled', () => {
-    const card = {
-      details: {
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-01-07T00:00:00Z',
-        enabledWeekDays: [1, 2, 3, 4, 5],
-        disabledDates: ['2023-01-02', '2023-01-03', '2023-01-04', '2023-01-05', '2023-01-06'],
-      },
-    };
-    const expectedOutput: Date[] = [];
-    expect(computeIntenseCalendar(card as any)).toEqual(expectedOutput);
-  });
-
-  it('Single Day Range', () => {
-    const card = {
-      details: {
-        utcStartDate: '2023-01-01T00:00:00Z',
-        utcEndDate: '2023-01-02T00:00:00Z',
-        enabledWeekDays: [1, 7],
-        disabledDates: [],
-      },
-    };
-    const expectedOutput = [new Date('2023-01-01'), new Date('2023-01-02')];
-    expect(computeIntenseCalendar(card as any)).toEqual(expectedOutput);
-  });
-});

package/src/business/campaign/__tests__/find-next-available-date.test.ts

@@ -1,82 +0,0 @@
-import { findNextAvailableDate } from '../live-campaign';
-
-describe('findNextAvailableDate', () => {
-  it('should return the current date if it is enabled and not disabled', () => {
-    const currentDate = new Date('2024-04-22'); // Monday
-    const enabledWeekDays = [1, 2, 3, 4, 5]; // Monday to Friday
-    const disabledDates: Date[] = [];
-
-    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
-    expect(result).toEqual(currentDate);
-  });
-
-  it('should skip the current date if it is not an enabled weekday', () => {
-    const currentDate = new Date('2024-04-27'); // Saturday
-    const enabledWeekDays = [1, 2, 3, 4, 5]; // Monday to Friday
-    const disabledDates: Date[] = [];
-
-    const expectedDate = new Date('2024-04-29'); // Next Monday
-    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
-    expect(result).toEqual(expectedDate);
-  });
-
-  it('should skip the current date if it is disabled', () => {
-    const currentDate = new Date('2024-04-22'); // Monday
-    const enabledWeekDays = [1, 2, 3, 4, 5];
-    const disabledDates = [new Date('2024-04-22')];
-
-    const expectedDate = new Date('2024-04-23'); // Thuesday
-    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
-    expect(result).toEqual(expectedDate);
-  });
-
-  it('should recurse until a valid date is found', () => {
-    const currentDate = new Date('2024-04-26'); // Friday
-    const enabledWeekDays = [1, 2, 3, 4, 5]; // Monday to Friday
-    const disabledDates = [
-      new Date('2024-04-26'), // Friday
-      new Date('2024-04-29'), // Monday next
-    ];
-
-    const expectedDate = new Date('2024-04-30'); // Thuesday
-    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
-    expect(result).toEqual(expectedDate);
-  });
-
-  it('should return current date if it is the end date and valid', () => {
-    const currentDate = new Date('2024-04-30'); // Thuesday
-    const enabledWeekDays = [1, 2, 3, 4, 5];
-    const disabledDates: Date[] = [];
-
-    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
-    expect(result).toEqual(currentDate);
-  });
-
-  it('should return current date if currentDate is after endDate', () => {
-    const currentDate = new Date('2024-05-01'); // Wednesday
-    const enabledWeekDays = [1, 2, 3, 4, 5];
-    const disabledDates: Date[] = [];
-
-    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
-    expect(result).toEqual(currentDate);
-  });
-
-  it('should handle empty enabledWeekDays by treating no days as enabled', () => {
-    const currentDate = new Date('2024-04-22'); // Monday
-
-    const enabledWeekDays: number[] = []; // No days enabled
-    const disabledDates: Date[] = [];
-
-    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
-    expect(result).toBeNull();
-  });
-
-  it('should handle empty disabledDates', () => {
-    const currentDate = new Date('2024-04-22'); // Monday
-    const enabledWeekDays = [1, 2, 3, 4, 5];
-    const disabledDates: Date[] = [];
-
-    const result = findNextAvailableDate(currentDate, enabledWeekDays, disabledDates);
-    expect(result).toEqual(currentDate);
-  });
-});

package/src/business/campaign/__tests__/get-calendar-dession-dates-from-campaign.test.ts

@@ -1,123 +0,0 @@
-import { CampaignDetails } from '../../types';
-import { getCalendarSessionDatesFromCampaign } from '../live-campaign';
-
-describe('getCalendarSessionDatesFromCampaign', () => {
-  const formatDate = (date: Date): string => {
-    const year = date.getFullYear();
-    const month = `0${date.getMonth() + 1}`.slice(-2);
-    const day = `0${date.getDate()}`.slice(-2);
-    return `${year}-${month}-${day}`;
-  };
-
-  it('should generate the correct number of session dates', () => {
-    const campaign: Partial<CampaignDetails> = {
-      launchDate: '2024-04-22',
-      enabledWeekDays: [1, 2, 3, 4, 5],
-      disabledDates: [],
-      nbSessions: 5,
-    };
-
-    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
-    expect(Object.keys(result)).toHaveLength(5);
-  });
-
-  it('should correctly assign session dates considering enabledWeekDays and disabledDates', () => {
-    const campaign: Partial<CampaignDetails> = {
-      launchDate: '2024-04-22',
-      enabledWeekDays: [1, 3, 5],
-      disabledDates: [new Date('2024-04-25')],
-      nbSessions: 3,
-    };
-
-    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
-
-    expect(formatDate(result[1])).toBe('2024-04-22');
-    expect(formatDate(result[2])).toBe('2024-04-24');
-    expect(formatDate(result[3])).toBe('2024-04-26');
-  });
-
-  it('should skip disabled dates and enabledWeekDays accordingly', () => {
-    const campaign: Partial<CampaignDetails> = {
-      launchDate: '2024-04-22',
-      enabledWeekDays: [2, 4],
-      disabledDates: [new Date('2024-04-23'), new Date('2024-04-25')],
-      nbSessions: 2,
-    };
-
-    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
-
-    expect(formatDate(result[1])).toBe('2024-04-30');
-    expect(formatDate(result[2])).toBe('2024-05-02');
-  });
-
-  it('should handle campaigns with no disabled dates', () => {
-    const campaign: Partial<CampaignDetails> = {
-      launchDate: '2024-04-22',
-      enabledWeekDays: [1, 2, 3, 4, 5],
-      disabledDates: [],
-      nbSessions: 3,
-    };
-
-    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
-
-    expect(formatDate(result[1])).toBe('2024-04-22');
-    expect(formatDate(result[2])).toBe('2024-04-23');
-    expect(formatDate(result[3])).toBe('2024-04-24');
-  });
-
-  it('should handle campaigns where nbSessions is zero', () => {
-    const campaign: Partial<CampaignDetails> = {
-      launchDate: '2024-04-22',
-      enabledWeekDays: [1, 2, 3, 4, 5],
-      disabledDates: [],
-      nbSessions: 0,
-    };
-
-    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
-    expect(Object.keys(result)).toHaveLength(0);
-  });
-
-  it('should correctly handle multiple disabled dates and enabledWeekDays', () => {
-    const campaign: Partial<CampaignDetails> = {
-      launchDate: '2024-04-22',
-      enabledWeekDays: [1, 3, 5],
-      disabledDates: [new Date('2024-04-22'), new Date('2024-04-24'), new Date('2024-04-26')],
-      nbSessions: 3,
-    };
-
-    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails);
-
-    expect(formatDate(result[1])).toBe('2024-04-29');
-    expect(formatDate(result[2])).toBe('2024-05-01');
-    expect(formatDate(result[3])).toBe('2024-05-03');
-  });
-
-  it('should correctly handle extra days', () => {
-    const campaign: Partial<CampaignDetails> & { extraDays: number } = {
-      launchDate: '2024-11-27',
-      enabledWeekDays: [1, 2, 3, 4, 5],
-      disabledDates: [new Date('2025-03-11')],
-      nbSessions: 2,
-      extraDays: 100,
-    };
-
-    const result = getCalendarSessionDatesFromCampaign(campaign as CampaignDetails & { extraDays: number });
-
-    expect(formatDate(result[1])).toBe('2024-11-27');
-    expect(formatDate(result[102])).toBe('2025-04-18');
-    expect(Object.keys(result)).toHaveLength(102);
-
-    // Verify that none of the disabled dates are included in the result
-    const disabledDateFormatted = formatDate(new Date('2025-03-11'));
-    Object.values(result).forEach((date) => {
-      expect(formatDate(date)).not.toBe(disabledDateFormatted);
-    });
-
-    // Verify that all dates fall on enabled weekdays
-    const { enabledWeekDays } = campaign;
-    Object.values(result).forEach((date) => {
-      const day = date.getDay();
-      expect(enabledWeekDays).toContain(day);
-    });
-  });
-});

package/src/business/campaign/index.ts

@@ -1 +0,0 @@
-export * from './live-campaign';