@sparted/shared-library 1.9.5 → 1.10.0

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

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

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

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

@@ -1,252 +0,0 @@
-import {
-  walkListItemRecord,
-  findPreviousId,
-  assertItemCompatibility,
-  assertPresence,
-  assertNewNodePosition,
-} from '../linked-list-utils';
-
-describe('walkListItemRecord', () => {
-  it('should throw an error if it detected an infinite loop', () => {
-    const items = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: '1', previousId: '2' },
-      4: { id: '4', nextId: null, previousId: '3' },
-    };
-
-    expect(
-      () => {
-        walkListItemRecord(
-          () => ({
-            result: null,
-          }),
-          {
-            initValue: null,
-            startId: '1',
-            items,
-          },
-        );
-      },
-    ).toThrowError('Infinite loop found');
-  });
-
-  it('should throw an error if a node points to another node that does not exist', () => {
-    const items = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: '4', previousId: '2' },
-      5: { id: '5', nextId: null, previousId: '3' },
-    };
-
-    expect(
-      () => {
-        walkListItemRecord(
-          () => ({
-            result: null,
-          }),
-          {
-            initValue: null,
-            startId: '1',
-            items,
-          },
-        );
-      },
-    ).toThrowError('Cul de sac detected');
-  });
-
-  it('should not throw an error if it did not walk through every nodes and it was force stopped', () => {
-    const items = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: null, previousId: '2' },
-      4: { id: '4', nextId: null, previousId: '3' },
-    };
-
-    expect(
-      () => {
-        walkListItemRecord(
-          (_, current) => {
-            if (current.id === '2') {
-              return {
-                result: null,
-                control: {
-                  stop: true,
-                },
-              };
-            }
-
-            return {
-              result: null,
-            };
-          },
-          {
-            initValue: null,
-            startId: '1',
-            items,
-          },
-        );
-      },
-    ).not.toThrowError();
-  });
-
-  it('should accumulate the result and return it', () => {
-    const items = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: '4', previousId: '2' },
-      4: { id: '4', nextId: null, previousId: '3' },
-    };
-
-    const result = walkListItemRecord(
-      (acc, current) => ({
-        result: acc + current.id.toString(),
-      }),
-      {
-        initValue: '',
-        startId: '1',
-        items,
-      },
-    );
-
-    expect(result).toStrictEqual('1234');
-  });
-});
-
-describe('findPreviousId', () => {
-  const list = {
-    headId: '1',
-    items: {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: '4', previousId: '2' },
-      4: { id: '4', nextId: null, previousId: '3' },
-    },
-  };
-
-  it('should return the headId if the id is the head', () => {
-    expect(findPreviousId('1', list)).toStrictEqual(null);
-  });
-
-  it('should correctly return the previous id', () => {
-    expect(findPreviousId('4', list)).toStrictEqual('3');
-  });
-
-  it('should correctly find the previous id if it is the tail', () => {
-    expect(findPreviousId(null, list)).toStrictEqual('4');
-  });
-
-  it('should return null if the list is empty', () => {
-    expect(findPreviousId('4', { headId: null, items: {} })).toStrictEqual(null);
-  });
-
-  it('should return null if it can\'t find the previous', () => {
-    expect(findPreviousId('6', list)).toStrictEqual(null);
-  });
-});
-
-describe('assertItemCompatibility', () => {
-  const itemWithPrevious = { id: '2', nextId: '3', previousId: '1' };
-  const itemWithoutPrevious = { id: '2', nextId: '3' };
-
-  it('should throw an error if the node has previous and the linked list is not double linked', () => {
-    expect(() => assertItemCompatibility(itemWithPrevious, 'single')).toThrowError(
-      'Node is incompatible with the list (id: 2)',
-    );
-  });
-
-  it('should throw an error if the node does not have previous and the linked list is double linked', () => {
-    expect(() => assertItemCompatibility(itemWithoutPrevious, 'double')).toThrowError(
-      'Node is incompatible with the list (id: 2)',
-    );
-  });
-
-  it('should not throw error if the node is correct', () => {
-    expect(() => assertItemCompatibility(itemWithoutPrevious, 'single')).not.toThrowError();
-    expect(() => assertItemCompatibility(itemWithPrevious, 'double')).not.toThrowError();
-  });
-
-  it('should not throw error if format is null', () => {
-    expect(() => assertItemCompatibility(itemWithoutPrevious, null)).not.toThrowError();
-    expect(() => assertItemCompatibility(itemWithPrevious, null)).not.toThrowError();
-  });
-});
-
-describe('assertPresence', () => {
-  const items = {
-    1: { id: '1', nextId: '2', previousId: null },
-    2: { id: '2', nextId: null, previousId: '1' },
-  };
-
-  it('should throw an error if the item is not in the list', () => {
-    expect(() => assertPresence('3', items)).toThrowError(
-      'Node not found in the list (id: 3)',
-    );
-  });
-
-  it('should not throw an error if the item is in the list', () => {
-    expect(() => assertPresence('2', items)).not.toThrowError();
-  });
-});
-
-describe('assertNewNodePosition', () => {
-  const list = {
-    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 throw an error if the head position is incorrect', () => {
-    const item = { id: '4', nextId: '2' };
-
-    expect(
-      () => {
-        assertNewNodePosition(item, {
-          previousId: null,
-          list,
-        });
-      },
-    ).toThrowError('Invalid position for given node (id: 4)');
-  });
-
-  it('should throw an error if the tail position is incorrect', () => {
-    const item = { id: '4', nextId: null };
-
-    expect(
-      () => {
-        assertNewNodePosition(item, {
-          previousId: '2',
-          list,
-        });
-      },
-    ).toThrowError('Invalid position for given node (id: 4)');
-  });
-  it('should throw an error if the middle position is incorrect', () => {
-    const item = { id: '4', nextId: '3' };
-
-    expect(
-      () => {
-        assertNewNodePosition(item, {
-          previousId: '1',
-          list,
-        });
-      },
-    ).toThrowError('Invalid position for given node (id: 4)');
-  });
-
-  it('should not throw an error if the position is correct', () => {
-    const item = { id: '4', nextId: '3' };
-
-    expect(
-      () => {
-        assertNewNodePosition(item, {
-          previousId: '2',
-          list,
-        });
-      },
-    ).not.toThrowError();
-  });
-});

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

