@sparted/shared-library 1.9.3 → 1.9.5

package/src/date/__tests__/shift-date-by.test.ts

@@ -0,0 +1,76 @@
+import { shiftDateBy } from '../shift-date-by';
+
+describe('shiftDateBy', () => {
+  test('should add days, hours, minutes, and seconds to a given date', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const options = { days: 1, hours: 2, minutes: 30, seconds: 45 };
+    const result = shiftDateBy(options, initialDate);
+    expect(result.toISOString()).toBe('2024-11-15T02:30:45.000Z');
+  });
+
+  test('should remove days, hours, minutes, and seconds to a given date', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const options = { days: -1, hours: -2, minutes: -30, seconds: -45 };
+    const result = shiftDateBy(options, initialDate);
+    expect(result.toISOString()).toBe('2024-11-12T21:29:15.000Z');
+  });
+
+  test('should handle adding only days to a date', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const result = shiftDateBy({ days: 5 }, initialDate);
+    expect(result.toISOString()).toBe('2024-11-19T00:00:00.000Z');
+  });
+
+  test('should handle removing only days to a date', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const result = shiftDateBy({ days: -5 }, initialDate);
+    expect(result.toISOString()).toBe('2024-11-09T00:00:00.000Z');
+  });
+
+  test('should handle adding only hours to a date', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const result = shiftDateBy({ hours: 3 }, initialDate);
+    expect(result.toISOString()).toBe('2024-11-14T03:00:00.000Z');
+  });
+
+  test('should handle removing only hours to a date', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const result = shiftDateBy({ hours: -3 }, initialDate);
+    expect(result.toISOString()).toBe('2024-11-13T21:00:00.000Z');
+  });
+
+  test('should handle adding only minutes to a date', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const result = shiftDateBy({ minutes: 45 }, initialDate);
+    expect(result.toISOString()).toBe('2024-11-14T00:45:00.000Z');
+  });
+
+  test('should handle removing only minutes to a date', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const result = shiftDateBy({ minutes: -45 }, initialDate);
+    expect(result.toISOString()).toBe('2024-11-13T23:15:00.000Z');
+  });
+
+  test('should handle adding only seconds to a date', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const result = shiftDateBy({ seconds: 30 }, initialDate);
+    expect(result.toISOString()).toBe('2024-11-14T00:00:30.000Z');
+  });
+
+  test('should handle removing only seconds to a date', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const result = shiftDateBy({ seconds: -30 }, initialDate);
+    expect(result.toISOString()).toBe('2024-11-13T23:59:30.000Z');
+  });
+
+  test('should return the same date if no options are provided', () => {
+    const initialDate = new Date('2024-11-14T00:00:00Z');
+    const result = shiftDateBy({}, initialDate);
+    expect(result.toISOString()).toBe('2024-11-14T00:00:00.000Z');
+  });
+
+  test('should return the current date if nothing is provided', () => {
+    const result = shiftDateBy();
+    expect(result.getTime()).toBeCloseTo(new Date().getTime(), -3);
+  });
+});

package/src/date/__tests__/to-utc-date-string.test.ts

@@ -0,0 +1,28 @@
+import { toUTCDateString } from '../to-utc-date-string';
+
+describe('toUTCDateString', () => {
+  it('should convert a date to UTC date string (same day)', () => {
+    const date = new Date('2023-08-09T12:00:00+02:00');
+    expect(toUTCDateString(date)).toBe('2023-08-09');
+  });
+
+  it('should convert a date to UTC date string (crossing midnight)', () => {
+    const date = new Date('2023-08-09T23:00:00+02:00');
+    expect(toUTCDateString(date)).toBe('2023-08-09');
+  });
+
+  it('should handle dates in UTC correctly', () => {
+    const date = new Date('2023-08-09T00:00:00+00:00');
+    expect(toUTCDateString(date)).toBe('2023-08-09');
+  });
+
+  it('should convert a date at the end of a day to correct UTC date string', () => {
+    const date = new Date('2023-08-09T23:59:59+02:00');
+    expect(toUTCDateString(date)).toBe('2023-08-09');
+  });
+
+  it('should handle a leap year date', () => {
+    const date = new Date('2020-02-29T12:00:00+00:00');
+    expect(toUTCDateString(date)).toBe('2020-02-29');
+  });
+});

