@gabrielrufino/cube 1.0.1

package/src/Deck/IDeck.ts

@@ -0,0 +1,10 @@
+interface IDeck<T> {
+    addFront(_element: T): T;
+    addBack(_element: T): T;
+    removeFront(): T | undefined;
+    removeBack(): T | undefined;
+    peekFront(): T | undefined;
+    peekBack(): T | undefined;
+}
+
+export default IDeck;

package/src/Deck/index.spec.ts

@@ -0,0 +1,131 @@
+import {describe, it, expect} from '@jest/globals';
+
+import Deck from './';
+
+describe('Deck', () => {
+	it('Should create an empty deck without problems', () => {
+		const deck = new Deck();
+
+		expect(deck.data).toEqual([]);
+		expect(deck.size).toBe(0);
+	});
+
+	it('Should create a filled deck without problems', () => {
+		const deck = new Deck(1, 2, 3, 4);
+
+		expect(deck.data).toEqual([1, 2, 3, 4]);
+		expect(deck.size).toBe(4);
+	});
+
+	describe('.addFront()', () => {
+		it('Should add an element in the front of the deck', () => {
+			const deck = new Deck(2, 3, 4);
+			deck.addFront(1);
+
+			expect(deck.data).toEqual([1, 2, 3, 4]);
+		});
+
+		it('Should return the inserted element', () => {
+			const deck = new Deck(2, 3, 4);
+			const returned = deck.addFront(1);
+
+			expect(returned).toBe(1);
+		});
+	});
+
+	describe('.addBack()', () => {
+		it('Should add an element in the back of the deck', () => {
+			const deck = new Deck(1, 2, 3);
+			deck.addBack(4);
+
+			expect(deck.data).toEqual([1, 2, 3, 4]);
+		});
+
+		it('Should return the inserted element', () => {
+			const deck = new Deck(1, 2, 3);
+			const returned = deck.addBack(4);
+
+			expect(returned).toBe(4);
+		});
+	});
+
+	describe('.removeFront()', () => {
+		it('Should remove the element in the front of the deck', () => {
+			const deck = new Deck(1, 2, 3, 4);
+			deck.removeFront();
+
+			expect(deck.data).toEqual([2, 3, 4]);
+		});
+
+		it('Should return the removed element', () => {
+			const deck = new Deck(1, 2, 3, 4);
+			const returned = deck.removeFront();
+
+			expect(returned).toBe(1);
+		});
+	});
+
+	describe('.removeBack()', () => {
+		it('Should remove the element in the back of the deck', () => {
+			const deck = new Deck(1, 2, 3, 4);
+			deck.removeBack();
+
+			expect(deck.data).toEqual([1, 2, 3]);
+		});
+
+		it('Should return the removed element', () => {
+			const deck = new Deck(1, 2, 3, 4);
+			const returned = deck.removeBack();
+
+			expect(returned).toBe(4);
+		});
+	});
+
+	describe('.peekFront()', () => {
+		it('Should peek the element in the front of the deck', () => {
+			const deck = new Deck(1, 2, 3, 4);
+			const returned = deck.peekFront();
+
+			expect(returned).toBe(1);
+		});
+
+		it('Should not remove the element in the front os the deck', () => {
+			const deck = new Deck(1, 2, 3, 4);
+			deck.peekFront();
+
+			expect(deck.data).toEqual([1, 2, 3, 4]);
+		});
+	});
+
+	describe('.peekBack()', () => {
+		it('Should peek the element in the back of the deck', () => {
+			const deck = new Deck(1, 2, 3, 4);
+			const returned = deck.peekBack();
+
+			expect(returned).toBe(4);
+		});
+
+		it('Should not remove the element in the back os the deck', () => {
+			const deck = new Deck(1, 2, 3, 4);
+			deck.peekBack();
+
+			expect(deck.data).toEqual([1, 2, 3, 4]);
+		});
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return comma-separated elements in string conversion', () => {
+			const deck = new Deck(1, 2, 3, 4);
+			const string = String(deck);
+
+			expect(string).toBe('[Front] 1, 2, 3, 4 [Back]');
+		});
+
+		it('Should return the deck size in number conversion', () => {
+			const deck = new Deck(1, 2, 3, 4);
+			const number = Number(deck);
+
+			expect(number).toBe(4);
+		});
+	});
+});

