@sparted/shared-library 1.9.4 → 1.9.5

package/src/cdn/cdn.factory.ts

@@ -0,0 +1,70 @@
+import { buildSearchParams } from '../http/build-search-params';
+import type { CdnConfig, CdnType, TransformationQueries, TwicpicsTransformationChain } from './types';
+import { getCdnFromS3UrlFactory } from './utils/get-cdn-from-s3-url.util';
+import { getCdnUrlFactory } from './utils/get-cdn-url.util';
+import { twicpicsTransformationChainToString } from './utils/twicpics-transformations.util';
+
+export const imgixTransformationQueries: TransformationQueries = ({
+  fit,
+  width,
+  height,
+  quality,
+  compress = true,
+  devicePixelRatio,
+}) => {
+  const params = {
+    auto: compress ? 'compress,format' : undefined,
+    fit: fit === 'crop' ? 'crop' : undefined,
+    dpr: Number.isFinite(devicePixelRatio) ? devicePixelRatio : undefined,
+    h: Number.isFinite(height) ? height : undefined,
+    w: Number.isFinite(width) ? width : undefined,
+    q: quality !== undefined && quality >= 0 && quality <= 100 ? quality : undefined,
+  };
+  const searchParams = buildSearchParams(params).toString();
+
+  return searchParams ? `${searchParams}` : '';
+};
+
+export const twicpicsTransformationQueries: TransformationQueries = (params) => {
+  const quality = params.quality || 70;
+  const transformations: TwicpicsTransformationChain = [['quality', quality]];
+  const dpr = params.devicePixelRatio || 1;
+
+  const width = params.width ? Math.round(params.width * dpr) : '-';
+  const height = params.height ? Math.round(params.height * dpr) : '-';
+  const fit = params.fit || 'cover';
+
+  if (params.width !== undefined || params.height !== undefined) {
+    transformations.push([fit, `${width}x${height}`]);
+  }
+
+  if (params.output !== undefined) {
+    transformations.push(['output', params.output]);
+  }
+
+  return twicpicsTransformationChainToString(transformations);
+};
+
+/**
+ *
+ * @param type cdn provider: 'twicpics' | 'imgix'
+ * @param domain provider domain
+ * @param instanceMapper domain + the result of the instanceMapper will form the base path
+ * @param cacheVersion
+ * @returns \{ getCdnUrl, transformationQueries \}
+ */
+export const createCdn = <T extends CdnType>({ type, domain, instanceMapper, cacheVersion }: CdnConfig<T>) => {
+  const getCdnUrl = getCdnUrlFactory({
+    domain,
+    instanceMapper,
+    transformationQueries: type === 'imgix' ? imgixTransformationQueries : twicpicsTransformationQueries,
+    cacheVersion,
+  });
+
+  return {
+    getCdnUrl,
+    getCdnFromS3Url: getCdnFromS3UrlFactory({
+      getCdnUrl,
+    }),
+  };
+};

package/src/cdn/index.ts

@@ -0,0 +1,2 @@
+export { createCdn } from './cdn.factory';
+export * from './types';

package/src/cdn/types/cdn-factory.type.ts

@@ -0,0 +1,49 @@
+export type BaseUrlMapperFunc = (instanceId: string) => string;
+
+export type Transformation = {
+  fit?: 'crop' | 'contain';
+  width?: number;
+  height?: number;
+  devicePixelRatio?: number;
+  quality?: number;
+  /**
+   * Only for imgix transformations. Default is true.
+   */
+  compress?: boolean;
+  output?: 'jpeg' | 'png' | 'webp' | 'image';
+};
+
+export type CdnParams = {
+  asThumbnail?: boolean;
+  transformation?: Transformation;
+};
+
+export type TransformationQueries = (params: Transformation) => string;
+
+type TwicpicsOutputTransformation = ['output', Transformation['output']];
+
+type TwicpicsFitTransformation = ['cover' | 'crop' | 'contain', string] | ['quality', number];
+
+export type TwicpicsTransformation = TwicpicsOutputTransformation | TwicpicsFitTransformation;
+
+export type TwicpicsTransformationChain = TwicpicsTransformation[];
+
+export type GetCdnUrl = (instanceId: string, path: `/${string}`, params?: CdnParams) => string;
+
+export type GetCdnFromS3Url = (url: string, params?: CdnParams) => string;
+
+export type InstanceMapper = (instanceId: string) => string;
+
+export type CdnType = 'twicpics' | 'imgix';
+
+export type CdnConfig<T extends CdnType> = {
+  type: T;
+  domain: `https://${string}`;
+  instanceMapper: InstanceMapper;
+  cacheVersion?: T extends 'twicpics' ? number : undefined;
+};
+
+export type Cdn = {
+  getCdnUrl: GetCdnUrl;
+  getCdnFromS3Url: GetCdnFromS3Url;
+};

