@sparted/shared-library 1.0.6 → 1.0.8-alpha.0

package/{index.d.ts → src/index.ts}

@@ -1,14 +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 './array';
+export * from './cdn';
+export * from './time';
+export * from './formatting';
+export * from './fp';
+export * from './github';
+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';

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

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

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

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

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

@@ -0,0 +1,28 @@
+import { getLinkedList } from '../get-linked-list';
+
+describe('getLinkedList', () => {
+  const list = {
+    headId: '1',
+    items: {
+      1: {
+        id: '1',
+        nextId: '2',
+      },
+      2: {
+        id: '2',
+        nextId: null,
+      },
+    },
+  };
+
+  it('should get the item corresponding to the id', () => {
+    expect(getLinkedList('1', list)).toStrictEqual({
+      id: '1',
+      nextId: '2',
+    });
+  });
+
+  it('should return null if the item with the given id does not exist', () => {
+    expect(getLinkedList('5', list)).toBeNull();
+  });
+});

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

@@ -0,0 +1,186 @@
+import { insertLinkedList } from '../insert-linked-list';
+
+import {
+  findPreviousId,
+  assertItemCompatibility,
+  assertPresence,
+  assertNewNodePosition,
+} from '../linked-list-utils';
+
+jest.mock('../linked-list-utils');
+
+describe('insertLinkedList', () => {
+  const findPreviousIdMocked = jest.mocked(findPreviousId);
+  const assertItemCompatibilityMocked = jest.mocked(assertItemCompatibility);
+  const assertPresenceMocked = jest.mocked(assertPresence);
+  const assertNewNodePositionMocked = jest.mocked(assertNewNodePosition);
+
+  const list = {
+    headId: '1',
+    items: {
+      1: { id: '1', nextId: '2', previousId: null },
+      2: { id: '2', nextId: null, previousId: '1' },
+    },
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should call every assertion', () => {
+    const itemToInsert = {
+      nextId: '2',
+      previousId: '1',
+      id: '3',
+    };
+    insertLinkedList(itemToInsert, {
+      format: 'double',
+      factory: jest.fn(),
+      list: list as any,
+    });
+
+    expect(assertItemCompatibilityMocked).toHaveBeenCalledTimes(1);
+    expect(assertItemCompatibilityMocked).toHaveBeenCalledWith(itemToInsert, 'double');
+
+    expect(assertPresenceMocked).toHaveBeenCalledTimes(2);
+    expect(assertPresenceMocked).toHaveBeenNthCalledWith(1, '2', list.items);
+    expect(assertPresenceMocked).toHaveBeenNthCalledWith(2, '1', list.items);
+
+    expect(assertNewNodePositionMocked).toHaveBeenCalledTimes(1);
+    expect(assertNewNodePositionMocked).toHaveBeenCalledWith(itemToInsert, {
+      previousId: '1',
+      list,
+    });
+  });
+
+  it('should find the previous id if the linked list is not double link', () => {
+    const itemToInsert = {
+      id: '3',
+      nextId: '1',
+    };
+
+    findPreviousIdMocked.mockReturnValue(null);
+
+    insertLinkedList(itemToInsert, {
+      format: 'single',
+      factory: jest.fn().mockImplementation((newList) => newList),
+      list: list as any,
+    });
+
+    expect(findPreviousIdMocked).toHaveBeenCalledTimes(1);
+    expect(findPreviousIdMocked).toHaveBeenCalledWith('1', list);
+  });
+
+  it('should directly take the previousId from item if the list is double link', () => {
+    const itemToInsert = {
+      id: '3',
+      nextId: '1',
+      previousId: null,
+    };
+
+    insertLinkedList(itemToInsert, {
+      format: 'double',
+      factory: jest.fn(),
+      list: list as any,
+    });
+
+    expect(findPreviousIdMocked).not.toHaveBeenCalled();
+  });
+
+  it('should handle a middle insertion', () => {
+    const itemToInsert = {
+      id: '3',
+      nextId: '2',
+      previousId: '1',
+    };
+
+    const newList = insertLinkedList(itemToInsert, {
+      format: 'double',
+      factory: (theList) => theList as any,
+      list: list as any,
+    });
+
+    expect(newList).toStrictEqual({
+      headId: '1',
+      items: {
+        1: { id: '1', nextId: '3', previousId: null },
+        3: { id: '3', nextId: '2', previousId: '1' },
+        2: { id: '2', nextId: null, previousId: '3' },
+      },
+    });
+  });
+
+  it('should handle a head insertion', () => {
+    const itemToInsert = {
+      id: '3',
+      nextId: '1',
+      previousId: null,
+    };
+
+    const newList = insertLinkedList(itemToInsert, {
+      format: 'double',
+      factory: (theList) => theList as any,
+      list: list as any,
+    });
+
+    expect(newList).toStrictEqual({
+      headId: '3',
+      items: {
+        3: { id: '3', nextId: '1', previousId: null },
+        1: { id: '1', nextId: '2', previousId: '3' },
+        2: { id: '2', nextId: null, previousId: '1' },
+      },
+    });
+  });
+
+  it('should handle a tail insertion', () => {
+    const itemToInsert = {
+      id: '3',
+      nextId: null,
+      previousId: '2',
+    };
+
+    const newList = insertLinkedList(itemToInsert, {
+      format: 'double',
+      factory: (theList) => theList as any,
+      list: list as any,
+    });
+
+    expect(newList).toStrictEqual({
+      headId: '1',
+      items: {
+        1: { id: '1', nextId: '2', previousId: null },
+        2: { id: '2', nextId: '3', previousId: '1' },
+        3: { id: '3', nextId: null, previousId: '2' },
+      },
+    });
+  });
+
+  it('should handle an insertion in a single linked list', () => {
+    findPreviousIdMocked.mockReturnValue('2');
+
+    const singleLinkedlist = {
+      headId: '1',
+      items: {
+        1: { id: '1', nextId: '2' },
+        2: { id: '2', nextId: null },
+      },
+    };
+    const itemToInsert = { id: '3', nextId: null };
+
+    const newList = insertLinkedList(itemToInsert, {
+      format: 'single',
+      factory: (theList) => theList as any,
+      list: singleLinkedlist as any,
+    });
+
+    expect(newList).toStrictEqual({
+      headId: '1',
+      items: {
+        1: { id: '1', nextId: '2' },
+        2: { id: '2', nextId: '3' },
+        3: { id: '3', nextId: null },
+      },
+    });
+  });
+});