@thzero/library_server 0.18.5 → 0.18.7

package/service/version.js

@@ -1,37 +1,37 @@
-import fs from 'fs';
-import path from 'path';
-
-import Service from './index.js';
-
-class VersionService extends Service {
-	async version(correlationId) {
-		try {
-			const filePath = path.join(process.cwd(), 'package.json');
-			const file = fs.readFileSync(filePath, 'utf8');
-			if (String.isNullOrEmpty(file))
-				throw Error('Invalid package.json file for versioning; expected in the <app root> folder.');
-	
-			const packageObj = JSON.parse(file);
-			if (!packageObj)
-				throw Error('Invalid package.json file for versioning.');
-	
-			return this._generate(correlationId, packageObj.version_major, packageObj.version_minor, packageObj.version_patch, packageObj.version_date);
-		}
-		catch (err) {
-			return this._error('VersionService', 'version', null, err, null, null, correlationId);
-		}
-	}
-
-	_generate(correlationId, version_major, version_minor, version_patch, version_date) {
-		const response = this._success(correlationId);
-		response.results = {
-			major: version_major,
-			minor: version_minor,
-			patch: version_patch,
-			date: version_date
-		};
-		return response;
-	}
-}
-
-export default VersionService;
+import fs from 'fs';
+import path from 'path';
+
+import Service from './index.js';
+
+class VersionService extends Service {
+	async version(correlationId) {
+		try {
+			const filePath = path.join(process.cwd(), 'package.json');
+			const file = fs.readFileSync(filePath, 'utf8');
+			if (String.isNullOrEmpty(file))
+				throw Error('Invalid package.json file for versioning; expected in the <app root> folder.');
+	
+			const packageObj = JSON.parse(file);
+			if (!packageObj)
+				throw Error('Invalid package.json file for versioning.');
+	
+			return this._generate(correlationId, packageObj.version_major, packageObj.version_minor, packageObj.version_patch, packageObj.version_date);
+		}
+		catch (err) {
+			return this._error('VersionService', 'version', null, err, null, null, correlationId);
+		}
+	}
+
+	_generate(correlationId, version_major, version_minor, version_patch, version_date) {
+		const response = this._success(correlationId);
+		response.results = {
+			major: version_major,
+			minor: version_minor,
+			patch: version_patch,
+			date: version_date
+		};
+		return response;
+	}
+}
+
+export default VersionService;

package/utility/injector.js

@@ -1,59 +1,59 @@
-class Injector {
-	constructor() {
-		this._di = {};
-	}
-
-	addService(key, dependency) {
-		if (String.isNullOrEmpty(key))
-			throw Error(`Invalid injector key '${key}'.`);
-		if (!dependency)
-			throw Error('Invalid injector dependency.');
-
-		if (this._di[key])
-			return;
-
-		this._di[key] = { dependency: dependency };
-	}
-
-	addSingleton(key, dependency) {
-		if (String.isNullOrEmpty(key))
-			throw Error(`Invalid injector key '${key}'.`);
-		if (!dependency)
-			throw Error('Invalid injector dependency.');
-
-		if (this._di[key])
-			return;
-
-		this._di[key] = { key: key, singleton: true, dependency: dependency };
-	}
-
-	getInjector() {
-		return this._di;
-	}
-
-	getService(key, args) {
-		if (String.isNullOrEmpty(key))
-			throw Error(`Invalid injector key '${key}'.`);
-
-		const result = this._di[key];
-		if (!result)
-			return null;
-
-		if (result.singleton)
-			return result.dependency;
-
-		return new result.dependency.prototype.constructor(args);
-	}
-
-	getServices() {
-		return Object.values(this._di);
-	}
-
-	getSingletons() {
-		return Object.values(this._di).filter(l => l.singleton).map(l => l.dependency);
-	}
-}
-
-const singletonInstance = new Injector();
-Object.freeze(singletonInstance);
-export default singletonInstance;
+class Injector {
+	constructor() {
+		this._di = {};
+	}
+
+	addService(key, dependency) {
+		if (String.isNullOrEmpty(key))
+			throw Error(`Invalid injector key '${key}'.`);
+		if (!dependency)
+			throw Error('Invalid injector dependency.');
+
+		if (this._di[key])
+			return;
+
+		this._di[key] = { dependency: dependency };
+	}
+
+	addSingleton(key, dependency) {
+		if (String.isNullOrEmpty(key))
+			throw Error(`Invalid injector key '${key}'.`);
+		if (!dependency)
+			throw Error('Invalid injector dependency.');
+
+		if (this._di[key])
+			return;
+
+		this._di[key] = { key: key, singleton: true, dependency: dependency };
+	}
+
+	getInjector() {
+		return this._di;
+	}
+
+	getService(key, args) {
+		if (String.isNullOrEmpty(key))
+			throw Error(`Invalid injector key '${key}'.`);
+
+		const result = this._di[key];
+		if (!result)
+			return null;
+
+		if (result.singleton)
+			return result.dependency;
+
+		return new result.dependency.prototype.constructor(args);
+	}
+
+	getServices() {
+		return Object.values(this._di);
+	}
+
+	getSingletons() {
+		return Object.values(this._di).filter(l => l.singleton).map(l => l.dependency);
+	}
+}
+
+const singletonInstance = new Injector();
+Object.freeze(singletonInstance);
+export default singletonInstance;