package/src/cdn/types/index.ts

@@ -0,0 +1 @@
+export * from './cdn-factory.type';

package/src/cdn/utils/extract-info-from-url.util.ts

@@ -0,0 +1,25 @@
+type ExtractInfoFromUrl = (url: string) =>
+| {
+  instanceId: string;
+  path: `/${string}`;
+}
+| undefined;
+
+const S3_URL_RE = /https:\/\/sparted-prod-([^.]+)\.s3(\.eu-west-1)?(\.amazonaws\.com)?(\.fr-par\.scw\.cloud)?(\/[^?]+)/;
+
+export const extractInfoFromUrl: ExtractInfoFromUrl = (url) => {
+  if (typeof url !== 'string') {
+    return undefined;
+  }
+
+  const matchS3Url = url.match(S3_URL_RE);
+
+  if (!matchS3Url) {
+    return undefined;
+  }
+
+  const instanceId = matchS3Url[1];
+  const path = matchS3Url[5] as `/${string}`;
+
+  return { instanceId, path };
+};

package/src/cdn/utils/get-cdn-from-s3-url.util.ts

@@ -0,0 +1,20 @@
+import type { GetCdnFromS3Url, GetCdnUrl } from '../types';
+import { extractInfoFromUrl } from './extract-info-from-url.util';
+
+type FactoryConfig = {
+  getCdnUrl: GetCdnUrl;
+};
+
+export function getCdnFromS3UrlFactory(config: FactoryConfig): GetCdnFromS3Url {
+  return (url, params) => {
+    const { getCdnUrl } = config;
+
+    const info = extractInfoFromUrl(url);
+    if (info === undefined) {
+      return url;
+    }
+    const { instanceId, path } = info;
+
+    return getCdnUrl(instanceId, path, params);
+  };
+}

package/src/cdn/utils/get-cdn-url.util.ts

@@ -0,0 +1,31 @@
+import type { GetCdnUrl, InstanceMapper, Transformation, TransformationQueries } from '../types';
+
+const DEFAULT_THUMBNAIL_CONFIG: Transformation = {
+  width: 300,
+  height: 300,
+};
+
+type FactoryConfig = {
+  domain: `https://${string}`;
+  instanceMapper: InstanceMapper;
+  transformationQueries: TransformationQueries;
+  cacheVersion?: number;
+};
+
+export const genCacheVersionQuery = (cacheVersion?: number) => (cacheVersion ? `v=${cacheVersion}` : '');
+
+export const getCdnUrlFactory =
+  (config: FactoryConfig): GetCdnUrl =>
+  (instanceId, path, params = {}) => {
+    const { domain, instanceMapper, transformationQueries, cacheVersion } = config;
+
+    const { transformation = params.asThumbnail ? DEFAULT_THUMBNAIL_CONFIG : {} } = params;
+
+    const transformationQuery: string = transformationQueries(transformation);
+    const cacheVersionQuery = genCacheVersionQuery(cacheVersion);
+    const hasQueryParams = [transformationQuery, cacheVersionQuery].some((query) => query !== '');
+
+    return `${domain}${instanceMapper(instanceId)}${path}${hasQueryParams ? '?' : ''}${transformationQuery}${
+      cacheVersionQuery ? `&${cacheVersionQuery}` : ''
+    }`;
+  };

package/src/cdn/utils/twicpics-transformations.util.ts

@@ -0,0 +1,9 @@
+import { TwicpicsTransformationChain } from '../types';
+
+export const twicpicsTransformationChainToString = (transformationChain: TwicpicsTransformationChain): string => {
+  if (transformationChain.length === 0) return '';
+
+  const transformations = transformationChain.map(([key, value]) => `${key}=${value}`).join('/');
+
+  return `twic=v1/${transformations}`;
+};

package/src/chrono/get-approximated-session-time.ts