package/src/date/add-days.ts

@@ -0,0 +1,5 @@
+export const addDays = (date: Date, days: number): Date => {
+  const result = new Date(date);
+  result.setUTCDate(result.getUTCDate() + days);
+  return result;
+};

package/src/date/difference-in-days.ts

@@ -0,0 +1,6 @@
+export const differenceInDays = (start: Date, end: Date): number => {
+  const msPerDay = 24 * 60 * 60 * 1000;
+  const utcStart = Date.UTC(start.getFullYear(), start.getMonth(), start.getDate());
+  const utcEnd = Date.UTC(end.getFullYear(), end.getMonth(), end.getDate());
+  return Math.floor((utcEnd - utcStart) / msPerDay);
+};

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

@@ -0,0 +1 @@
+export const getIsoDayNumber = (date = new Date()) => ((date.getDay() + 6) % 7) + 1;

package/src/date/get-next-day.ts

@@ -0,0 +1,6 @@
+export const getNextDay = (date: Date): Date => {
+  const nextDay = new Date(date);
+  nextDay.setDate(date.getDate() + 1);
+
+  return nextDay;
+};

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

@@ -0,0 +1,24 @@
+export const getRemainingTimeInMsFromDate = (date: Date): number => {
+  if (!(date instanceof Date)) return 0;
+
+  const endTime = date.getTime();
+  const currentTime = Date.now();
+  const diff = endTime - currentTime;
+  return Math.max(0, diff);
+};
+
+export const getRemainingTimeFromMs = (
+  ms: number,
+): { daysLeft: number; hoursLeft: number; minutesLeft: number; secondsLeft: number } => {
+  const daysLeft = Math.floor(ms / 86400000);
+  const hoursLeft = Math.floor((ms % 86400000) / 3600000);
+  const minutesLeft = Math.floor((ms % 3600000) / 60000);
+  const secondsLeft = Math.floor((ms % 60000) / 1000);
+
+  return {
+    daysLeft: Math.max(0, daysLeft),
+    hoursLeft: Math.max(0, hoursLeft),
+    minutesLeft: Math.max(0, minutesLeft),
+    secondsLeft: Math.max(0, secondsLeft),
+  };
+};

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

@@ -0,0 +1,11 @@
+export const startOfDay = (date: Date) => {
+  const d = new Date(date);
+  d.setUTCHours(0, 0, 0, 0);
+  return d;
+};
+
+export const startOfDayLocal = (date: Date) => {
+  const d = new Date(date);
+  d.setHours(0, 0, 0, 0);
+  return d;
+};

package/src/date/index.ts

@@ -0,0 +1,10 @@
+export * from './is-same-date';
+export * from './to-plain-date-string';
+export * from './get-next-day';
+export * from './get-remaining-time';
+export * from './shift-date-by';
+export * from './difference-in-days';
+export * from './add-days';
+export * from './get-start-of-day';
+export * from './to-utc-date-string';
+export * from './get-iso-day-number';

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

@@ -0,0 +1,7 @@
+export const isSameDate = (date1: Date, date2: Date): boolean => {
+  return (
+    date1.getUTCFullYear() === date2.getUTCFullYear() &&
+    date1.getUTCMonth() === date2.getUTCMonth() &&
+    date1.getUTCDate() === date2.getUTCDate()
+  );
+};

package/src/date/shift-date-by.ts

@@ -0,0 +1,17 @@
+type TimeShifts = {
+  days?: number;
+  hours?: number;
+  minutes?: number;
+  seconds?: number;
+};
+
+export const shiftDateBy = (shifts: TimeShifts = {}, date: Date = new Date()): Date => {
+  const { days = 0, hours = 0, minutes = 0, seconds = 0 } = shifts;
+  return new Date(
+    date.getTime() +
+      days * 86400000 + // 1 day = 86 400 000 ms
+      hours * 3600000 + // 1 hour = 3 600 000 ms
+      minutes * 60000 + // 1 minute = 60 000 ms
+      seconds * 1000, // 1 second = 1 000 ms
+  );
+};

