@gabrielrufino/cube 1.0.1 → 1.0.6

package/src/DoublyLinkedList/index.spec.ts

@@ -1,478 +0,0 @@
-import {describe, it, expect} from '@jest/globals';
-
-import DoublyLinkedList from './';
-
-describe('DoublyLinkedList', () => {
-	it('Should create an empty doubly linked list with no problems', () => {
-		const doublyLinkedList = new DoublyLinkedList();
-
-		expect(doublyLinkedList.data).toEqual([]);
-		expect(doublyLinkedList.size).toBe(0);
-	});
-
-	it('Should creat a filled doubly linked list with no problems', () => {
-		const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-
-		expect(doublyLinkedList.data).toEqual([
-			{
-				previous: null,
-				value: 1,
-				next: 2,
-			},
-			{
-				previous: 1,
-				value: 2,
-				next: 3,
-			},
-			{
-				previous: 2,
-				value: 3,
-				next: 4,
-			},
-			{
-				previous: 3,
-				value: 4,
-				next: null,
-			},
-		]);
-		expect(doublyLinkedList.size).toBe(4);
-	});
-
-	describe('.push()', () => {
-		it('Should push a new element in a filled doubly linked list', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			doublyLinkedList.push(5);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 1,
-					next: 2,
-				},
-				{
-					previous: 1,
-					value: 2,
-					next: 3,
-				},
-				{
-					previous: 2,
-					value: 3,
-					next: 4,
-				},
-				{
-					previous: 3,
-					value: 4,
-					next: 5,
-				},
-				{
-					previous: 4,
-					value: 5,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(5);
-		});
-
-		it('Should push a new element in an empty doubly linked list', () => {
-			const doublyLinkedList = new DoublyLinkedList();
-			doublyLinkedList.push(1);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 1,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(1);
-		});
-
-		it('Should return the new element', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.push(5);
-
-			expect(returned).toBe(5);
-		});
-	});
-
-	describe('.getFromPosition()', () => {
-		it('Should return undefined when receive a position lower than zero', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.getFromPosition(-1);
-
-			expect(returned).toBeUndefined();
-		});
-
-		it('Should return undefined when receive a position equals the size', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.getFromPosition(4);
-
-			expect(returned).toBeUndefined();
-		});
-
-		it('Should return undefined when receive a position greater than the size', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.getFromPosition(5);
-
-			expect(returned).toBeUndefined();
-		});
-
-		it('Should return the correct item when closest to the head', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.getFromPosition(1);
-
-			expect(returned).toEqual({
-				previous: 1,
-				value: 2,
-				next: 3,
-			});
-		});
-
-		it('Should return the correct item when closest to the tail', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.getFromPosition(2);
-
-			expect(returned).toEqual({
-				previous: 2,
-				value: 3,
-				next: 4,
-			});
-		});
-	});
-
-	describe('.positionOf()', () => {
-		it('Should return the position of an element', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.positionOf(3);
-
-			expect(returned).toBe(2);
-		});
-
-		it('Should return undefined when the element is not in the doubly linked list', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.positionOf(5);
-
-			expect(returned).toBeUndefined();
-		});
-	});
-
-	describe('.insertInPosition()', () => {
-		it('Should return undefined when receive a negative position', () => {
-			const doublyLinkedList = new DoublyLinkedList();
-			const returned = doublyLinkedList.insertInPosition(1, -1);
-
-			expect(returned).toBeUndefined();
-			expect(doublyLinkedList.data).toEqual([]);
-			expect(doublyLinkedList.size).toBe(0);
-		});
-
-		it('Should return undefined when receive a position greater than the size', () => {
-			const doublyLinkedList = new DoublyLinkedList();
-			const returned = doublyLinkedList.insertInPosition(1, doublyLinkedList.size + 1);
-
-			expect(returned).toBeUndefined();
-			expect(doublyLinkedList.data).toEqual([]);
-			expect(doublyLinkedList.size).toBe(0);
-		});
-
-		it('Should insert a new element in the first position', () => {
-			const doublyLinkedList = new DoublyLinkedList(2);
-			doublyLinkedList.insertInPosition(1, 0);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 1,
-					next: 2,
-				},
-				{
-					previous: 1,
-					value: 2,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(2);
-		});
-
-		it('Should insert a new element in the penultimate position', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 3);
-			doublyLinkedList.insertInPosition(2, 1);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 1,
-					next: 2,
-				},
-				{
-					previous: 1,
-					value: 2,
-					next: 3,
-				},
-				{
-					previous: 2,
-					value: 3,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(3);
-		});
-
-		it('Should insert a new element in the last position', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2);
-			doublyLinkedList.insertInPosition(3, 2);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 1,
-					next: 2,
-				},
-				{
-					previous: 1,
-					value: 2,
-					next: 3,
-				},
-				{
-					previous: 2,
-					value: 3,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(3);
-		});
-
-		it('Should insert a new element in a position closest to the head', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 3, 4, 5);
-			doublyLinkedList.insertInPosition(2, 1);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 1,
-					next: 2,
-				},
-				{
-					previous: 1,
-					value: 2,
-					next: 3,
-				},
-				{
-					previous: 2,
-					value: 3,
-					next: 4,
-				},
-				{
-					previous: 3,
-					value: 4,
-					next: 5,
-				},
-				{
-					previous: 4,
-					value: 5,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(5);
-		});
-
-		it('Should insert a new element in a position closest to the head', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 4, 5);
-			doublyLinkedList.insertInPosition(3, 2);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 1,
-					next: 2,
-				},
-				{
-					previous: 1,
-					value: 2,
-					next: 3,
-				},
-				{
-					previous: 2,
-					value: 3,
-					next: 4,
-				},
-				{
-					previous: 3,
-					value: 4,
-					next: 5,
-				},
-				{
-					previous: 4,
-					value: 5,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(5);
-		});
-
-		it('Should return the inserted element', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 5);
-			const returned = doublyLinkedList.insertInPosition(4, 3);
-
-			expect(returned).toBe(4);
-		});
-	});
-
-	describe('.remove()', () => {
-		it('Should remove an element in the first position', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			doublyLinkedList.remove(1);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 2,
-					next: 3,
-				},
-				{
-					previous: 2,
-					value: 3,
-					next: 4,
-				},
-				{
-					previous: 3,
-					value: 4,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(3);
-		});
-
-		it('Should remove an element in the last position', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			doublyLinkedList.remove(4);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 1,
-					next: 2,
-				},
-				{
-					previous: 1,
-					value: 2,
-					next: 3,
-				},
-				{
-					previous: 2,
-					value: 3,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(3);
-		});
-
-		it('Should remove an element in a middle position', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			doublyLinkedList.remove(3);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 1,
-					next: 2,
-				},
-				{
-					previous: 1,
-					value: 2,
-					next: 4,
-				},
-				{
-					previous: 2,
-					value: 4,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(3);
-		});
-
-		it('Should return the removed element', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.remove(2);
-
-			expect(returned).toBe(2);
-		});
-
-		it('Should return undefined when the element is not in the doubly linked list', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.remove(5);
-
-			expect(returned).toBeUndefined();
-		});
-	});
-
-	describe('.removeFromPosition()', () => {
-		it('Should return undefined when receive a negative position', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.removeFromPosition(-1);
-
-			expect(returned).toBeUndefined();
-		});
-
-		it('Should return undefined when receive a position equals the size', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.removeFromPosition(doublyLinkedList.size);
-
-			expect(returned).toBeUndefined();
-		});
-
-		it('Should return undefined when receive a position greater than the size', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.removeFromPosition(doublyLinkedList.size + 1);
-
-			expect(returned).toBeUndefined();
-		});
-
-		it('Should remove an element from position', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			doublyLinkedList.removeFromPosition(2);
-
-			expect(doublyLinkedList.data).toEqual([
-				{
-					previous: null,
-					value: 1,
-					next: 2,
-				},
-				{
-					previous: 1,
-					value: 2,
-					next: 4,
-				},
-				{
-					previous: 2,
-					value: 4,
-					next: null,
-				},
-			]);
-			expect(doublyLinkedList.size).toBe(3);
-		});
-
-		it('Should return the removed element', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const returned = doublyLinkedList.removeFromPosition(3);
-
-			expect(returned).toBe(4);
-		});
-	});
-
-	describe('Conversion to primitive', () => {
-		it('Should return double-arrow-separated elements in string conversion', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const string = String(doublyLinkedList);
-
-			expect(string).toBe('[Head] 1 <=> 2 <=> 3 <=> 4 [Tail]');
-		});
-
-		it('Should return the doubly linked list size in number conversion', () => {
-			const doublyLinkedList = new DoublyLinkedList(1, 2, 3, 4);
-			const number = Number(doublyLinkedList);
-
-			expect(number).toBe(4);
-		});
-	});
-});

