@gabrielrufino/cube 1.0.1 → 1.0.3

package/src/Deck/IDeck.ts

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

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

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

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

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

package/src/Dictionary/index.spec.ts

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

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

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

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