@thzero/library_server 0.17.3 → 0.17.5

package/utility/list/doubleLinked.js

@@ -1,88 +1,88 @@
-class DoubleLinkedList {
-	constructor() {
-		this._map = new Map();
-		this._head = null;
-		this._pointer = null;
-		this._tail = null;
-	}
-
-	add(processId, proxy) {
-		const node = { processId: processId, proxy: proxy };
-		this._map.set(processId, node);
-
-		// no element in list
-		if (!this._head) {
-			this._head = node;
-			this._pointer = node;
-			this._tail = node;
-			return;
-		}
-
-		// adding to the tail
-		this._tail.next = node;
-		node.previous = this._tail;
-		this._tail = node;
-	}
-
-	decrementPointer() {
-		this._pointer = this._pointer.previous ? this._pointer.previous : this._tail;
-		return this._pointer;
-	}
-
-	get(processId) {
-		return this._map.get(processId);
-	}
-
-	has(processId) {
-		return this._map.has(processId);
-	}
-
-	incrementPointer() {
-		this._pointer = this._pointer.next ? this._pointer.next : this._head;
-
-		return this._pointer;
-	}
-
-	remove(processId) {
-		const node = this.get(processId);
-		if (!node)
-			return;
-
-		if (node.previous)
-			node.previous.next = node.next;
-		if (node.next)
-			node.next.previous = node.previous;
-
-		if (this._head === node)
-			this._head = node.next;
-		if (this._tail === node)
-			this._tail = node.previous;
-
-		if (this._pointer === node) {
-			this._pointer = node.next;
-			if (!this._pointer)
-				this._pointer = this._head;
-		}
-
-		this._map.delete(processId);
-	}
-
-	setPointer(processId) {
-		const node = this._map.get(processId);
-		if (!node)
-			return;
-
-		this._pointer = node;
-		return this._pointer;
-	}
-
-	get length() {
-		return this._map.size;
-	}
-
-	get pointer() {
-		return this._pointer;
-	}
-}
-
-export default DoubleLinkedList;
+class DoubleLinkedList {
+	constructor() {
+		this._map = new Map();
+		this._head = null;
+		this._pointer = null;
+		this._tail = null;
+	}
+
+	add(processId, proxy) {
+		const node = { processId: processId, proxy: proxy };
+		this._map.set(processId, node);
+
+		// no element in list
+		if (!this._head) {
+			this._head = node;
+			this._pointer = node;
+			this._tail = node;
+			return;
+		}
+
+		// adding to the tail
+		this._tail.next = node;
+		node.previous = this._tail;
+		this._tail = node;
+	}
+
+	decrementPointer() {
+		this._pointer = this._pointer.previous ? this._pointer.previous : this._tail;
+		return this._pointer;
+	}
+
+	get(processId) {
+		return this._map.get(processId);
+	}
+
+	has(processId) {
+		return this._map.has(processId);
+	}
+
+	incrementPointer() {
+		this._pointer = this._pointer.next ? this._pointer.next : this._head;
+
+		return this._pointer;
+	}
+
+	remove(processId) {
+		const node = this.get(processId);
+		if (!node)
+			return;
+
+		if (node.previous)
+			node.previous.next = node.next;
+		if (node.next)
+			node.next.previous = node.previous;
+
+		if (this._head === node)
+			this._head = node.next;
+		if (this._tail === node)
+			this._tail = node.previous;
+
+		if (this._pointer === node) {
+			this._pointer = node.next;
+			if (!this._pointer)
+				this._pointer = this._head;
+		}
+
+		this._map.delete(processId);
+	}
+
+	setPointer(processId) {
+		const node = this._map.get(processId);
+		if (!node)
+			return;
+
+		this._pointer = node;
+		return this._pointer;
+	}
+
+	get length() {
+		return this._map.size;
+	}
+
+	get pointer() {
+		return this._pointer;
+	}
+}
+
+export default DoubleLinkedList;

package/utility/list/priorityQueue.js

