@sparted/shared-library 1.1.8 → 1.2.0

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/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/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,18 @@
+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,39 @@
+import { SearchObject } from '../types';
+
+export type EncodingConfig = {
+  keyValueDelimiter: string,
+  pairDelimiter: string,
+};
+
+const defaultEncodingConfig: EncodingConfig = {
+  keyValueDelimiter: ':',
+  pairDelimiter: '+',
+};
+
+export const encodeSearchValue = <T extends Record<string, string>>(
+  searchValue: T,
+  config: EncodingConfig = defaultEncodingConfig,
+) => {
+  const { pairDelimiter, keyValueDelimiter } = config;
+
+  return Object.entries(searchValue)
+    .map(([key, value]) => `${key}${keyValueDelimiter}${encodeURI(value)}`)
+    .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: offset.toString(),
+    limit: limit.toString(),
+  });
+
+  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,24 @@
+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,15 @@
+export * from './array';
+export * from './cdn';
+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';

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']);
+  });
+});