package/src/date/to-plain-date-string.ts

@@ -0,0 +1 @@
+export const toPlainDateString = (date: Date): string => date.toISOString().split('T')[0];

package/src/date/to-utc-date-string.ts

@@ -0,0 +1,3 @@
+export const toUTCDateString = (date: Date) => {
+  return new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate())).toISOString().split('T')[0];
+};

package/src/formatting/__tests__/format-number.test.ts

@@ -0,0 +1,11 @@
+import { formatNumber } from '../format-number';
+
+describe('formatNumber', () => {
+  it('should format numbers correctly', () => {
+    expect(formatNumber(48)).toBe('48');
+    expect(formatNumber(999)).toBe('999');
+    expect(formatNumber(1000)).toBe('1.0k');
+    expect(formatNumber(42869)).toBe('42.8k');
+    expect(formatNumber(992169)).toBe('992.1k');
+  });
+});

package/src/formatting/format-number.ts

@@ -0,0 +1,14 @@
+const DECIMAL_SEPARATOR = '.';
+const THOUSAND_UNIT = 'k';
+
+export const formatNumber = (n: number): string => {
+  const numString = String(n);
+  if (n < 1000) {
+    return numString;
+  }
+
+  const decimalsMinusLast = numString.slice(0, numString.length - 3);
+  const lastDecimal = numString.slice(numString.length - 3, numString.length - 2);
+
+  return `${decimalsMinusLast}${DECIMAL_SEPARATOR}${lastDecimal}${THOUSAND_UNIT}`;
+};

package/src/formatting/index.ts

@@ -0,0 +1 @@
+export * from './format-number';

package/src/fp/__tests__/run-while.test.ts

@@ -0,0 +1,29 @@
+import { runWhile } from '../run-while';
+
+describe('runWhile', () => {
+  it('should run while the predicate is true and return the right interation count', () => {
+    const { result, iterationCount } = runWhile({
+      predicate: (counter) => counter <= 9,
+      callback: (counter) => counter + 1,
+      initialValue: 0,
+    });
+
+    expect(result).toStrictEqual(10);
+    expect(iterationCount).toStrictEqual(10);
+  });
+
+  it('should throw an error when the iteration limit is reached', () => {
+    const predicateMock = jest.fn().mockReturnValue(true);
+
+    const { iterationCount } = runWhile({
+      predicate: predicateMock,
+      callback: (counter) => counter + 1,
+      initialValue: 0,
+      iterationLimit: 89,
+    });
+
+    // Called once outside the while loop
+    expect(predicateMock).toHaveBeenCalledTimes(90);
+    expect(iterationCount).toStrictEqual(89);
+  });
+});

package/src/fp/index.ts

@@ -0,0 +1 @@
+export * from './run-while';

package/src/fp/run-while.ts

@@ -0,0 +1,54 @@
+export type RunWhileConfig<T> = {
+  /**
+   * Return a boolean to keep running the callback or not.
+   */
+  predicate: (current: T) => boolean,
+  /**
+   * The function to run while `predicate` returns `true`
+   */
+  callback: (current: T, iteractionCount: number) => T,
+  /**
+   * `callback` will not be run again if `iterationCount` exceeds this value.
+   * Default to `Infinity`
+   */
+  iterationLimit?: number,
+  /**
+   * The first value passed to the callback.
+   */
+  initialValue: T,
+};
+
+export type RunWhileFn = <T>(config: RunWhileConfig<T>) => {
+  /**
+   * The callback last result.
+   */
+  result: T,
+  iterationCount: number,
+};
+
+/**
+ * Run the callback while the predicate return true. Throws an
+ * error if the iteration count exceeds the iteration limit.
+ */
+export const runWhile: RunWhileFn = ({ predicate, callback, initialValue, iterationLimit = Infinity }) => {
+  let counter = 0;
+  let currentValue = initialValue;
+  let shouldRun = predicate(currentValue);
+
+  while (shouldRun) {
+    if (counter >= iterationLimit) {
+      break;
+    }
+
+    const nextValue = callback(currentValue, counter);
+
+    counter += 1;
+    shouldRun = predicate(nextValue);
+    currentValue = nextValue;
+  }
+
+  return {
+    result: currentValue,
+    iterationCount: counter,
+  };
+};