package/src/DoublyLinkedList/index.ts

@@ -1,250 +0,0 @@
-import IDoublyLinkedList, {IDoublyLinkedListItem} from './IDoublyLinkedList';
-import Node from './Node';
-
-export default class DoublyLinkedList<T = number> implements IDoublyLinkedList<T> {
-	private _head: Node<T> | null = null;
-	private _tail: Node<T> | null = null;
-	private _size: number = 0;
-
-	constructor(...inputs: T[]) {
-		if (inputs.length) {
-			const nodes = inputs.map(input => new Node(input));
-
-			for (let i = 0; i < inputs.length; i++) {
-				nodes[i].previous = nodes[i - 1] || null;
-				nodes[i].next = nodes[i + 1] || null;
-			}
-
-			this._head = nodes[0];
-			this._tail = nodes[nodes.length - 1];
-			this._size = inputs.length;
-		}
-	}
-
-	public get data(): IDoublyLinkedListItem<T>[] {
-		let current = this._head;
-		const data = [];
-
-		while (current) {
-			data.push({
-				previous: current.previous?.value || null,
-				value: current.value,
-				next: current.next?.value || null,
-			});
-			current = current.next;
-		}
-
-		return data;
-	}
-
-	public get size(): number {
-		return this._size;
-	}
-
-	/**
-	 * Complexity: O(1)
-	 */
-	public push(element: T): T {
-		const node = new Node(element);
-
-		if (this._tail) {
-			this._tail.next = node;
-			node.previous = this._tail;
-		} else {
-			this._head = node;
-			this._tail = node;
-		}
-
-		this._size += 1;
-		return element;
-	}
-
-	/**
-	 * Complexity: O(n/2)
-	 */
-	public getFromPosition(position: number): IDoublyLinkedListItem<T> | undefined {
-		if (position < 0 || position >= this._size) {
-			return undefined;
-		}
-
-		const distanceToTheHead = position;
-		const distanceToTheTail = this.size - position - 1;
-		let current: Node<T> | null;
-
-		if (distanceToTheTail > distanceToTheHead) {
-			current = this._head;
-
-			for (let i = 0; i < position; i++) {
-				current = current?.next || null;
-			}
-		} else {
-			current = this._tail;
-
-			for (let i = this.size - 1; i > position; i--) {
-				current = current?.previous || null;
-			}
-		}
-
-		if (current?.value) {
-			return {
-				previous: current?.previous?.value || null,
-				value: current?.value,
-				next: current?.next?.value || null,
-			};
-		}
-	}
-
-	public positionOf(element: T): number | undefined {
-		let current = this._head;
-		let position = 0;
-
-		while (current && current.value !== element) {
-			current = current.next;
-			position += 1;
-		}
-
-		return position === this.size ? undefined : position;
-	}
-
-	/**
-	 * Complexity: O(n)
-	 */
-	public insertInPosition(element: T, position: number): T | undefined {
-		if (position < 0 || position > this.size) {
-			return undefined;
-		}
-
-		const node = new Node<T>(element);
-
-		if (position === 0 && this._head) {
-			node.next = this._head;
-			this._head.previous = node;
-			this._head = node;
-
-			this._size += 1;
-
-			return element;
-		}
-
-		if (position === this.size - 1 && this._tail && this._tail.previous) {
-			this._tail.previous.next = node;
-			node.previous = this._tail?.previous || null;
-			node.next = this._tail;
-			this._tail.previous = node;
-
-			this._size += 1;
-
-			return element;
-		}
-
-		if (position === this.size && this._tail) {
-			node.previous = this._tail;
-			this._tail.next = node;
-			this._tail = node;
-
-			this._size += 1;
-
-			return element;
-		}
-
-		const way = this._findFasterWayToPosition(position);
-		let current: Node<T> | null;
-
-		if (way === 'ASC') {
-			current = this._head;
-
-			for (let i = 0; i < position; i++) {
-				current = current?.next || null;
-			}
-		} else {
-			current = this._tail;
-
-			for (let i = this.size - 1; i > position; i--) {
-				current = current?.previous || null;
-			}
-		}
-
-		if (current && current.previous) {
-			current.previous.next = node;
-			node.previous = current.previous;
-			node.next = current;
-			current.previous = node;
-		}
-
-		this._size += 1;
-
-		return element;
-	}
-
-	/**
-	 * Complexity: O(n)
-	 */
-	public remove(element: T): T | undefined {
-		let current = this._head;
-
-		while (current && current.value !== element) {
-			current = current.next;
-		}
-
-		if (current) {
-			if (current.previous) {
-				current.previous.next = current.next;
-			}
-
-			if (current.next) {
-				current.next.previous = current.previous;
-			}
-
-			if (current === this._head) {
-				this._head = current.next;
-			}
-
-			if (current === this._tail) {
-				this._tail = current.previous;
-			}
-
-			this._size -= 1;
-
-			return current.value;
-		}
-
-		return undefined;
-	}
-
-	/**
-	 * Complexity: O(n)
-	 */
-	public removeFromPosition(position: number): T | undefined {
-		const item = this.getFromPosition(position);
-
-		if (item) {
-			this.remove(item.value);
-			return item.value;
-		}
-
-		return undefined;
-	}
-
-	private _findFasterWayToPosition(position: number): 'ASC' | 'DESC' {
-		const distanceToTheHead = position;
-		const distanceToTheTail = this.size - position - 1;
-
-		if (distanceToTheTail > distanceToTheHead) {
-			return 'ASC';
-		}
-
-		return 'DESC';
-	}
-
-	private [Symbol.toPrimitive](type: string): string | number | null {
-		if (type === 'string') {
-			return `[Head] ${this.data.map(({value}) => value).join(' <=> ')} [Tail]`;
-		}
-
-		if (type === 'number') {
-			return this.size;
-		}
-
-		return null;
-	}
-}

package/src/Graph/GraphNodeNotFoundError.ts

@@ -1,7 +0,0 @@
-export default class GraphNodeNotFoundError extends Error {
-	constructor(node: string) {
-		super(`Node ${node} not found`);
-
-		this.name = 'GraphNodeNotFoundError';
-	}
-}