@@ -0,0 +1,27 @@
+import { type GameType } from '../business/types';
+
+const DOLPHIN_CHRONO_GAMEPLAY = {
+  mcq: 27 * 1000,
+  'error-text': 27 * 1000,
+  'no-interaction': 20000,
+  'picture-spot': 15 * 1000,
+  'open-question': 73 * 1000,
+  'swiping-cards': 15 * 1000,
+  'ordering-cards': 20 * 1000 + 10000,
+};
+
+export const DOLPHIN_AVERAGE_CHRONO_GAMEPLAY =
+  Object.values(DOLPHIN_CHRONO_GAMEPLAY).reduce<number>((sum, time) => sum + time, 0) /
+  Object.keys(DOLPHIN_CHRONO_GAMEPLAY).length;
+
+export const getApproximatedSessionTime = (gameTypes: GameType[]) => {
+  const time = gameTypes.reduce<number>((sessionTime, gameType) => {
+    const gameplayTime = DOLPHIN_CHRONO_GAMEPLAY[gameType];
+
+    return sessionTime + gameplayTime;
+  }, 0);
+
+  return time;
+};
+
+export const getAverageSessionTime = (gameCount: number) => gameCount * DOLPHIN_AVERAGE_CHRONO_GAMEPLAY;

package/src/chrono/index.ts

@@ -0,0 +1 @@
+export * from './get-approximated-session-time';

package/src/color/__tests__/get-contrast-color.test.ts

@@ -0,0 +1,22 @@
+import { getContrastColor } from '../get-contrast-color';
+
+describe('getContrastColor', () => {
+  const customLight = '#f18888';
+  const customDark = '#051831';
+
+  it('should return the default light color', () => {
+    expect(getContrastColor('#000000')).toBe('#FFFFFF');
+  });
+
+  it('should return the default dark color', () => {
+    expect(getContrastColor('#FFFFFF')).toBe('#000000');
+  });
+
+  it('should return a specified light color', () => {
+    expect(getContrastColor('#000000', customLight, customDark)).toBe(customLight);
+  });
+
+  it('should return a specified dark color', () => {
+    expect(getContrastColor('#FFFFFF', customLight, customDark)).toBe(customDark);
+  });
+});

package/src/color/get-contrast-color.ts

@@ -0,0 +1,18 @@
+const DEFAULT_LIGHT_COLOR = '#FFFFFF';
+const DEFAULT_DARK_COLOR = '#000000';
+
+// Based on https://stackoverflow.com/questions/11867545/change-text-color-based-on-brightness-of-the-covered-background-area
+export const getContrastColor = (bgColor: string, lightColor: string = DEFAULT_LIGHT_COLOR, darkColor: string = DEFAULT_DARK_COLOR): string => {
+  const color = bgColor.charAt(0) === '#' ? bgColor.substring(1, 7) : bgColor;
+
+  if (color.length !== 6) {
+    throw new Error(`Invalid HEX color "${bgColor}" in sparted mail manager.`);
+  }
+
+  const r = parseInt(color.substring(0, 2), 16); // hexToR
+  const g = parseInt(color.substring(2, 4), 16); // hexToG
+  const b = parseInt(color.substring(4, 6), 16); // hexToB
+
+  // Values from https://www.w3.org/TR/AERT/#color-contrast
+  return r * 0.299 + g * 0.587 + b * 0.114 > 186 ? darkColor : lightColor;
+};

package/src/color/index.ts

@@ -0,0 +1 @@
+export * from './get-contrast-color';

package/src/crypto/__tests__/aes256.test.ts

@@ -0,0 +1,23 @@
+import { encrypt } from '../aes256';
+
+const key = '6fa979f20126cb08aa645a8f495f6d856fa979f20126cb08aa645a8f495f6d85';
+const iv = '49387a7941346c56684d43614a354b67';
+
+const data = '111222333';
+
+describe('aes-256-cbc', () => {
+  describe('encrypt', () => {
+    it('should match the expected cipher', () => {
+      const result = encrypt(data, key, iv);
+      expect(result).toBe('56457610927dc4923e2aa34cc2a79382');
+    });
+
+    it('should fail if the key is not 256 bits long', () => {
+      expect(() => encrypt(data, 'short-key', iv)).toThrow();
+    });
+
+    it('should fail if the iv is not 32 characters long', () => {
+      expect(() => encrypt(data, key, 'short-iv')).toThrow();
+    });
+  });
+});

