@gabrielrufino/cube 1.0.1

package/src/Graph/GraphSearchNodeStates.ts

@@ -0,0 +1,8 @@
+/* eslint-disable no-unused-vars */
+enum GraphSearchNodeStates {
+	UNEXPLORED,
+	DISCOVERED,
+	EXPLORED,
+}
+
+export default GraphSearchNodeStates;

package/src/Graph/IGraph.ts

@@ -0,0 +1,15 @@
+interface IGraph {
+	get isDirected(): boolean;
+	get data(): { [key: string]: string[] };
+	get size(): number;
+	get nodes(): string[];
+	get edges(): [string, string][];
+	insert(_node: string): string | null;
+	// Remove(_node: string): string | null;
+	connect(_node1: string, _node2: string): [string, string];
+	// Disconnect(_node1: string, _node2: string): [string, string] | null;
+	breadthFirstSearch(_startNode: string, _callback: (_node: string) => void): void;
+	getDistancesFrom(_node: string): { [key: string]: number };
+}
+
+export default IGraph;

package/src/Graph/IGraphOptions.ts

@@ -0,0 +1,6 @@
+interface IGraphOptions {
+	inputs?: { [key: string]: string[] },
+	isDirected?: boolean;
+}
+
+export default IGraphOptions;

package/src/Graph/index.spec.ts