package/src/http/__tests__/build-search-params.test.ts

@@ -0,0 +1,17 @@
+import { buildSearchParams } from '../build-search-params';
+
+describe('buildSearchParams', () => {
+  it('should remove undefined values', () => {
+    const params = {
+      param1: 'value1',
+      param2: undefined,
+      param3: 'value3',
+    };
+    const searchParams = buildSearchParams(params);
+
+    expect(searchParams.toString()).toStrictEqual('param1=value1&param3=value3');
+    expect(searchParams.get('param1')).toStrictEqual('value1');
+    expect(searchParams.get('param2')).toStrictEqual(null);
+    expect(searchParams.get('param3')).toStrictEqual('value3');
+  });
+});

package/src/http/__tests__/encode-search-object.test.ts

@@ -0,0 +1,34 @@
+import { encodeSearchObject } from '../encode-search-object';
+
+describe('encodeSearchObject', () => {
+  it('should not encode sort and query if undefined', () => {
+    const url = encodeSearchObject({
+      limit: 10,
+      offset: 15,
+    });
+
+    expect(url).toStrictEqual('offset=15&limit=10');
+  });
+
+  it('should encode sort and query twice', () => {
+    const url = encodeSearchObject({
+      limit: 10,
+      offset: 0,
+      sort: {
+        name: 'asc',
+        editionDate: 'desc',
+      },
+      query: {
+        name: 'The name of something',
+        status: 'published',
+      },
+    });
+
+    expect(url).toStrictEqual([
+      'offset=0',
+      'limit=10',
+      'sort=name%3Aasc%2BeditionDate%3Adesc',
+      'query=name%3AThe%2520name%2520of%2520something%2Bstatus%3Apublished',
+    ].join('&'));
+  });
+});

package/src/http/__tests__/fetch-with-timeout.test.ts

@@ -0,0 +1,50 @@
+/* eslint-disable import/first -- https://github.com/jefflau/jest-fetch-mock#to-setup-for-an-individual-test */
+
+import fetchMock, { enableFetchMocks } from 'jest-fetch-mock';
+
+// must appear before any other imports
+enableFetchMocks();
+
+import { fetchWithTimeout } from '../fetch-with-timeout';
+
+describe('fetchWithTimeout', () => {
+  beforeEach(() => {
+    fetchMock.resetMocks();
+  });
+
+  it('should call fetch with the same parameters', async () => {
+    const url = 'http://some/url';
+    const init = {
+      headers: {
+        some: 'header',
+      },
+    };
+
+    fetchMock.mockResponseOnce('mock response');
+    const response = await fetchWithTimeout(url, init);
+
+    expect(fetch as any).toHaveBeenNthCalledWith(1, url, expect.objectContaining(init));
+    expect(await response.text()).toBe('mock response');
+  });
+
+  it('should abort the request if timeout has elapsed', async () => {
+    jest.useFakeTimers();
+    const TIMEOUT = 3000;
+    const REQUEST_TIMEOUT = TIMEOUT * 2;
+
+    // This request will take too long
+    fetchMock.mockResponseOnce(async () => {
+      jest.advanceTimersByTime(REQUEST_TIMEOUT);
+      return 'mock response';
+    });
+
+    // https://github.com/jefflau/jest-fetch-mock/issues/159
+    (global as any).DOMException = Error;
+
+    const responsePromise = fetchWithTimeout('http://some/url', { timeout: TIMEOUT });
+
+    jest.advanceTimersByTime(TIMEOUT + 100);
+
+    await expect(responsePromise).rejects.toThrow('The operation was aborted. ');
+  });
+});