package/src/crypto/aes256.ts

@@ -0,0 +1,22 @@
+import { encrypt as cryptoEncrypt } from 'crypto-js/aes';
+import { enc, mode, pad } from 'crypto-js';
+
+/**
+ * Encrypt data using AES-256-CBC
+ * @param data
+ * @param key Must be a 256 bits hex string
+ * @param iv Must be a 128 bits hex string
+ * @returns Encrypted data as a hex string
+ */
+function encrypt(data: string, key: string, iv: string): string {
+  if (key.length !== 64) throw new Error('Key must be 256 bits long');
+  if (iv.length !== 32) throw new Error('IV must be 128 bits long');
+  const cipher = cryptoEncrypt(data, enc.Hex.parse(key), {
+    mode: mode.CBC,
+    padding: pad.Pkcs7,
+    iv: enc.Hex.parse(iv),
+  });
+  return enc.Hex.stringify(cipher.ciphertext);
+}
+
+export { encrypt };

package/src/crypto/index.ts

@@ -0,0 +1 @@
+export { encrypt } from './aes256';

package/src/date/__tests__/get-iso-day-number.test.ts

@@ -0,0 +1,34 @@
+import { getIsoDayNumber } from '../get-iso-day-number';
+
+describe('getIsoDayNumber', () => {
+  it('returns 1..7 for Monday..Sunday', () => {
+    const cases: Array<[Date, number]> = [
+      [new Date(2023, 7, 7, 12, 0, 0), 1], // Monday 2023-08-07
+      [new Date(2023, 7, 8, 12, 0, 0), 2], // Tuesday
+      [new Date(2023, 7, 9, 12, 0, 0), 3], // Wednesday
+      [new Date(2023, 7, 10, 12, 0, 0), 4], // Thursday
+      [new Date(2023, 7, 11, 12, 0, 0), 5], // Friday
+      [new Date(2023, 7, 12, 12, 0, 0), 6], // Saturday
+      [new Date(2023, 7, 13, 12, 0, 0), 7], // Sunday
+    ];
+
+    for (const [date, expected] of cases) {
+      expect(getIsoDayNumber(date)).toBe(expected);
+    }
+  });
+
+  it('does not modify the original date', () => {
+    const date = new Date(2023, 7, 9, 12, 34, 56);
+    const originalTime = date.getTime();
+    getIsoDayNumber(date);
+    expect(date.getTime()).toBe(originalTime);
+  });
+
+  it('uses current date when no argument is provided', () => {
+    jest.useFakeTimers().setSystemTime(new Date(2023, 7, 7, 12, 0, 0)); // Monday
+    expect(getIsoDayNumber()).toBe(1);
+    jest.useRealTimers();
+  });
+});
+
+

package/src/date/__tests__/get-remaining-time.test.ts