@@ -0,0 +1,318 @@
+import {describe, it, expect, jest} from '@jest/globals';
+import faker from 'faker';
+
+import Graph from './';
+import GraphNodeNotFoundError from './GraphNodeNotFoundError';
+
+describe('Graph', () => {
+	it('Should create an empty graph without problems', () => {
+		const graph = new Graph();
+
+		expect(graph.data).toEqual({});
+		expect(graph.size).toBe(0);
+	});
+
+	it('Should create a filled graph without problems', () => {
+		const graph = new Graph({
+			inputs: {
+				A: ['B', 'C', 'D'],
+				B: ['A', 'C'],
+				C: ['A', 'B'],
+				D: ['A'],
+			},
+		});
+
+		expect(graph.data).toEqual({
+			A: ['B', 'C', 'D'],
+			B: ['A', 'C'],
+			C: ['A', 'B'],
+			D: ['A'],
+		});
+		expect(graph.size).toBe(4);
+	});
+
+	it('Should throw an error when receive a link with a non existent node', () => {
+		expect(() => {
+			// eslint-disable-next-line no-new
+			new Graph({
+				inputs: {
+					A: ['B'],
+					B: ['C'],
+					C: [],
+				},
+			});
+		}).not.toThrow(new GraphNodeNotFoundError('C'));
+
+		expect(() => {
+			// eslint-disable-next-line no-new
+			new Graph({
+				inputs: {
+					A: ['B'],
+					B: ['C'],
+				},
+			});
+		}).toThrow(new GraphNodeNotFoundError('C'));
+	});
+
+	describe('.isDirected', () => {
+		it('Should be true when the graph is directed', () => {
+			const graph = new Graph({
+				isDirected: true,
+			});
+
+			expect(graph.isDirected).toBe(true);
+		});
+
+		it('Should be false when the graph is not directed', () => {
+			const graph = new Graph({
+				isDirected: false,
+			});
+
+			expect(graph.isDirected).toBe(false);
+		});
+	});
+
+	describe('.nodes', () => {
+		it('Should be the graph nodes', () => {
+			const graph = new Graph({
+				inputs: {
+					A: ['B'],
+					B: ['C'],
+					C: [],
+				},
+			});
+
+			expect(graph.nodes.sort()).toEqual(['A', 'B', 'C'].sort());
+		});
+	});
+
+	describe('.edges', () => {
+		it('Should be the correct edges when the graph is directed', () => {
+			const graph = new Graph({
+				inputs: {
+					A: ['B'],
+					B: ['A', 'C'],
+					C: [],
+				},
+				isDirected: true,
+			});
+
+			expect(graph.edges).toEqual([
+				['A', 'B'],
+				['B', 'A'],
+				['B', 'C'],
+			]);
+		});
+
+		it('Should be the correct edges when the graph is not directed', () => {
+			const graph = new Graph({
+				inputs: {
+					A: ['B'],
+					B: ['A', 'C'],
+					C: ['B'],
+				},
+				isDirected: false,
+			});
+
+			expect(graph.edges).toEqual([
+				['A', 'B'],
+				['B', 'C'],
+			]);
+		});
+	});
+
+	describe('.insert()', () => {
+		it('Should insert a new node in the graph', () => {
+			const graph = new Graph();
+			graph.insert('A');
+
+			expect(graph.data).toEqual({
+				A: [],
+			});
+			expect(graph.size).toBe(1);
+		});
+
+		it('Should return the inserted node', () => {
+			const graph = new Graph();
+			const returned = graph.insert('A');
+
+			expect(returned).toBe('A');
+		});
+
+		it('Should change nothing if the node is already in the graph', () => {
+			const graph = new Graph({
+				inputs: {
+					A: ['B'],
+					B: ['A'],
+				},
+			});
+			graph.insert('A');
+
+			expect(graph.data).toEqual({
+				A: ['B'],
+				B: ['A'],
+			});
+			expect(graph.size).toBe(2);
+		});
+
+		it('Should return null when the node is already in the graph', () => {
+			const graph = new Graph({
+				inputs: {
+					A: ['B'],
+					B: ['A'],
+				},
+			});
+			const returned = graph.insert('A');
+
+			expect(returned).toBeNull();
+		});
+	});
+
+	describe('.connect()', () => {
+		it('Should connect two different nodes', () => {
+			const graph = new Graph({
+				inputs: {
+					A: [],
+					B: [],
+				},
+			});
+			graph.connect('A', 'B');
+
+			expect(graph.data).toEqual({
+				A: ['B'],
+				B: ['A'],
+			});
+			expect(graph.size).toBe(2);
+		});
+
+		it('Should throw an error when the first node is not in the graph', () => {
+			const graph = new Graph({
+				inputs: {
+					B: [],
+				},
+			});
+
+			expect(() => {
+				graph.connect('A', 'B');
+			}).toThrow(new GraphNodeNotFoundError('A'));
+		});
+
+		it('Should throw an error when the second node is not in the graph', () => {
+			const graph = new Graph({
+				inputs: {
+					A: [],
+				},
+			});
+
+			expect(() => {
+				graph.connect('A', 'B');
+			}).toThrow(new GraphNodeNotFoundError('B'));
+		});
+
+		it('Should connect only the first node to the second when the graph is directed', () => {
+			const graph = new Graph({
+				isDirected: true,
+				inputs: {
+					A: [],
+					B: [],
+				},
+			});
+			graph.connect('A', 'B');
+
+			expect(graph.data).toEqual({
+				A: ['B'],
+				B: [],
+			});
+			expect(graph.size).toBe(2);
+		});
+
+		it('Should return the inserted edge', () => {
+			const graph = new Graph({
+				isDirected: true,
+				inputs: {
+					A: [],
+					B: [],
+				},
+			});
+			const returned = graph.connect('A', 'B');
+
+			expect(returned).toEqual(['A', 'B']);
+		});
+	});
+
+	describe('.breadthFirstSearch()', () => {
+		it('Should traverse all the graph', () => {
+			const keys = new Array(10).fill(undefined).map(faker.datatype.string);
+			const graph = new Graph();
+
+			for (const key of keys) {
+				graph.insert(key);
+			}
+
+			for (const key1 of keys) {
+				for (const key2 of keys) {
+					if (Math.random() > 0.5) {
+						graph.connect(key1, key2);
+					}
+				}
+			}
+
+			const callback = jest.fn();
+			graph.breadthFirstSearch(keys[0], callback);
+
+			expect(callback).toBeCalledTimes(keys.length);
+			for (const key of keys) {
+				expect(callback).toBeCalledWith(key);
+			}
+		});
+
+		it('Should throw an error when the start node is not in the graph', () => {
+			const graph = new Graph({
+				inputs: {
+					A: ['B'],
+					B: ['A'],
+				},
+			});
+
+			expect(() => {
+				graph.breadthFirstSearch('C', jest.fn());
+			}).toThrow(new GraphNodeNotFoundError('C'));
+		});
+	});
+
+	describe('.getDistancesFrom()', () => {
+		it('Should return the distances from the origin to the others nodes', () => {
+			const graph = new Graph({
+				inputs: {
+					A: ['C', 'D', 'E'],
+					B: ['C', 'E'],
+					C: ['A', 'B'],
+					D: ['A'],
+					E: ['A', 'B'],
+				},
+			});
+			const returned = graph.getDistancesFrom('B');
+
+			expect(returned).toEqual({
+				A: 2,
+				B: 0,
+				C: 1,
+				D: 3,
+				E: 1,
+			});
+		});
+
+		it('Should throw an error when the origin node is not in the graph', () => {
+			const graph = new Graph({
+				inputs: {
+					A: ['B'],
+					B: ['A'],
+				},
+			});
+
+			expect(() => {
+				graph.getDistancesFrom('C');
+			}).toThrow(new GraphNodeNotFoundError('C'));
+		});
+	});
+});

package/src/Graph/index.ts