package/src/http/build-search-params.ts

@@ -0,0 +1,16 @@
+import type { Primitive } from '../types';
+
+export const buildSearchParams = (params: Record<string, Primitive | undefined>): URLSearchParams => {
+  const definedParams = Object.entries(params).reduce((acc, [key, value]) => {
+    if (value !== undefined) {
+      return {
+        ...acc,
+        [key]: String(value),
+      };
+    }
+
+    return acc;
+  }, {} as Record<string, string>);
+
+  return new URLSearchParams(definedParams);
+};

package/src/http/encode-search-object.ts

@@ -0,0 +1,42 @@
+import { SearchObject, SearchQueryValue } from '../types';
+
+export type EncodingConfig = {
+  keyValueDelimiter: string;
+  pairDelimiter: string;
+};
+
+const defaultEncodingConfig: EncodingConfig = {
+  keyValueDelimiter: ':',
+  pairDelimiter: '+',
+};
+
+export const encodeSearchValue = <T extends Record<string, SearchQueryValue>>(
+  searchValue: T,
+  config: EncodingConfig = defaultEncodingConfig,
+) => {
+  const { pairDelimiter, keyValueDelimiter } = config;
+
+  return Object.entries(searchValue)
+    .map(([key, value]) => {
+      const stringValue = Array.isArray(value) ? value.join(',') : value;
+      return `${key}${keyValueDelimiter}${encodeURI(stringValue)}`;
+    })
+    .join(pairDelimiter);
+};
+
+export const encodeSearchObject = (searchObject: SearchObject): string => {
+  const { sort, query, offset, limit } = searchObject;
+
+  const sortEncoded = sort ? encodeSearchValue(sort) : null;
+  const queryEncoded = query ? encodeSearchValue(query) : null;
+
+  const urlParams = new URLSearchParams({
+    ...(offset !== undefined ? { offset: offset.toString() } : undefined),
+    ...(limit !== undefined ? { limit: limit.toString() } : undefined),
+  });
+
+  if (sortEncoded) urlParams.append('sort', sortEncoded);
+  if (queryEncoded) urlParams.append('query', queryEncoded);
+
+  return urlParams.toString();
+};

package/src/http/fetch-with-timeout.ts

@@ -0,0 +1,27 @@
+export type RequestInitWithTimeout = RequestInit & {
+  timeout?: number;
+};
+
+/**
+ * Use fetch to perform an HTTP request
+ * Add an optional timeout, that will abort the request if it has not returned before
+ */
+export const fetchWithTimeout = (
+  input: RequestInfo,
+  init?: Omit<RequestInitWithTimeout, 'signal'> | undefined,
+): Promise<Response> => {
+  const abortController = new AbortController();
+
+  const { timeout, ...rest } = init || {};
+
+  const params = {
+    ...rest,
+    signal: abortController.signal,
+  };
+
+  if (timeout !== undefined) {
+    setTimeout(() => abortController.abort(), timeout);
+  }
+
+  return fetch(input, params);
+};

package/src/http/index.ts

@@ -0,0 +1,3 @@
+export * from './encode-search-object';
+export * from './fetch-with-timeout';
+export * from './build-search-params';

package/src/index.ts

@@ -0,0 +1,19 @@
+export * from './array';
+export * from './business';
+export * from './cdn';
+export * from './chrono';
+export * from './time';
+export * from './formatting';
+export * from './fp';
+export * from './http';
+export * from './linked-list';
+export * from './math';
+export * from './object';
+export * from './parsing';
+export * from './predicates';
+export * from './promise';
+export * from './string';
+export * from './types';
+export * from './color';
+export * from './crypto';
+export * from './date';

package/src/linked-list/__tests__/apply-diff-linked-list.test.ts