package/src/Deck/index.ts

@@ -0,0 +1,51 @@
+import DataStructure from '../DataStructure';
+import IDeck from './IDeck';
+
+export default class Deck<T = number> extends DataStructure<T> implements IDeck<T> {
+	constructor(...inputs: T[]) {
+		super(inputs);
+	}
+
+	public addFront(element: T): T {
+		this._data = [element, ...this.data];
+		return element;
+	}
+
+	public addBack(element: T): T {
+		this._data = [...this.data, element];
+		return element;
+	}
+
+	public removeFront(): T | undefined {
+		const [element, ...rest] = this.data;
+		this._data = rest;
+		return element;
+	}
+
+	public removeBack(): T | undefined {
+		const element = this._data.pop();
+		return element;
+	}
+
+	public peekFront(): T | undefined {
+		const [element] = this.data;
+		return element;
+	}
+
+	public peekBack(): T | undefined {
+		const element = this.data[this.size - 1];
+		return element;
+	}
+
+	private [Symbol.toPrimitive](type: string): string | number | null {
+		if (type === 'string') {
+			return `[Front] ${this.data.join(', ')} [Back]`;
+		}
+
+		if (type === 'number') {
+			return this.size;
+		}
+
+		return null;
+	}
+}

package/src/Dictionary/IDictionary.ts

@@ -0,0 +1,18 @@
+import IDictionaryData from './IDictionaryData';
+
+interface IDictionary<T> {
+	get data(): IDictionaryData<T>;
+	get size(): number;
+	get isEmpty(): boolean;
+	get keys(): string[];
+	get values(): T[];
+	get pairs(): [string, T][]
+	set(_key: string, _value: T): [string, T];
+	remove(_key: string): [string, T] | null;
+	hasKey(_key: string): boolean;
+	get(_key: string): T | null;
+	clear(): IDictionaryData<T>
+	forEach(_func: (_key: string, _value: T) => any): void;
+}
+
+export default IDictionary;

package/src/Dictionary/IDictionaryData.ts

@@ -0,0 +1,5 @@
+interface IDictionaryData<T> {
+	[key: string]: T
+}
+
+export default IDictionaryData;

package/src/Dictionary/index.spec.ts

