@gabrielrufino/cube 1.0.1 → 1.0.6

package/src/Graph/GraphSearchNodeStates.ts

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

package/src/Graph/IGraph.ts

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

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

package/src/Graph/index.spec.ts

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

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

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

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

package/src/HashTable/IHashTableInputs.ts

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

package/src/HashTable/IHashTableOptions.ts

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

package/src/HashTable/index.spec.ts

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