@@ -1,109 +1,109 @@
-class PriorityQueue {
-	constructor() {
-		this._values = [];
-	}
-
-	dequeue() {
-		// swap first and last element
-		this._swap(0, this._values.length - 1);
-		// pop max value off of values
-		let poppedNode = this._values.pop();
-		// re-adjust heap if length is greater than 1
-		if (this._values.length > 1)
-			this._bubbleDown();
-
-		return poppedNode;
-	}
-
-	//  method that pushes new value onto the end and calls the bubble helper
-	enqueue(value) {
-		this._values.push(value)
-		// calculate parent, if parent is greater swap
-		// while loop or recurse
-		this._bubbleUp();
-		return this._values
-	}
-
-	length() {
-		return this._values.length;
-	}
-
-	_bubbleDown() {
-		let parentIndex = 0;
-		const length = this._values.length;
-		const elementPriority = this._values[0].priority;
-		// loop breaks if no swaps are needed
-		// eslint-disable-next-line
-		while (true) {
-			// get indexes of child elements by following formula
-			let leftChildIndex = (2 * parentIndex) + 1;
-			let rightChildIndex = (2 * parentIndex) + 2;
-			let leftChildPriority, rightChildPriority;
-			let indexToSwap = null;
-
-			//  if left child exists, and is greater than the element, plan to swap with the left child index
-			if (leftChildIndex < length) {
-				leftChildPriority = this._values[leftChildIndex].priority;
-				if (leftChildPriority < elementPriority)
-					indexToSwap = leftChildIndex;
-
-			}
-
-			// if right child exists
-			if (rightChildIndex < length) {
-				rightChildPriority = this._values[rightChildIndex].priority;
-
-				if (
-					// if right child is greater than element and there are no plans to swap
-					(rightChildPriority < elementPriority && indexToSwap === null) ||
-					// OR if right child is greater than left child and there ARE plans to swap
-					(rightChildPriority < leftChildPriority && indexToSwap !== null))
-				{
-					// plan to swap with the right child
-					indexToSwap = rightChildIndex;
-				}
-			}
-
-			// if there are no plans to swap, break out of the loop
-			if (indexToSwap === null)
-				break;
-
-			// swap with planned element
-			this._swap(parentIndex, indexToSwap);
-			// starting index is now index that we swapped with
-			parentIndex = indexToSwap;
-		}
-	}
-
-	// helper methods that bubbles up values from end
-	_bubbleUp() {
-		// get index of inserted element
-		let index = this._values.length - 1;
-		// loop while index is not 0 or element no loger needs to bubble
-		while (index > 0) {
-			// get parent index via formula
-			let parentIndex = Math.floor((index - 1)/2);
-			// if values is greater than parent, swap the two
-			if (this._values[parentIndex].priority > this._values[index].priority) {
-				// swap with helper method
-				this._swap(index, parentIndex);
-				// change current index to parent index
-				index = parentIndex;
-				continue;
-			}
-
-			break;
-		}
-
-		return 0;
-	}
-
-	_swap(index1, index2) {
-		let temp = this._values[index1];
-		this._values[index1] = this._values[index2];
-		this._values[index2] = temp;
-		return this._values;
-	}
-}
-
-export default PriorityQueue;
+class PriorityQueue {
+	constructor() {
+		this._values = [];
+	}
+
+	dequeue() {
+		// swap first and last element
+		this._swap(0, this._values.length - 1);
+		// pop max value off of values
+		let poppedNode = this._values.pop();
+		// re-adjust heap if length is greater than 1
+		if (this._values.length > 1)
+			this._bubbleDown();
+
+		return poppedNode;
+	}
+
+	//  method that pushes new value onto the end and calls the bubble helper
+	enqueue(value) {
+		this._values.push(value)
+		// calculate parent, if parent is greater swap
+		// while loop or recurse
+		this._bubbleUp();
+		return this._values
+	}
+
+	length() {
+		return this._values.length;
+	}
+
+	_bubbleDown() {
+		let parentIndex = 0;
+		const length = this._values.length;
+		const elementPriority = this._values[0].priority;
+		// loop breaks if no swaps are needed
+		// eslint-disable-next-line
+		while (true) {
+			// get indexes of child elements by following formula
+			let leftChildIndex = (2 * parentIndex) + 1;
+			let rightChildIndex = (2 * parentIndex) + 2;
+			let leftChildPriority, rightChildPriority;
+			let indexToSwap = null;
+
+			//  if left child exists, and is greater than the element, plan to swap with the left child index
+			if (leftChildIndex < length) {
+				leftChildPriority = this._values[leftChildIndex].priority;
+				if (leftChildPriority < elementPriority)
+					indexToSwap = leftChildIndex;
+
+			}
+
+			// if right child exists
+			if (rightChildIndex < length) {
+				rightChildPriority = this._values[rightChildIndex].priority;
+
+				if (
+					// if right child is greater than element and there are no plans to swap
+					(rightChildPriority < elementPriority && indexToSwap === null) ||
+					// OR if right child is greater than left child and there ARE plans to swap
+					(rightChildPriority < leftChildPriority && indexToSwap !== null))
+				{
+					// plan to swap with the right child
+					indexToSwap = rightChildIndex;
+				}
+			}
+
+			// if there are no plans to swap, break out of the loop
+			if (indexToSwap === null)
+				break;
+
+			// swap with planned element
+			this._swap(parentIndex, indexToSwap);
+			// starting index is now index that we swapped with
+			parentIndex = indexToSwap;
+		}
+	}
+
+	// helper methods that bubbles up values from end
+	_bubbleUp() {
+		// get index of inserted element
+		let index = this._values.length - 1;
+		// loop while index is not 0 or element no loger needs to bubble
+		while (index > 0) {
+			// get parent index via formula
+			let parentIndex = Math.floor((index - 1)/2);
+			// if values is greater than parent, swap the two
+			if (this._values[parentIndex].priority > this._values[index].priority) {
+				// swap with helper method
+				this._swap(index, parentIndex);
+				// change current index to parent index
+				index = parentIndex;
+				continue;
+			}
+
+			break;
+		}
+
+		return 0;
+	}
+
+	_swap(index1, index2) {
+		let temp = this._values[index1];
+		this._values[index1] = this._values[index2];
+		this._values[index2] = temp;
+		return this._values;
+	}
+}
+
+export default PriorityQueue;

