@sparted/shared-library 1.9.5 → 1.9.6

package/src/formatting/format-number.ts

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

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

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

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

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

package/src/fp/run-while.ts

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

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

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

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

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

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

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

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

package/src/index.ts

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

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

package/src/linked-list/__tests__/create-linked-list.test.ts

@@ -1,204 +0,0 @@
-import { createLinkedList } from '../create-linked-list';
-
-import { reduceLinkedList } from '../reduce-linked-list';
-import { findLinkedList } from '../find-linked-list';
-import { whileLinkedList } from '../while-linked-list';
-import { removeLinkedList } from '../remove-linked-list';
-import { insertLinkedList } from '../insert-linked-list';
-import { getLinkedList } from '../get-linked-list';
-import { updateLinkedList } from '../update-linked-list';
-import { applyDiffLinkedList } from '../apply-diff-linked-list';
-
-jest.mock('../reduce-linked-list');
-jest.mock('../find-linked-list');
-jest.mock('../while-linked-list');
-jest.mock('../remove-linked-list');
-jest.mock('../insert-linked-list');
-jest.mock('../get-linked-list');
-jest.mock('../update-linked-list');
-jest.mock('../apply-diff-linked-list');
-
-describe('createLinkedList', () => {
-  it('should create an empty list', () => {
-    const linkedList = createLinkedList(null, {});
-
-    expect(linkedList.head).toBeNull();
-    expect(linkedList.items).toStrictEqual({});
-    expect(linkedList.format).toBeNull();
-  });
-
-  it('should have the right head', () => {
-    const node = { title: 'Micro knowledge', id: '2', nextId: null };
-    const map = { 2: node };
-
-    const linkedList = createLinkedList('2', map);
-
-    expect(linkedList.head).toStrictEqual(node);
-  });
-
-  it('should set format to single', () => {
-    const map = {
-      1: { id: '1', nextId: '2' },
-      2: { id: '2', nextId: null },
-    };
-
-    const linkedList = createLinkedList('1', map);
-
-    expect(linkedList.format).toStrictEqual('single');
-  });
-
-  it('should set format to double', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: null, previousId: '1' },
-    };
-
-    const linkedList = createLinkedList('1', map);
-
-    expect(linkedList.format).toStrictEqual('double');
-  });
-
-  it('should throw an error if some nodes are double linkedand some are single linked', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: null },
-    };
-
-    expect(() => createLinkedList('1', map)).toThrowError(
-      'Invalid previous node in the linked list',
-    );
-  });
-
-  it('should throw an error if some nodes have invalid previous', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: null, previousId: '1' },
-    };
-
-    expect(() => createLinkedList('1', map)).toThrowError(
-      'Invalid previous node in the linked list',
-    );
-  });
-
-  it('should have the right size', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: null, previousId: '2' },
-    };
-
-    const linkedList = createLinkedList('1', map);
-
-    expect(linkedList.size).toStrictEqual(3);
-  });
-
-  describe('methods', () => {
-    const reduceLinkedListMocked = jest.mocked(reduceLinkedList);
-    const findLinkedListMocked = jest.mocked(findLinkedList);
-    const whileLinkedListMocked = jest.mocked(whileLinkedList);
-    const removeLinkedListMocked = jest.mocked(removeLinkedList);
-    const insertLinkedListMocked = jest.mocked(insertLinkedList);
-    const getLinkedListMocked = jest.mocked(getLinkedList);
-    const updateLinkedListMocked = jest.mocked(updateLinkedList);
-    const applyDiffLinkedListMocked = jest.mocked(applyDiffLinkedList);
-
-    const record = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: null, previousId: '1' },
-    };
-    const linkedList = createLinkedList('1', record);
-    const list = {
-      headId: '1',
-      items: record,
-    };
-    const manipulationConfig = {
-      factory: expect.toBeFunction(),
-      format: 'double',
-      list,
-    };
-
-    beforeEach(() => {
-      jest.clearAllMocks();
-    });
-
-    it('it should have reduce', () => {
-      reduceLinkedListMocked.mockReturnValue('reduce');
-
-      const accumulatorFunction = jest.fn().mockName('accumulatorFunction');
-      const result = linkedList.reduce(accumulatorFunction, 'init');
-
-      expect(result).toStrictEqual('reduce');
-      expect(reduceLinkedListMocked).toHaveBeenCalledWith(accumulatorFunction, 'init', list);
-    });
-
-    it('it should have find', () => {
-      findLinkedListMocked.mockReturnValue('find' as any);
-
-      const findPredicate = jest.fn().mockName('findPredicate');
-      const result = linkedList.find(findPredicate);
-
-      expect(result).toStrictEqual('find');
-      expect(findLinkedListMocked).toHaveBeenCalledWith(findPredicate, list);
-    });
-
-    it('it should have while', () => {
-      whileLinkedListMocked.mockReturnValue('while' as any);
-
-      const whilePredicate = jest.fn().mockName('whilePredicate');
-      const result = linkedList.while(whilePredicate, '2');
-
-      expect(result).toStrictEqual('while');
-      expect(whileLinkedListMocked).toHaveBeenCalledWith(whilePredicate, list, '2');
-    });
-
-    it('it should have remove', () => {
-      removeLinkedListMocked.mockReturnValue('remove' as any);
-
-      const result = linkedList.remove('3');
-
-      expect(result).toStrictEqual('remove');
-      expect(removeLinkedListMocked).toHaveBeenCalledWith('3', manipulationConfig);
-    });
-
-    it('it should have insert', () => {
-      insertLinkedListMocked.mockReturnValue('insert' as any);
-
-      const item = { id: '5', nextId: '6', previousId: '4' };
-      const result = linkedList.insert(item as any);
-
-      expect(result).toStrictEqual('insert');
-      expect(insertLinkedListMocked).toHaveBeenCalledWith(item, manipulationConfig);
-    });
-
-    it('it should have get', () => {
-      getLinkedListMocked.mockReturnValue('get' as any);
-
-      const result = linkedList.get('5');
-
-      expect(result).toStrictEqual('get');
-      expect(getLinkedListMocked).toHaveBeenCalledWith('5', list);
-    });
-
-    it('it should have update', () => {
-      updateLinkedListMocked.mockReturnValue('update' as any);
-
-      const updatedItem = { id: '5', nextId: '6', previousId: '4' };
-      const result = linkedList.update(updatedItem as any);
-
-      expect(result).toStrictEqual('update');
-      expect(updateLinkedListMocked).toHaveBeenCalledWith(updatedItem, manipulationConfig);
-    });
-
-    it('it should have applyDiff', () => {
-      applyDiffLinkedListMocked.mockReturnValue('applydiff' as any);
-
-      const before = { id: '5', nextId: '6', previousId: '4' };
-      const after = { id: '5', nextId: '7', previousId: '4' };
-      const result = linkedList.applyDiff(before as any, after as any);
-
-      expect(result).toStrictEqual('applydiff');
-      expect(applyDiffLinkedListMocked).toHaveBeenCalledWith(before, after, linkedList);
-    });
-  });
-});

package/src/linked-list/__tests__/find-linked-list.test.ts

@@ -1,40 +0,0 @@
-import { findLinkedList } from '../find-linked-list';
-
-describe('findLinkedList', () => {
-  const list = {
-    items: {
-      1: {
-        id: '1',
-        nextId: '2',
-      },
-      2: {
-        id: '2',
-        nextId: '3',
-      },
-      3: {
-        id: '3',
-        nextId: '4',
-      },
-      4: {
-        id: '1',
-        nextId: null,
-      },
-    },
-    headId: '1',
-  };
-
-  it('should return the right item if it is found', () => {
-    const foundItem = findLinkedList((item) => item.id === '3', list);
-
-    expect(foundItem).toStrictEqual({
-      id: '3',
-      nextId: '4',
-    });
-  });
-
-  it('should return null if no item match the predicate', () => {
-    const foundItem = findLinkedList((item) => item.id === '5', list);
-
-    expect(foundItem).toBeNull();
-  });
-});