@sparted/shared-library 1.9.3 → 1.9.5

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,50 @@
+import { ManipulationConfig, LinkedListItem } from './type';
+
+import {
+  findPreviousId,
+  assertItemCompatibility,
+  assertPresence,
+  assertNewNodePosition,
+} from './linked-list-utils';
+
+export const insertLinkedList = <T extends LinkedListItem>(item: T, config: ManipulationConfig<T>) => {
+  const { format, list, factory } = config;
+
+  assertItemCompatibility(item, format);
+  assertPresence(item.nextId, list.items);
+  assertPresence(item.previousId, list.items);
+
+  const hasPrevious = item.previousId !== undefined;
+
+  const previousId = hasPrevious
+    ? item.previousId!
+    : findPreviousId(item.nextId, list);
+
+  assertNewNodePosition(item, {
+    previousId,
+    list,
+  });
+
+  const newHeadId = item.nextId === list.headId ? item.id : list.headId;
+  const newItems = {
+    ...list.items,
+    ...(previousId ? {
+      [previousId]: {
+        ...list.items[previousId],
+        nextId: item.id,
+      },
+    } : {}),
+    ...(hasPrevious && item.nextId ? {
+      [item.nextId]: {
+        ...list.items[item.nextId],
+        ...(hasPrevious ? { previousId: item.id } : {}),
+      },
+    } : {}),
+    [item.id]: item,
+  };
+
+  return factory({
+    headId: newHeadId,
+    items: newItems,
+  });
+};

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

@@ -0,0 +1,143 @@
+import { runWhile } from '../fp';
+import { LinkedListFormat, LinkedListItem, SimpleLinkedList } from './type';
+
+export type WalkConfig<T extends LinkedListItem, Result> = {
+  startId: string | null,
+  items: Record<string, T>,
+  initValue: Result,
+};
+
+type WalkCallbackResult<R> = {
+  result: R,
+  control?: {
+    stop?: boolean,
+  },
+};
+
+export type WalkCallback<Item, Result> = (accumulator: Result, current: Item) => WalkCallbackResult<Result>;
+
+type RunWhileValue<T> = {
+  currentId: string | null,
+  accumulator: T,
+  control: WalkCallbackResult<any>['control'],
+};
+
+export const walkListItemRecord = <T extends LinkedListItem, Result>(
+  callback: WalkCallback<T, Result>,
+  config: WalkConfig<T, Result>,
+) => {
+  const { items, startId, initValue } = config;
+  const visited = new Set();
+  const totalNodes = Object.keys(items).length;
+
+  const { result } = runWhile({
+    iterationLimit: totalNodes + 1,
+    initialValue: {
+      currentId: startId,
+      accumulator: initValue,
+      control: {
+        stop: false,
+      },
+    } as RunWhileValue<Result>,
+    predicate: ({ control, currentId }) => {
+      const stop = control?.stop;
+      const forcedStop = stop === undefined ? false : stop;
+
+      /**
+       * Stop early or when the end is reached
+       */
+      return !forcedStop && currentId !== null;
+    },
+    callback: (current) => {
+      if (visited.has(current.currentId)) {
+        throw new Error('Infinite loop found');
+      }
+
+      visited.add(current.currentId);
+
+      const currentItem = items[current.currentId!];
+
+      if (!currentItem) {
+        throw new Error('Cul de sac detected');
+      }
+
+      const { result: currentResult, control } = callback(current.accumulator, currentItem);
+
+      return {
+        accumulator: currentResult,
+        currentId: currentItem.nextId,
+        control,
+      };
+    },
+  });
+
+  return result.accumulator;
+};
+
+export const findPreviousId = <T extends LinkedListItem>(id: string | null, list: SimpleLinkedList<T>) => {
+  if (id === list.headId) {
+    return null;
+  }
+
+  return walkListItemRecord(
+    (acc, current) => {
+      if (current.nextId === id) {
+        return {
+          result: current.id,
+          control: {
+            stop: true,
+          },
+        };
+      }
+
+      return {
+        result: acc,
+      };
+    },
+    {
+      initValue: null as null | string,
+      startId: list.headId,
+      items: list.items,
+    },
+  );
+};
+
+export const assertItemCompatibility = <T extends LinkedListItem>(item: T, format: LinkedListFormat | null) => {
+  /**
+   * An empty linked list won't have any format yet, it will be
+   * determined by the first item inserted in the list.
+   */
+  if (format === null) {
+    return;
+  }
+
+  const incompatibleWithDoubleLinks = item.previousId === undefined && format === 'double';
+  const incompatibleWithSingleLink = item.previousId !== undefined && format === 'single';
+
+  if (incompatibleWithDoubleLinks || incompatibleWithSingleLink) {
+    throw new Error(`Node is incompatible with the list (id: ${item.id})`);
+  }
+};
+
+export const assertPresence = (id: string | null | undefined, items: Record<string, unknown>) => {
+  if (id && !items[id]) {
+    throw new Error(`Node not found in the list (id: ${id})`);
+  }
+};
+
+type PositionAssertionConfig = {
+  previousId: string | null,
+  list: SimpleLinkedList<LinkedListItem>,
+};
+
+export const assertNewNodePosition = <T extends LinkedListItem>(item: T, config: PositionAssertionConfig) => {
+  const { previousId, list } = config;
+
+  const insertionMiddleError = previousId && list.items[previousId].nextId !== item.nextId;
+  const insertionTailError = previousId && item.nextId === null && list.items[previousId].nextId !== null;
+  const insertionHeadError = previousId === null && item.nextId !== list.headId;
+
+  if (insertionMiddleError || insertionTailError || insertionHeadError) {
+    throw new Error(`Invalid position for given node (id: ${item.id})`);
+  }
+};

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

@@ -0,0 +1,18 @@
+import { ReduceCallback, LinkedListItem, SimpleLinkedList } from './type';
+import { walkListItemRecord } from './linked-list-utils';
+
+export const reduceLinkedList = <Item extends LinkedListItem, Result>(
+  cb: ReduceCallback<Item, Result>,
+  initValue: Result,
+  list: SimpleLinkedList<Item>,
+): Result => {
+  const { items, headId } = list;
+
+  return walkListItemRecord((acc, current) => ({
+    result: cb(acc, current),
+  }), {
+    startId: headId,
+    items,
+    initValue,
+  });
+};

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

@@ -0,0 +1,36 @@
+import { ManipulationConfig, LinkedListItem } from './type';
+import { assertPresence, findPreviousId } from './linked-list-utils';
+
+export const removeLinkedList = <T extends LinkedListItem>(id: string, config: ManipulationConfig<T>) => {
+  const { format, list, factory } = config;
+  const { [id]: itemToDelete, ...otherItems } = list.items;
+
+  assertPresence(id, list.items);
+
+  const isDoubleLinkList = format === 'double';
+  const previousId = isDoubleLinkList
+    ? itemToDelete.previousId!
+    : findPreviousId(id, list);
+
+  const newHeadId = previousId === null ? itemToDelete.nextId : list.headId;
+  const newItems = {
+    ...otherItems,
+    ...(previousId ? {
+      [previousId]: {
+        ...otherItems[previousId],
+        nextId: itemToDelete.nextId,
+      },
+    } : {}),
+    ...(isDoubleLinkList && itemToDelete.nextId ? {
+      [itemToDelete.nextId]: {
+        ...otherItems[itemToDelete.nextId],
+        ...(isDoubleLinkList ? { previousId } : {}),
+      },
+    } : {}),
+  };
+
+  return factory({
+    headId: newHeadId,
+    items: newItems,
+  });
+};