@@ -0,0 +1,103 @@
+import { createLinkedList } from '../create-linked-list';
+import { applyDiffLinkedList } from '../apply-diff-linked-list';
+
+describe('applyDiffLinkedList', () => {
+  const items = {
+    1: { id: '1', nextId: '2', previousId: null, value: 1 },
+    2: { id: '2', nextId: '3', previousId: '1', value: 2 },
+    3: { id: '3', nextId: '4', previousId: '2', value: 3 },
+    4: { id: '4', nextId: null, previousId: '3', value: 4 },
+  };
+
+  const linkedList = createLinkedList('1', items);
+
+  it('should handle a delete', () => {
+    const newList = applyDiffLinkedList(items['2'], null, linkedList);
+
+    expect(newList.items).toStrictEqual({
+      1: { id: '1', nextId: '3', previousId: null, value: 1 },
+      3: { id: '3', nextId: '4', previousId: '1', value: 3 },
+      4: { id: '4', nextId: null, previousId: '3', value: 4 },
+    });
+    expect(newList.head).toStrictEqual(newList.items['1']);
+  });
+
+  it('should handle an insert', () => {
+    const insertedItem = { id: '5', nextId: null, previousId: '4', value: 5 };
+    const newList = applyDiffLinkedList(null, insertedItem, linkedList);
+
+    expect(newList.items).toStrictEqual({
+      1: { id: '1', nextId: '2', previousId: null, value: 1 },
+      2: { id: '2', nextId: '3', previousId: '1', value: 2 },
+      3: { id: '3', nextId: '4', previousId: '2', value: 3 },
+      4: { id: '4', nextId: '5', previousId: '3', value: 4 },
+      5: { id: '5', nextId: null, previousId: '4', value: 5 },
+    });
+    expect(newList.head).toStrictEqual(newList.items['1']);
+  });
+
+  it('should throw an error if the two items are null', () => {
+    expect(() => applyDiffLinkedList(null, null, linkedList)).toThrowError(
+      'Cannot have both before & after as null',
+    );
+  });
+
+  it('should throw an error if it tries to change the id', () => {
+    const before = linkedList.items['2'];
+    const after = { ...before, id: '6' };
+
+    expect(() => applyDiffLinkedList(before, after, linkedList)).toThrowError(
+      'Cannot change id of a ListNode',
+    );
+  });
+
+  it('should update a node if it has the same nextId', () => {
+    const before = linkedList.items['2'];
+    const after = { ...before, value: 22 };
+
+    const newList = applyDiffLinkedList(before, after, linkedList);
+
+    expect(newList.items).toStrictEqual({
+      1: { id: '1', nextId: '2', previousId: null, value: 1 },
+      2: { id: '2', nextId: '3', previousId: '1', value: 22 },
+      3: { id: '3', nextId: '4', previousId: '2', value: 3 },
+      4: { id: '4', nextId: null, previousId: '3', value: 4 },
+    });
+    expect(newList.head).toStrictEqual(newList.items['1']);
+  });
+
+  it('should update a node if it has the same nextId', () => {
+    const before = linkedList.items['2'];
+    const after = { ...before, value: 22 };
+
+    const newList = applyDiffLinkedList(before, after, linkedList);
+
+    expect(newList.items).toStrictEqual({
+      1: { id: '1', nextId: '2', previousId: null, value: 1 },
+      2: { id: '2', nextId: '3', previousId: '1', value: 22 },
+      3: { id: '3', nextId: '4', previousId: '2', value: 3 },
+      4: { id: '4', nextId: null, previousId: '3', value: 4 },
+    });
+    expect(newList.head).toStrictEqual(newList.items['1']);
+  });
+
+  it('should handle a reorder and an update', () => {
+    const before = linkedList.items['2'];
+    const after = {
+      ...before,
+      value: 22,
+      nextId: '4',
+      previousId: '3',
+    };
+
+    const newList = applyDiffLinkedList(before, after, linkedList);
+
+    expect(newList.items).toStrictEqual({
+      1: { id: '1', nextId: '3', previousId: null, value: 1 },
+      3: { id: '3', nextId: '2', previousId: '1', value: 3 },
+      2: { id: '2', nextId: '4', previousId: '3', value: 22 },
+      4: { id: '4', nextId: null, previousId: '2', value: 4 },
+    });
+    expect(newList.head).toStrictEqual(newList.items['1']);
+  });
+});