@@ -0,0 +1,170 @@
+import GraphNodeNotFoundError from './GraphNodeNotFoundError';
+import GraphSearchNodeStates from './GraphSearchNodeStates';
+import IGraph from './IGraph';
+import IGraphOptions from './IGraphOptions';
+
+import Dictionary from '../Dictionary';
+import Queue from '../Queue';
+import Set from '../Set';
+
+export default class Graph implements IGraph {
+	private _isDirected: boolean;
+	private _data: Dictionary<Set<string>>;
+
+	constructor({inputs = {}, isDirected = false}: IGraphOptions = {inputs: {}, isDirected: false}) {
+		this._isDirected = isDirected;
+		this._data = new Dictionary<Set<string>>();
+
+		const nodes = Object.keys(inputs);
+		for (const node of nodes) {
+			this.insert(node);
+		}
+
+		for (const node of nodes) {
+			for (const value of inputs[node]) {
+				this.connect(node, value);
+			}
+		}
+	}
+
+	get isDirected(): boolean {
+		return this._isDirected;
+	}
+
+	get data(): { [key: string]: string[]; } {
+		return Object.entries(this._data.data)
+			.reduce((accumulator, [key, value]) => ({
+				...accumulator,
+				[key]: value.data,
+			}), {});
+	}
+
+	get size(): number {
+		return this._data.size;
+	}
+
+	get nodes(): string[] {
+		return [...this._data.keys];
+	}
+
+	get edges(): [string, string][] {
+		if (this.isDirected) {
+			return Object.entries(this.data)
+				.flatMap((
+					[node, links]) => links.map<[string, string]>(link => [node, link]),
+				);
+		}
+
+		return Object.entries(this.data)
+			.reduce<[string, string][]>((accumulator, [node, links]) => {
+				const edges = links
+					.map<[string, string]>(link => [node, link])
+					.filter(edge => !accumulator.find(item => item.includes(edge[0]) && item.includes(edge[1])));
+
+				return [
+					...accumulator,
+					...edges,
+				];
+			}, []);
+	}
+
+	public insert(node: string): string | null {
+		if (this._data.hasKey(node)) {
+			return null;
+		}
+
+		this._data.set(node, new Set<string>());
+
+		return node;
+	}
+
+	public connect(node1: string, node2: string): [string, string] {
+		if (!this._data.hasKey(node1)) {
+			throw new GraphNodeNotFoundError(node1);
+		}
+
+		if (!this._data.hasKey(node2)) {
+			throw new GraphNodeNotFoundError(node2);
+		}
+
+		this._data.get(node1)?.add(node2);
+
+		if (!this._isDirected) {
+			this._data.get(node2)?.add(node1);
+		}
+
+		return [node1, node2];
+	}
+
+	public breadthFirstSearch(startNode: string, callback: (_node: string) => void): void {
+		if (!this._data.hasKey(startNode)) {
+			throw new GraphNodeNotFoundError(startNode);
+		}
+
+		const {nodes} = this;
+		const states: { [key: string]: GraphSearchNodeStates } = nodes.reduce((accumulator, node) => ({
+			...accumulator,
+			[node]: GraphSearchNodeStates.UNEXPLORED,
+		}), {});
+
+		const queue = new Queue<string>();
+		queue.enqueue(startNode);
+
+		while (!queue.isEmpty) {
+			const current = queue.dequeue() || '';
+
+			if (current) {
+				states[current] = GraphSearchNodeStates.DISCOVERED;
+				const neighbors = this._data.get(current)?.data || [];
+				const unexploredNeighbors = neighbors.filter(neighbor => states[neighbor] === GraphSearchNodeStates.UNEXPLORED);
+
+				for (const neighbor of unexploredNeighbors) {
+					states[neighbor] = GraphSearchNodeStates.DISCOVERED;
+					queue.enqueue(neighbor);
+				}
+			}
+
+			states[current] = GraphSearchNodeStates.EXPLORED;
+			callback(current);
+		}
+	}
+
+	public getDistancesFrom(node: string): { [key: string]: number; } {
+		if (!this._data.hasKey(node)) {
+			throw new GraphNodeNotFoundError(node);
+		}
+
+		const {nodes} = this;
+		const states: { [key: string]: GraphSearchNodeStates } = nodes.reduce((accumulator, node) => ({
+			...accumulator,
+			[node]: GraphSearchNodeStates.UNEXPLORED,
+		}), {});
+		const distances: { [key: string]: number } = nodes.reduce((accumulator, node) => ({
+			...accumulator,
+			[node]: 0,
+		}), {});
+
+		const queue = new Queue<string>();
+		queue.enqueue(node);
+
+		while (!queue.isEmpty) {
+			const current = queue.dequeue() || '';
+
+			if (current) {
+				states[current] = GraphSearchNodeStates.DISCOVERED;
+				const neighbors = this._data.get(current)?.data || [];
+				const unexploredNeighbors = neighbors.filter(neighbor => states[neighbor] === GraphSearchNodeStates.UNEXPLORED);
+
+				for (const neighbor of unexploredNeighbors) {
+					states[neighbor] = GraphSearchNodeStates.DISCOVERED;
+					distances[neighbor] = distances[current] + 1;
+					queue.enqueue(neighbor);
+				}
+			}
+
+			states[current] = GraphSearchNodeStates.EXPLORED;
+		}
+
+		return distances;
+	}
+}