@@ -1,31 +0,0 @@
-import { reduceLinkedList } from '../reduce-linked-list';
-
-describe('reduceLinkedList', () => {
-  it('should execute the reduce function on every node', () => {
-    const nodes = {
-      3: {
-        id: '3',
-        nextId: '2',
-      },
-      1: {
-        id: '1',
-        nextId: null,
-      },
-      2: {
-        id: '2',
-        nextId: '1',
-      },
-    };
-
-    const reduceResult = reduceLinkedList(
-      (acc: string, current) => acc.concat(current.id),
-      '',
-      {
-        headId: '3',
-        items: nodes,
-      },
-    );
-
-    expect(reduceResult).toStrictEqual('321');
-  });
-});

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

@@ -1,129 +0,0 @@
-import { removeLinkedList } from '../remove-linked-list';
-import { assertPresence, findPreviousId } from '../linked-list-utils';
-
-jest.mock('../linked-list-utils');
-
-describe('removeLinkedList', () => {
-  const assertPresenceMocked = jest.mocked(assertPresence);
-  const findPreviousIdMocked = jest.mocked(findPreviousId);
-
-  const list = {
-    headId: '1',
-    items: {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: null, previousId: '2' },
-    },
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should make the right assertions', () => {
-    removeLinkedList('1', {
-      list,
-      factory: jest.fn(),
-      format: 'double',
-    });
-
-    expect(assertPresenceMocked).toHaveBeenCalledTimes(1);
-    expect(assertPresenceMocked).toHaveBeenCalledWith('1', list.items);
-  });
-
-  it('should find the previous id if the list is not double linked', () => {
-    removeLinkedList('1', {
-      list,
-      factory: jest.fn(),
-      format: 'single',
-    });
-
-    expect(findPreviousIdMocked).toHaveBeenCalledTimes(1);
-    expect(findPreviousIdMocked).toHaveBeenCalledWith('1', list);
-  });
-
-  it('should directly take the previous id from the deleted item if the list is double linked', () => {
-    removeLinkedList('1', {
-      list,
-      factory: jest.fn(),
-      format: 'double',
-    });
-
-    expect(findPreviousIdMocked).not.toHaveBeenCalled();
-  });
-
-  it('should handle a head deletion', () => {
-    const newList = removeLinkedList('1', {
-      list,
-      factory: jest.fn().mockImplementation((theList) => theList),
-      format: 'double',
-    });
-
-    expect(newList).toStrictEqual({
-      headId: '2',
-      items: {
-        2: { id: '2', nextId: '3', previousId: null },
-        3: { id: '3', nextId: null, previousId: '2' },
-      },
-    });
-  });
-
-  it('should handle a tail deletion', () => {
-    const newList = removeLinkedList('3', {
-      list,
-      factory: jest.fn().mockImplementation((theList) => theList),
-      format: 'double',
-    });
-
-    expect(newList).toStrictEqual({
-      headId: '1',
-      items: {
-        1: { id: '1', nextId: '2', previousId: null },
-        2: { id: '2', nextId: null, previousId: '1' },
-      },
-    });
-  });
-
-  it('should handle a middle deletion', () => {
-    const newList = removeLinkedList('2', {
-      list,
-      factory: jest.fn().mockImplementation((theList) => theList),
-      format: 'double',
-    });
-
-    expect(newList).toStrictEqual({
-      headId: '1',
-      items: {
-        1: { id: '1', nextId: '3', previousId: null },
-        3: { id: '3', nextId: null, previousId: '1' },
-      },
-    });
-  });
-
-  it('should a deletion in a single linked list', () => {
-    findPreviousIdMocked.mockReturnValue('1');
-
-    const singleList = {
-      headId: '1',
-      items: {
-        1: { id: '1', nextId: '2' },
-        2: { id: '2', nextId: '3' },
-        3: { id: '3', nextId: null },
-      },
-    };
-
-    const newList = removeLinkedList('2', {
-      list: singleList,
-      factory: jest.fn().mockImplementation((theList) => theList),
-      format: 'single',
-    });
-
-    expect(newList).toStrictEqual({
-      headId: '1',
-      items: {
-        1: { id: '1', nextId: '3' },
-        3: { id: '3', nextId: null },
-      },
-    });
-  });
-});

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