@@ -0,0 +1,78 @@
+import { getRemainingTimeFromMs, getRemainingTimeInMsFromDate } from '../get-remaining-time';
+
+describe('getRemainingTimeInMsFromDate', () => {
+  it('should return 0 if the argument passed is not an instance of Date', () => {
+    expect(getRemainingTimeInMsFromDate('2024-12-01' as any)).toBe(0);
+    expect(getRemainingTimeInMsFromDate(null as any)).toBe(0);
+    expect(getRemainingTimeInMsFromDate(undefined as any)).toBe(0);
+    expect(getRemainingTimeInMsFromDate(123 as any)).toBe(0);
+    expect(getRemainingTimeInMsFromDate({} as any)).toBe(0);
+  });
+
+  it('should return 0 if the date is in the past', () => {
+    const pastDate = new Date(Date.now() - 1000);
+    expect(getRemainingTimeInMsFromDate(pastDate)).toBe(0);
+  });
+
+  it('should return the remaining time in milliseconds if the date is in the future', () => {
+    const futureDate = new Date(Date.now() + 5000);
+    const remainingTime = getRemainingTimeInMsFromDate(futureDate);
+
+    expect(remainingTime).toBe(5000);
+  });
+
+  it('should return 0 if the date is exactly at the present moment', () => {
+    const currentTime = Date.now();
+    const presentDate = new Date(currentTime);
+
+    jest.spyOn(global.Date, 'now').mockReturnValue(currentTime);
+
+    const remainingTime = getRemainingTimeInMsFromDate(presentDate);
+    expect(remainingTime).toBe(0);
+
+    jest.restoreAllMocks();
+  });
+});
+
+describe('getRemainingTimeFromMs', () => {
+  it('should return correct time for a full day (86400000 ms)', () => {
+    const result = getRemainingTimeFromMs(86400000);
+    expect(result).toEqual({ daysLeft: 1, hoursLeft: 0, minutesLeft: 0, secondsLeft: 0 });
+  });
+
+  it('should return correct time for one hour (3600000 ms)', () => {
+    const result = getRemainingTimeFromMs(3600000);
+    expect(result).toEqual({ daysLeft: 0, hoursLeft: 1, minutesLeft: 0, secondsLeft: 0 });
+  });
+
+  it('should return correct time for one minute (60000 ms)', () => {
+    const result = getRemainingTimeFromMs(60000);
+    expect(result).toEqual({ daysLeft: 0, hoursLeft: 0, minutesLeft: 1, secondsLeft: 0 });
+  });
+
+  it('should return correct time for one second (1000 ms)', () => {
+    const result = getRemainingTimeFromMs(1000);
+    expect(result).toEqual({ daysLeft: 0, hoursLeft: 0, minutesLeft: 0, secondsLeft: 1 });
+  });
+
+  it('should return correct time for a combination of days, hours, minutes, and seconds', () => {
+    const ms = 90061000; // 1 day, 1 hour, 1 minute, 1 second
+    const result = getRemainingTimeFromMs(ms);
+    expect(result).toEqual({ daysLeft: 1, hoursLeft: 1, minutesLeft: 1, secondsLeft: 1 });
+  });
+
+  it('should return zero for all fields when ms is 0', () => {
+    const result = getRemainingTimeFromMs(0);
+    expect(result).toEqual({ daysLeft: 0, hoursLeft: 0, minutesLeft: 0, secondsLeft: 0 });
+  });
+
+  it('should handle non-integer values gracefully', () => {
+    const result = getRemainingTimeFromMs(1234567); // 0 days, 0 hours, 20 minutes, 34 seconds
+    expect(result).toEqual({ daysLeft: 0, hoursLeft: 0, minutesLeft: 20, secondsLeft: 34 });
+  });
+
+  it('should return zero for negative input', () => {
+    const result = getRemainingTimeFromMs(-1000);
+    expect(result).toEqual({ daysLeft: 0, hoursLeft: 0, minutesLeft: 0, secondsLeft: 0 });
+  });
+});

package/src/date/__tests__/get-start-of-day.test.ts

@@ -0,0 +1,92 @@
+import { startOfDay, startOfDayLocal } from '../get-start-of-day';
+
+describe('startOfDay', () => {
+  it('should set the time of a date to 00:00:00 in local timezone', () => {
+    const date = new Date('2023-08-09T12:34:56');
+    const result = startOfDay(date);
+    const expected = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0));
+    expect(result.getTime()).toBe(expected.getTime());
+  });
+
+  it('should not modify the original date object', () => {
+    const date = new Date('2023-08-09T12:34:56');
+    const originalTime = date.getTime();
+    startOfDay(date);
+    expect(date.getTime()).toBe(originalTime);
+  });
+
+  it('should handle dates already at the start of the day', () => {
+    const date = new Date('2023-08-09T00:00:00');
+    const dateUTC = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    const result = startOfDay(dateUTC);
+    expect(result.getTime()).toBe(dateUTC.getTime());
+  });
+
+  it('should correctly handle leap year dates in local timezone', () => {
+    const date = new Date('2020-02-29T15:45:30');
+    const result = startOfDay(date);
+    const expected = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    expect(result.getTime()).toBe(expected.getTime());
+  });
+
+  it('should handle year boundaries correctly in local timezone', () => {
+    const date = new Date('2023-12-31T23:59:59');
+    const result = startOfDay(date);
+    const expected = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    expect(result.getTime()).toBe(expected.getTime());
+  });
+
+  it('should handle month boundaries correctly in local timezone', () => {
+    const date = new Date('2023-08-31T23:59:59');
+    const result = startOfDay(date);
+    const expected = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    expect(result.getTime()).toBe(expected.getTime());
+  });
+});
+
+describe('startOfDayLocal', () => {
+  it('should set the time of a date to 00:00:00 in local timezone', () => {
+    const date = new Date('2023-08-09T12:34:56');
+    const result = startOfDayLocal(date);
+    const expected = new Date(date);
+    expected.setHours(0, 0, 0, 0);
+    expect(result.getTime()).toBe(expected.getTime());
+  });
+
+  it('should not modify the original date object', () => {
+    const date = new Date('2023-08-09T12:34:56');
+    const originalTime = date.getTime();
+    startOfDayLocal(date);
+    expect(date.getTime()).toBe(originalTime);
+  });
+
+  it('should handle dates already at the start of the day', () => {
+    const date = new Date(2023, 7, 9, 0, 0, 0, 0);
+    const result = startOfDayLocal(date);
+    expect(result.getTime()).toBe(date.getTime());
+  });
+
+  it('should correctly handle leap year dates in local timezone', () => {
+    const date = new Date(2020, 1, 29, 15, 45, 30);
+    const result = startOfDayLocal(date);
+    const expected = new Date(date);
+    expected.setHours(0, 0, 0, 0);
+    expect(result.getTime()).toBe(expected.getTime());
+  });
+
+  it('should handle year boundaries correctly in local timezone', () => {
+    const date = new Date(2023, 11, 31, 23, 59, 59);
+    const result = startOfDayLocal(date);
+    const expected = new Date(date);
+    expected.setHours(0, 0, 0, 0);
+    expect(result.getTime()).toBe(expected.getTime());
+  });
+
+  it('should handle month boundaries correctly in local timezone', () => {
+    const date = new Date(2023, 7, 31, 23, 59, 59);
+    const result = startOfDayLocal(date);
+    const expected = new Date(date);
+    expected.setHours(0, 0, 0, 0);
+    expect(result.getTime()).toBe(expected.getTime());
+  });
+});