package/utility/list/queue.js

@@ -1,72 +1,72 @@
-/*
-
-Queue.js
-
-A function to represent a queue
-
-Created by Kate Morley - http://code.iamkate.com/ - and released under the terms
-of the CC0 1.0 Universal legal code:
-
-http://creativecommons.org/publicdomain/zero/1.0/legalcode
-
-*/
-
-/* Creates a new queue. A queue is a first-in-first-out (FIFO) data structure -
- * items are added to the end of the queue and removed from the front.
- */
-function Queue(){
-
-	// initialise the queue and offset
-	var queue	= [];
-	var offset = 0;
-
-	// Returns the length of the queue.
-	this.length = function(){
-		return (queue.length - offset);
-	}
-
-	// Returns true if the queue is empty, and false otherwise.
-	this.isEmpty = function(){
-		return (queue.length == 0);
-	}
-
-	/* Enqueues the specified item. The parameter is:
-	 *
-	 * item - the item to enqueue
-	 */
-	this.enqueue = function(item){
-		queue.push(item);
-	}
-
-	/* Dequeues an item and returns it. If the queue is empty, the value
-	 * 'undefined' is returned.
-	 */
-	this.dequeue = function(){
-
-		// if the queue is empty, return immediately
-		if (queue.length == 0) return undefined;
-
-		// store the item at the front of the queue
-		var item = queue[offset];
-
-		// increment the offset and remove the free space if necessary
-		if (++ offset * 2 >= queue.length){
-		queue	= queue.slice(offset);
-		offset = 0;
-		}
-
-		// return the dequeued item
-		return item;
-
-	}
-
-	/* Returns the item at the front of the queue (without dequeuing it). If the
-	 * queue is empty then undefined is returned.
-	 */
-	this.peek = function(){
-		return (queue.length > 0 ? queue[offset] : undefined);
-	}
-
-	}
-
-export default Queue;
+/*
+
+Queue.js
+
+A function to represent a queue
+
+Created by Kate Morley - http://code.iamkate.com/ - and released under the terms
+of the CC0 1.0 Universal legal code:
+
+http://creativecommons.org/publicdomain/zero/1.0/legalcode
+
+*/
+
+/* Creates a new queue. A queue is a first-in-first-out (FIFO) data structure -
+ * items are added to the end of the queue and removed from the front.
+ */
+function Queue(){
+
+	// initialise the queue and offset
+	var queue	= [];
+	var offset = 0;
+
+	// Returns the length of the queue.
+	this.length = function(){
+		return (queue.length - offset);
+	}
+
+	// Returns true if the queue is empty, and false otherwise.
+	this.isEmpty = function(){
+		return (queue.length == 0);
+	}
+
+	/* Enqueues the specified item. The parameter is:
+	 *
+	 * item - the item to enqueue
+	 */
+	this.enqueue = function(item){
+		queue.push(item);
+	}
+
+	/* Dequeues an item and returns it. If the queue is empty, the value
+	 * 'undefined' is returned.
+	 */
+	this.dequeue = function(){
+
+		// if the queue is empty, return immediately
+		if (queue.length == 0) return undefined;
+
+		// store the item at the front of the queue
+		var item = queue[offset];
+
+		// increment the offset and remove the free space if necessary
+		if (++ offset * 2 >= queue.length){
+		queue	= queue.slice(offset);
+		offset = 0;
+		}
+
+		// return the dequeued item
+		return item;
+
+	}
+
+	/* Returns the item at the front of the queue (without dequeuing it). If the
+	 * queue is empty then undefined is returned.
+	 */
+	this.peek = function(){
+		return (queue.length > 0 ? queue[offset] : undefined);
+	}
+
+	}
+
+export default Queue;

package/utility/os.js

@@ -1,20 +1,20 @@
-import os from 'os';
-
-class OsUtility {
-	static get isLinux() {
-		const type = os.type();
-		return (/^linux/i.test(type) || /^freebsd/i.test(type) || /^darwin/i.test(type));
-	}
-
-	static get isMac() {
-		const type = os.type();
-		return (/^darwin/i.test(type));
-	}
-
-	static get isWin() {
-		const type = os.type();
-		return (/^win/i.test(type));
-	}
-}
-
-export default OsUtility;
+import os from 'os';
+
+class OsUtility {
+	static get isLinux() {
+		const type = os.type();
+		return (/^linux/i.test(type) || /^freebsd/i.test(type) || /^darwin/i.test(type));
+	}
+
+	static get isMac() {
+		const type = os.type();
+		return (/^darwin/i.test(type));
+	}
+
+	static get isWin() {
+		const type = os.type();
+		return (/^win/i.test(type));
+	}
+}
+
+export default OsUtility;