package/src/HashTable/IHashTable.ts

@@ -0,0 +1,11 @@
+import IHashTableData from './IHashTableData';
+
+interface IHashTable<T> {
+	get data(): IHashTableData<T>;
+	get size(): number;
+	put(_key: string, _value: T): T;
+	get(_key: string): T | null;
+	remove(_key: string): T | null;
+}
+
+export default IHashTable;

package/src/HashTable/IHashTableData.ts

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

package/src/HashTable/IHashTableInputs.ts

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

package/src/HashTable/IHashTableOptions.ts

@@ -0,0 +1,5 @@
+interface IHashTableOptions {
+	maxSize?: number;
+}
+
+export default IHashTableOptions;

package/src/HashTable/index.spec.ts

@@ -0,0 +1,136 @@
+import {describe, it, expect} from '@jest/globals';
+
+import HashTable from './';
+
+describe('HashTable', () => {
+	it('Should create an empty hash table without problems', () => {
+		const hashTable = new HashTable<number>();
+
+		expect(hashTable.data).toEqual({});
+		expect(hashTable.size).toBe(0);
+	});
+
+	it('Should create an filled hash table without problems', () => {
+		const hashTable = new HashTable<number>({
+			first: 1,
+			second: 2,
+			third: 3,
+			fourth: 4,
+		});
+
+		expect(hashTable.data).toEqual({
+			36: 2,
+			39: 3,
+			52: 1,
+			64: 4,
+		});
+		expect(hashTable.size).toBe(4);
+	});
+
+	describe('.put()', () => {
+		it('Should insert a new element in hash table', () => {
+			const hashTable = new HashTable();
+			hashTable.put('first', 1);
+
+			expect(hashTable.data).toEqual({
+				52: 1,
+			});
+			expect(hashTable.size).toBe(1);
+		});
+
+		it('Should return the inserted element', () => {
+			const hashTable = new HashTable();
+			const returned = hashTable.put('first', 1);
+
+			expect(returned).toEqual(1);
+		});
+	});
+
+	describe('.get()', () => {
+		it('Should return the element of the key', () => {
+			const hashTable = new HashTable({
+				first: 1,
+			});
+			const returned = hashTable.get('first');
+
+			expect(returned).toBe(1);
+		});
+
+		it('Should return null if the key does not exists in the hash table', () => {
+			const hashTable = new HashTable({
+				first: 1,
+			});
+			const returned = hashTable.get('second');
+
+			expect(returned).toBeNull();
+		});
+	});
+
+	describe('.remove()', () => {
+		it('Should remove an existent key value pair', () => {
+			const hashTable = new HashTable<number>({
+				first: 1,
+				second: 2,
+			});
+			hashTable.remove('second');
+
+			expect(hashTable.data).toEqual({
+				52: 1,
+			});
+			expect(hashTable.size).toBe(1);
+		});
+
+		it('Should not change the hash table when receive a non existent key', () => {
+			const hashTable = new HashTable<number>({
+				first: 1,
+			});
+			hashTable.remove('second');
+
+			expect(hashTable.data).toEqual({
+				52: 1,
+			});
+			expect(hashTable.size).toBe(1);
+		});
+
+		it('Should return the removed value', () => {
+			const hashTable = new HashTable({
+				first: 1,
+				second: 2,
+			});
+			const returned = hashTable.remove('second');
+
+			expect(returned).toBe(2);
+		});
+
+		it('Should return null when receive a non existent key', () => {
+			const hashTable = new HashTable({
+				first: 1,
+			});
+			const returned = hashTable.remove('second');
+
+			expect(returned).toBeNull();
+		});
+	});
+
+	describe('Conversion to primitive', () => {
+		it('Should return a separated by comma key value pairs in string conversion', () => {
+			const hashTable = new HashTable({
+				first: 1,
+				second: 2,
+			});
+			const string = String(hashTable);
+
+			expect(string).toBe('[ 36 => 2, 52 => 1 ]');
+		});
+
+		it('Should return the hash table size in number conversion', () => {
+			const hashTable = new HashTable({
+				first: 1,
+				second: 2,
+			});
+			const number = Number(hashTable);
+
+			expect(number).toBe(2);
+		});
+	});
+});