package/src/date/__tests__/is-same-date.test.ts

@@ -0,0 +1,50 @@
+import { isSameDate } from '../is-same-date';
+
+describe('isSameDate', () => {
+  it('should return true for the same date with same time zones', () => {
+    const date1 = new Date('2023-08-09T12:00:00+02:00'); // 9 August 2023
+    const date2 = new Date('2023-08-09T12:00:00+02:00'); // 9 August 2023
+    expect(isSameDate(date1, date2)).toBe(true);
+  });
+
+  it('should return true for the same date across different time zones', () => {
+    const date1 = new Date('2023-08-09T23:00:00+00:00'); // 9 August 2023 UTC
+    const date2 = new Date('2023-08-10T01:00:00+02:00'); // 10 August 2023 UTC+2, but still 9 August in UTC
+    expect(isSameDate(date1, date2)).toBe(true);
+  });
+
+  it('should return true for the same plain date', () => {
+    const date1 = new Date(2023, 7, 9); // 9 August 2023
+    const date2 = new Date(2023, 7, 9); // 9 August 2023
+    expect(isSameDate(date1, date2)).toBe(true);
+  });
+
+  it('should return false for different dates across different time zones', () => {
+    const date1 = new Date('2023-08-09T23:00:00+00:00'); // 9 August 2023 UTC
+    const date2 = new Date('2023-08-10T02:00:00+02:00'); // 10 August 2023 UTC+2, also 10 August in UTC
+    expect(isSameDate(date1, date2)).toBe(false);
+  });
+
+  it('should return false for different dates in the same time zone', () => {
+    const date1 = new Date('2023-08-09T12:00:00+02:00'); // 9 August 2023 UTC+2
+    const date2 = new Date('2023-08-10T12:00:00+02:00'); // 10 August 2023 UTC+2
+    expect(isSameDate(date1, date2)).toBe(false);
+  });
+
+  it('should return false for different plain dates', () => {
+    const date1 = new Date(2023, 7, 9); // 9 August 2023
+    const date2 = new Date(2023, 7, 10); // 10 August 2023
+    expect(isSameDate(date1, date2)).toBe(false);
+  });
+
+  it('should return true when comparing the same date with itself', () => {
+    const date = new Date('2023-08-09T12:00:00+02:00'); // 9 August 2023
+    expect(isSameDate(date, date)).toBe(true);
+  });
+
+  it('should return false if one of the dates is invalid', () => {
+    const date1 = new Date('Invalid Date');
+    const date2 = new Date('2023-08-09T12:00:00+02:00'); // 9 August 2023
+    expect(isSameDate(date1, date2)).toBe(false);
+  });
+});