@sparted/shared-library 1.9.4 → 1.9.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sparted/shared-library",
-  "version": "1.9.4",
+  "version": "1.9.5",
   "repository": "git@github.com:Sparted/shared-library.git",
   "author": {
     "name": "Sparted",
@@ -14,12 +14,58 @@
     "**/*",
     "**/**"
   ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint .",
+    "clean": "rm -rf ./dist",
+    "build": "yarn clean && rollup --config rollup.config.ts --configPlugin typescript2 && node -e \"const pkg = require('./package.json'); const clean = { name: pkg.name, version: pkg.version, repository: pkg.repository, author: pkg.author, license: pkg.license, module: pkg.module, main: pkg.main, files: pkg.files, dependencies: pkg.dependencies, publishConfig: pkg.publishConfig }; require('fs').writeFileSync('./dist/package.json', JSON.stringify(clean, null, 2));\"",
+    "build-and-publish": "yarn test && yarn build && (cd ./dist && npm publish --registry=https://registry.npmjs.org)"
+  },
+  "devDependencies": {
+    "@types/crypto-js": "^4.2.2",
+    "@types/glob": "^8.0.0",
+    "@types/jest": "^29.0.3",
+    "@types/ungap__structured-clone": "^0.3.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "glob": "^8.0.3",
+    "jest": "^29.6.1",
+    "jest-environment-jsdom": "^29.0.3",
+    "jest-extended": "^3.1.0",
+    "jest-fetch-mock": "^3.0.3",
+    "prettier": "2",
+    "rollup": "^2.79.1",
+    "rollup-plugin-typescript2": "^0.34.0",
+    "ts-jest": "^29.0.2",
+    "tslib": "^2.4.0",
+    "typescript": "^4.8.3"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "ts"
+    ],
+    "setupFilesAfterEnv": [
+      "jest-extended/all"
+    ],
+    "rootDir": ".",
+    "testRegex": [
+      ".*\\.test\\.ts$"
+    ],
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    }
+  },
   "dependencies": {
     "@ungap/structured-clone": "^1.2.0",
     "crypto-js": "^4.2.0",
     "ts-essentials": "^9.4.1"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/"
   }
-}
+}

package/rollup.config.ts

@@ -0,0 +1,19 @@
+import { glob } from 'glob';
+import typescript from 'rollup-plugin-typescript2';
+
+export default {
+  input: glob.sync('./src/**/index.ts'),
+  plugins: [
+    typescript({
+      exclude: ['**/__tests__', '**/*.test.ts'],
+    }),
+  ],
+  output: [
+    {
+      dir: 'dist',
+      format: 'cjs',
+      sourcemap: true,
+      preserveModules: true, // Keep directory structure and files
+    },
+  ],
+};

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

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

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

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

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

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

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

package/src/array/index.ts

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

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

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

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

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