@sparted/shared-library 1.2.0 → 1.2.2

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

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

@@ -1,58 +0,0 @@
-import { whileLinkedList } from '../while-linked-list';
-
-describe('whileLinkedList', () => {
-  it('should return every ids while the predicate is true', () => {
-    const list = {
-      headId: '3',
-      items: {
-        3: {
-          id: '3',
-          nextId: '2',
-        },
-        1: {
-          id: '1',
-          nextId: null,
-        },
-        2: {
-          id: '2',
-          nextId: '1',
-        },
-      },
-    };
-
-    const ids = whileLinkedList(
-      (item) => item.id !== '1',
-      list,
-    );
-
-    expect(ids).toStrictEqual(['3', '2']);
-  });
-
-  it('should return every ids while the predicate is true with a start id', () => {
-    const list = {
-      headId: '3',
-      items: {
-        3: {
-          id: '3',
-          nextId: '2',
-        },
-        1: {
-          id: '1',
-          nextId: null,
-        },
-        2: {
-          id: '2',
-          nextId: '1',
-        },
-      },
-    };
-
-    const ids = whileLinkedList(
-      (item) => item.id !== '1',
-      list,
-      '2',
-    );
-
-    expect(ids).toStrictEqual(['2']);
-  });
-});

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

@@ -1,35 +0,0 @@
-import { LinkedList, LinkedListItem } from './type';
-
-export const applyDiffLinkedList = <T extends LinkedListItem>(
-  before: T | null,
-  after: T | null,
-  list: LinkedList<T>,
-) => {
-  // Delete
-  if (!after && before) {
-    return list.remove(before.id);
-  }
-
-  // Insert
-  if (!before && after) {
-    return list.insert(after);
-  }
-
-  // For the following commands, none of the 2 items can be null
-  // We dont use && because checks are already done above, but ts cannot infer that they cannot be null afterwards
-  if (!before || !after) {
-    throw new Error('Cannot have both before & after as null');
-  }
-
-  if (before.id !== after.id) {
-    throw new Error('Cannot change id of a ListNode');
-  }
-
-  const listWithPotentialReorder = before.nextId === after.nextId
-    ? list
-    : list
-      .remove(before.id)
-      .insert(after);
-
-  return listWithPotentialReorder.update(after);
-};

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

@@ -1,79 +0,0 @@
-import { LinkedListItem, LinkedList, ManipulationConfig, LinkedListFormat } from './type';
-
-import { reduceLinkedList } from './reduce-linked-list';
-import { findLinkedList } from './find-linked-list';
-import { whileLinkedList } from './while-linked-list';
-import { walkListItemRecord } from './linked-list-utils';
-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';
-
-type LinkedListValidation = {
-  format: LinkedListFormat | null,
-  previousId: null | string,
-  count: number,
-};
-
-export const createLinkedList = <T extends LinkedListItem>(headId: string | null, items: Record<string, T>): LinkedList<T> => {
-  const head = headId ? items[headId] : null;
-
-  if (head === undefined) {
-    throw new Error('Cannot find the head.');
-  }
-
-  const list = { headId, items };
-
-  const { format, count } = walkListItemRecord((acc, current) => {
-    const newCount = acc.count + 1;
-    const currentNodeFormat: LinkedListFormat = current.previousId !== undefined ? 'double' : 'single';
-    const incompatibleFormats = acc.format !== null && acc.format !== currentNodeFormat;
-
-    if (incompatibleFormats || (currentNodeFormat === 'double' && current.previousId !== acc.previousId)) {
-      throw new Error('Invalid previous node in the linked list');
-    }
-
-    return {
-      result: {
-        previousId: current.id,
-        format: currentNodeFormat,
-        count: newCount,
-      },
-    };
-  }, {
-    initValue: {
-      format: null,
-      count: 0,
-      previousId: null,
-    } as LinkedListValidation,
-    startId: headId,
-    items,
-  });
-
-  const manipulationConfig: ManipulationConfig<T> = {
-    factory: (newList) => createLinkedList(newList.headId, newList.items),
-    /**
-     * At this point isDoubleLinked cannot be undefined
-     */
-    format,
-    list,
-  };
-
-  const linkedList: LinkedList<T> = {
-    head,
-    items,
-    format,
-    size: count,
-    reduce: (cb, initValue) => reduceLinkedList(cb, initValue, list),
-    find: (predicate) => findLinkedList(predicate, list),
-    while: (predicate, startId) => whileLinkedList(predicate, list, startId),
-    remove: (id) => removeLinkedList(id, manipulationConfig),
-    insert: (item) => insertLinkedList(item, manipulationConfig),
-    get: (id) => getLinkedList(id, list),
-    update: (item) => updateLinkedList(item, manipulationConfig),
-    applyDiff: (before, after) => applyDiffLinkedList(before, after, linkedList),
-  };
-
-  return linkedList;
-};

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

@@ -1,26 +0,0 @@
-import { LinkedListItem, ItemPredicate, SimpleLinkedList } from './type';
-import { walkListItemRecord } from './linked-list-utils';
-
-export const findLinkedList = <Item extends LinkedListItem>(
-  predicate: ItemPredicate<Item>,
-  list: SimpleLinkedList<Item>,
-): Item | null => (
-    walkListItemRecord((acc, item) => {
-      if (predicate(item)) {
-        return {
-          result: item,
-          control: {
-            stop: true,
-          },
-        };
-      }
-
-      return {
-        result: acc,
-      };
-    }, {
-      initValue: null as Item | null,
-      items: list.items,
-      startId: list.headId,
-    })
-  );

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

@@ -1,9 +0,0 @@
-import { SimpleLinkedList, LinkedListItem } from './type';
-
-export const getLinkedList = <T extends LinkedListItem>(id: string, list: SimpleLinkedList<T>) => {
-  if (list.items[id]) {
-    return list.items[id];
-  }
-
-  return null;
-};

package/src/linked-list/index.ts

@@ -1,2 +0,0 @@
-export * from './create-linked-list';
-export * from './type';