package/utility/internalIp/index.js

@@ -1,49 +1,49 @@
-import {networkInterfaces} from 'os';
-import defaultGateway from 'default-gateway';
-import ip from 'ipaddr.js';
-
-function findIp(gateway) {
-	const gatewayIp = ip.parse(gateway);
-
-	// Look for the matching interface in all local interfaces.
-	for (const addresses of Object.values(networkInterfaces())) {
-		for (const {cidr} of addresses) {
-			const net = ip.parseCIDR(cidr);
-
-			// eslint-disable-next-line unicorn/prefer-regexp-test
-			if (net[0] && net[0].kind() === gatewayIp.kind() && gatewayIp.match(net)) {
-				return net[0].toString();
-			}
-		}
-	}
-}
-
-async function async(family) {
-	try {
-		const {gateway} = await defaultGateway[family]();
-		return findIp(gateway);
-	} catch {}
-}
-
-function sync(family) {
-	try {
-		const {gateway} = defaultGateway[family].sync();
-		return findIp(gateway);
-	} catch {}
-}
-
-export async function internalIpV6() {
-	return async('v6');
-}
-
-export async function internalIpV4() {
-	return async('v4');
-}
-
-export function internalIpV6Sync() {
-	return sync('v6');
-}
-
-export function internalIpV4Sync() {
-	return sync('v4');
+import {networkInterfaces} from 'os';
+import defaultGateway from 'default-gateway';
+import ip from 'ipaddr.js';
+
+function findIp(gateway) {
+	const gatewayIp = ip.parse(gateway);
+
+	// Look for the matching interface in all local interfaces.
+	for (const addresses of Object.values(networkInterfaces())) {
+		for (const {cidr} of addresses) {
+			const net = ip.parseCIDR(cidr);
+
+			// eslint-disable-next-line unicorn/prefer-regexp-test
+			if (net[0] && net[0].kind() === gatewayIp.kind() && gatewayIp.match(net)) {
+				return net[0].toString();
+			}
+		}
+	}
+}
+
+async function async(family) {
+	try {
+		const {gateway} = await defaultGateway[family]();
+		return findIp(gateway);
+	} catch {}
+}
+
+function sync(family) {
+	try {
+		const {gateway} = defaultGateway[family].sync();
+		return findIp(gateway);
+	} catch {}
+}
+
+export async function internalIpV6() {
+	return async('v6');
+}
+
+export async function internalIpV4() {
+	return async('v4');
+}
+
+export function internalIpV6Sync() {
+	return sync('v6');
+}
+
+export function internalIpV4Sync() {
+	return sync('v4');
 }

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;