@@ -1,53 +0,0 @@
-import { updateLinkedList } from '../update-linked-list';
-import { assertPresence } from '../linked-list-utils';
-
-jest.mock('../linked-list-utils');
-
-describe('updateLinkedList', () => {
-  const assertPresenceMocked = jest.mocked(assertPresence);
-
-  const list = {
-    headId: '1',
-    items: {
-      1: { id: '1', nextId: '2', previousId: null, name: 'Barack Afritt' },
-      2: { id: '2', nextId: '3', previousId: '1', name: 'Djamal Dormi' },
-      3: { id: '3', nextId: null, previousId: '2', name: 'Harry Cover' },
-    },
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should make the right assertions', () => {
-    const itemToUpdate = { id: '1', nextId: '2', previousId: null };
-
-    updateLinkedList(itemToUpdate, {
-      list: list as any,
-      format: 'double',
-      factory: jest.fn(),
-    });
-
-    expect(assertPresenceMocked).toHaveBeenCalledTimes(1);
-    expect(assertPresenceMocked).toHaveBeenCalledWith('1', list.items);
-  });
-
-  it('should update the item without reordering it', () => {
-    const itemToUpdate = { id: '1', nextId: '3', previousId: '2', surname: 'Ototo' };
-
-    const newList = updateLinkedList(itemToUpdate, {
-      list: list as any,
-      format: 'double',
-      factory: jest.fn().mockImplementation((theList) => theList),
-    });
-
-    expect(newList).toStrictEqual({
-      headId: '1',
-      items: {
-        1: { id: '1', nextId: '2', previousId: null, surname: 'Ototo' },
-        2: { id: '2', nextId: '3', previousId: '1', name: 'Djamal Dormi' },
-        3: { id: '3', nextId: null, previousId: '2', name: 'Harry Cover' },
-      },
-    });
-  });
-});