@sparted/shared-library 1.9.5 → 1.9.6

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

@@ -1,50 +0,0 @@
-import { arrayToMap } from '../array-to-map';
-
-type Item = {
-  id: string,
-  bar: number,
-};
-
-describe('arrayToMap', () => {
-  it('should convert array to map with item containing one key', () => {
-    const array = [{ id: 'toto' }, { id: 'bonjour' }];
-    const map = arrayToMap(array, { selectKey: ({ id }) => id });
-
-    expect(map).toStrictEqual({
-      bonjour: { id: 'bonjour' },
-      toto: { id: 'toto' },
-    });
-  });
-
-  it('should convert array to map and select right key in item', () => {
-    const array = [{ id: 'toto', bar: 1 }, { id: 'bonjour', bar: 2 }];
-    const map = arrayToMap(array, { selectKey: ({ bar }) => bar.toString() });
-
-    expect(map).toStrictEqual({
-      1: { id: 'toto', bar: 1 },
-      2: { id: 'bonjour', bar: 2 },
-    });
-  });
-
-  it('should handle data transformation', () => {
-    const item1: Item = { id: 'toto', bar: 1 };
-    const item2: Item = { id: 'bonjour', bar: 2 };
-    const array = [item1, item2];
-
-    const modifierFn = jest.fn();
-    const map = arrayToMap<Item, string>(array, {
-      selectKey: ({ bar }) => bar.toString(),
-      dataModifier: ({ id }, currentMap) => {
-        modifierFn(currentMap);
-        return id;
-      },
-    });
-
-    expect(modifierFn).toHaveBeenNthCalledWith(1, {});
-    expect(modifierFn).toHaveBeenNthCalledWith(2, { 1: 'toto' });
-    expect(map).toStrictEqual({
-      1: 'toto',
-      2: 'bonjour',
-    });
-  });
-});

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

@@ -1,14 +0,0 @@
-import { valuesFromKeys } from '../get-values-from-keys';
-
-describe('valuesFromKeys', () => {
-  it('should transform a map to an array with only selected keys', () => {
-    const map = {
-      uno: 1,
-      dos: 2,
-      tres: 3,
-      quatro: 4,
-    };
-
-    expect(valuesFromKeys(['uno', 'tres'], map)).toStrictEqual([1, 3]);
-  });
-});

package/src/array/__tests__/inner-join.test.ts

@@ -1,55 +0,0 @@
-import { innerJoin } from '../inner-join';
-
-describe('innerJoin', () => {
-  it('should return an inner join of simple arrays', () => {
-    const arr1 = [1, 2, 3];
-    const arr2 = [3, 4, 5];
-
-    const innerJoinedArr = innerJoin(
-      arr1,
-      arr2,
-      (item) => item,
-      (item) => item,
-    );
-
-    expect(innerJoinedArr).toEqual([3]);
-  });
-
-  it('should return an inner join 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 innerJoinedArr = innerJoin(
-      arr1,
-      arr2,
-      (item) => item.id,
-      (item) => item.id,
-    );
-
-    expect(innerJoinedArr).toEqual([
-      {
-        id: 3,
-        name: 'Jane',
-      },
-      {
-        id: 4,
-        name: 'Jack',
-      },
-      {
-        id: 5,
-        name: 'Jill',
-      },
-    ]);
-  });
-});

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);
-  });
-});