@@ -0,0 +1,310 @@
+import {describe, it, expect, jest} from '@jest/globals';
+
+import Dictionary from './';
+
+describe('Dictionary', () => {
+	it('Should create an empty dictionary without problems', () => {
+		const dictionary = new Dictionary<number>();
+
+		expect(dictionary.data).toEqual({});
+		expect(dictionary.size).toBe(0);
+	});
+
+	it('Should create a filled dictionary without problems', () => {
+		const dictionary = new Dictionary<number>({
+			first: 1,
+			second: 2,
+			third: 3,
+			fourth: 4,
+		});
+
+		expect(dictionary.data).toEqual({
+			first: 1,
+			second: 2,
+			third: 3,
+			fourth: 4,
+		});
+		expect(dictionary.size).toBe(4);
+	});
+
+	describe('.isEmpty', () => {
+		it('Should return true when the dictionary has no key value pairs', () => {
+			const dictionary = new Dictionary({});
+
+			expect(dictionary.isEmpty).toBe(true);
+		});
+
+		it('Should return false when the dictionary has some key value pair', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+			});
+
+			expect(dictionary.isEmpty).toBe(false);
+		});
+	});
+
+	describe('.keys', () => {
+		it('Should return an array with all the dictionary keys', () => {
+			const dictionary = new Dictionary<number>({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+
+			expect(dictionary.keys.sort()).toEqual(['first', 'second', 'third', 'fourth'].sort());
+		});
+	});
+
+	describe('.values', () => {
+		it('Should return an array with all the dictionary values', () => {
+			const dictionary = new Dictionary<number>({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+
+			expect(dictionary.values.sort()).toEqual([1, 2, 3, 4].sort());
+		});
+	});
+
+	describe('.pairs', () => {
+		it('Should return an array of key value pairs', () => {
+			const dictionary = new Dictionary<number>({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+
+			expect(dictionary.pairs.sort())
+				.toEqual([['first', 1], ['second', 2], ['third', 3], ['fourth', 4]].sort());
+		});
+	});
+
+	describe('.set()', () => {
+		it('Should set a new key with a value in the dictionary', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+			});
+			dictionary.set('second', 2);
+
+			expect(dictionary.data).toEqual({
+				first: 1,
+				second: 2,
+			});
+			expect(dictionary.size).toBe(2);
+		});
+
+		it('Should replace a key value pair when receive an already existent key', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+			});
+			dictionary.set('first', 2);
+
+			expect(dictionary.data).toEqual({
+				first: 2,
+			});
+			expect(dictionary.size).toBe(1);
+		});
+
+		it('Should return the inserted key valur pair', () => {
+			const dictionary = new Dictionary();
+			const returned = dictionary.set('first', 1);
+
+			expect(returned).toEqual(['first', 1]);
+		});
+	});
+
+	describe('.remove()', () => {
+		it('Should remove an existent key value pair', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			dictionary.remove('third');
+
+			expect(dictionary.data).toEqual({
+				first: 1,
+				second: 2,
+				fourth: 4,
+			});
+			expect(dictionary.size).toBe(3);
+		});
+
+		it('Should change nothing when receive a non existent key', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			dictionary.remove('fifth');
+
+			expect(dictionary.data).toEqual({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			expect(dictionary.size).toBe(4);
+		});
+
+		it('Should return the removed key value pair', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			const returned = dictionary.remove('second');
+
+			expect(returned).toEqual(['second', 2]);
+		});
+
+		it('Should return null when the dictionary has not the received key', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			const returned = dictionary.remove('fifth');
+
+			expect(returned).toBeNull();
+		});
+	});
+
+	describe('.hasKey()', () => {
+		it('Should return truw when the dictionary has the received key', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			const returned = dictionary.hasKey('first');
+
+			expect(returned).toBe(true);
+		});
+
+		it('Should return false when the dictionary has not the received key', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			const returned = dictionary.hasKey('fifth');
+
+			expect(returned).toBe(false);
+		});
+	});
+
+	describe('.get()', () => {
+		it('Should return the value of the received key', () => {
+			const dictionary = new Dictionary<number>({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			const returned = dictionary.get('third');
+
+			expect(returned).toBe(3);
+		});
+
+		it('Should return null when the dictionary has not the received key', () => {
+			const dictionary = new Dictionary<number>({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			const returned = dictionary.get('fifth');
+
+			expect(returned).toBeNull();
+		});
+	});
+
+	describe('.clear()', () => {
+		it('Should clear the dictionary', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 3,
+			});
+			dictionary.clear();
+
+			expect(dictionary.data).toEqual({});
+			expect(dictionary.size).toBe(0);
+		});
+
+		it('Should return the dictionary key values pairs befores the clear', () => {
+			const dictionary = new Dictionary({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 3,
+			});
+			const returned = dictionary.clear();
+
+			expect(returned).toEqual({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 3,
+			});
+		});
+	});
+
+	describe('.forEach()', () => {
+		it('Should call the received function for each elements', () => {
+			const dictionary = new Dictionary<number>({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			const func = jest.fn();
+
+			dictionary.forEach(func);
+
+			expect(func).toBeCalledTimes(4);
+			expect(func).toBeCalledWith('first', 1);
+			expect(func).toBeCalledWith('second', 2);
+			expect(func).toBeCalledWith('third', 3);
+			expect(func).toBeCalledWith('fourth', 4);
+		});
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return a comma separated key value pairs in string conversion', () => {
+			const dictionary = new Dictionary<number>({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			const string = String(dictionary);
+
+			expect(string).toBe('{ first => 1, second => 2, third => 3, fourth => 4 }');
+		});
+
+		it('Should return the dictionary size in number conversion', () => {
+			const dictionary = new Dictionary<number>({
+				first: 1,
+				second: 2,
+				third: 3,
+				fourth: 4,
+			});
+			const number = Number(dictionary);
+
+			expect(number).toBe(4);
+		});
+	});
+});

package/src/Dictionary/index.ts

@@ -0,0 +1,88 @@
+import IDictionary from './IDictionary';
+import IDictionaryData from './IDictionaryData';
+
+export default class Dictionary<T = number> implements IDictionary<T> {
+	private _data: IDictionaryData<T> = {};
+
+	constructor(inputs: { [key: string]: T } = {}) {
+		this._data = inputs;
+	}
+
+	get data(): IDictionaryData<T> {
+		return {...this._data};
+	}
+
+	get size(): number {
+		return Reflect.ownKeys(this.data).length;
+	}
+
+	get isEmpty(): boolean {
+		return this.size === 0;
+	}
+
+	get keys(): string[] {
+		return Reflect
+			.ownKeys(this.data)
+			.map(key => String(key));
+	}
+
+	get values(): T[] {
+		return Object.values(this.data);
+	}
+
+	get pairs(): [string, T][] {
+		return Object.entries(this.data);
+	}
+
+	public set(key: string, value: T): [string, T] {
+		Reflect.set(this._data, key, value);
+		return [key, value];
+	}
+
+	public remove(key: string): [string, T] | null {
+		if (this.hasKey(key)) {
+			const value = Reflect.get(this.data, key);
+			Reflect.deleteProperty(this._data, key);
+
+			return [key, value];
+		}
+
+		return null;
+	}
+
+	public hasKey(key: string): boolean {
+		return Reflect.has(this.data, key);
+	}
+
+	public get(key: string): T | null {
+		if (this.hasKey(key)) {
+			return Reflect.get(this.data, key);
+		}
+
+		return null;
+	}
+
+	public clear(): IDictionaryData<T> {
+		const dictionary = {...this.data};
+		this._data = {};
+		return dictionary;
+	}
+
+	public forEach(func: (_key: string, _value: T) => any): void {
+		for (const [key, value] of this.pairs) {
+			func(key, value);
+		}
+	}
+
+	private[Symbol.toPrimitive](type: string): string | number | null {
+		if (type === 'string') {
+			return `{ ${this.pairs.map(([key, value]) => `${key} => ${value}`).join(', ')} }`;
+		}
+
+		if (type === 'number') {
+			return this.size;
+		}
+
+		return null;
+	}
+}

package/src/DoublyLinkedList/IDoublyLinkedList.ts

@@ -0,0 +1,18 @@
+export interface IDoublyLinkedListItem<T> {
+  previous: T | null;
+  value: T;
+  next: T | null;
+}
+
+interface IDoublyLinkedList<T> {
+  get data(): IDoublyLinkedListItem<T>[];
+  get size(): number;
+  push(_element: T): T;
+  getFromPosition(_position: number): IDoublyLinkedListItem<T> | undefined;
+  positionOf(_element: T): number | undefined;
+  insertInPosition(_element: T, _position: number): T | undefined;
+  remove(_element: T): T | undefined;
+  removeFromPosition(_position: number): T | undefined;
+}
+
+export default IDoublyLinkedList;

package/src/DoublyLinkedList/Node.ts

@@ -0,0 +1,9 @@
+export default class Node<T> {
+	public value: T;
+	public previous: Node<T> | null = null;
+	public next: Node<T> | null = null;
+
+	constructor(value: T) {
+		this.value = value;
+	}
+}