qtools-library-dot-d 1.0.8 → 1.0.9

package/libDotD_Working_Example/node_modules/qtools-functional-library/lib/qtools-number-keys-to-array/qtools-number-keys-to-array.js

@@ -0,0 +1,131 @@
+'use strict';
+//START OF moduleFunction() ============================================================
+var moduleFunction = function(args = {}) {
+	const { commonFunctions } = args;
+	
+	const addToPrototypeActual = functionObject => () =>
+		commonFunctions.universalAddToPrototype(commonFunctions, functionObject);
+	
+	
+	
+	//first method definition function ==========================
+	const firstMethodFunction = commonFunctions => {
+		const methodName = 'qtNumberKeysToArray';
+		const description = `object.${methodName}({collapseHoles=true, omitNonNumeric=false, throwErrorIfNonNumeric=false})`;
+		const supportedTypeList = [Object];
+		
+		const baseConversion=function(inData, args={}) {
+				const { collapseHoles = true, omitNonNumeric = false, throwErrorIfNonNumeric=false } = args;
+				if (typeof inData.length != 'undefined') {
+					return inData;
+				}
+
+				var outArray = [];
+				var workingArray = [];
+				const extraElements = [];
+				let maxIndex = 0;
+				
+				let naturalIndex = 0;
+				
+				for (var i in inData) {
+					if (!inData.hasOwnProperty(i)) {
+						continue;
+					}
+
+					var element = inData[i];
+
+					if (isNaN(+i)) {
+						extraElements.push({
+							key: i,
+							value: element
+						});
+						if(throwErrorIfNonNumeric){
+							throw `throwErrorIfNonNumeric set true, non-numeric key '${i}' not allowed`;
+						}
+						continue;
+					}
+
+					if (collapseHoles) {
+						workingArray[naturalIndex] = element;
+						naturalIndex++;
+					} else {
+						workingArray[i] = element;
+						maxIndex = Math.max(maxIndex, i);
+					}
+					
+				}
+				
+				if (!collapseHoles) {
+					
+					for (var i = 0; i < maxIndex + 1; i++) {
+						outArray.push(
+							typeof workingArray[i] != 'undefined' ? workingArray[i] : void ''
+						);
+					}
+					
+				} else {
+					outArray = workingArray;
+				}
+				
+				if (!omitNonNumeric) {
+					for (var i = 0, len = extraElements.length; i < len; i++) {
+						outArray.push(extraElements[i]);
+					}
+				}
+
+				return outArray;
+			};
+
+		const method = () => function(args={}){
+		if (args.shallow){
+			return baseConversion(this, args)
+		}
+		
+		if (
+			typeof this != 'object' ||
+			typeof this.length != 'undefined' ||
+			this == null
+		) {
+			return this;
+		}
+		const keys = Object.keys(this);
+		 for (var i in this) {
+			if (!this.hasOwnProperty(i)) {
+				continue;
+			}
+			this[i] = this[i].qtNumberKeysToArray(args);
+		}
+		const isNumeric = keys.filter(item => !isNaN(+item)).length ? true : false;
+		if (!isNumeric) {
+			return this;
+		}
+			return baseConversion(this, args)
+	
+		
+		}
+			
+
+		const functionObject = new Map(); // prettier-ignore
+		functionObject.set(methodName, {
+			description,
+			supportedTypeList,
+			method,
+			test: args => {
+				return require('./test.js')({
+					...args,
+					...{
+						moduleName: module.id.replace(module.path, '')
+					}
+				});
+			}
+		});
+		return functionObject;
+	};
+	this.addToPrototype = addToPrototypeActual(
+		firstMethodFunction(commonFunctions)
+	);
+	
+};
+//END OF moduleFunction() ============================================================
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();

package/libDotD_Working_Example/node_modules/qtools-functional-library/lib/qtools-number-keys-to-array/test.js

@@ -0,0 +1,181 @@
+'use strict';
+
+//START OF moduleFunction() ============================================================
+
+const moduleFunction = function(args) {
+	//this module is initialized with parameters spec'd in the main function module
+	
+	const completeStepActual = ({
+		verbose = false,
+		logErrors = false,
+		moduleName
+	}) => (methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) => {
+		const thisStepPass = thisStepEvalFunction(thisStepResult);
+
+		if (logErrors && !thisStepPass) {
+			console.log(`FAIL TEST: ${thisStepMessage} in ...${moduleName}`);
+		}
+		if (verbose) {
+			console.log(
+				`Result for: ${methodName} (${thisStepPass ? 'PASS' : 'FAIL'}):`
+			);
+			console.dir(thisStepResult);
+			console.log('\n\n');
+		}
+
+		return passingTests && thisStepPass;
+	};
+
+	const completeStep = completeStepActual(args);
+
+	let passingTests = true;
+
+	let thisStepMessage;
+	let thisStepResult;
+	let thisStepEvalFunction;
+	let methodName;
+
+	//TESTS ============================================================
+
+	
+	
+	const testArray = {
+		['0']: 'zero',
+		['1']: 'one',
+		['4']: 'four',
+		a: 'b'
+	};
+
+	
+	
+	const testArray2 = {
+		['0']: 'zero',
+		['1']: 'one',
+		['4']: 'four',
+		a: 'b',
+		subArray: {
+			['0']: 'zeroX',
+			['1']: 'oneX',
+			['4']: 'fourX'
+		}
+	};
+
+	const emptyArray = {};
+	
+
+	//TEST ITEM ------------------------------------------------------
+	methodName = 'qtNumberKeysToArray';
+	thisStepMessage = 'test #1, result is wrong, holes or length are wrong';
+	thisStepResult = testArray[methodName]({
+		collapseHoles: false,
+		omitNonNumeric: true
+	});
+	thisStepEvalFunction = item =>
+		(item =
+			item.length == 5 &&
+			typeof item[2] == 'undefined' &&
+			typeof item[3] == 'undefined');
+	passingTests =
+		completeStep(
+			methodName,
+			thisStepMessage,
+			thisStepResult,
+			thisStepEvalFunction
+		) && passingTests;
+	
+	
+	//TEST ITEM ------------------------------------------------------
+	methodName = 'qtNumberKeysToArray';
+	thisStepMessage = 'test #2, result is wrong, has holes or length is wrong';
+	thisStepResult = testArray[methodName]({
+		collapseHoles: true,
+		omitNonNumeric: true
+	});
+	thisStepEvalFunction = item =>
+		(item =
+			item.length == 3 &&
+			item.reduce(
+				(item, result) => typeof (item != 'undefined') && result,
+				true
+			));
+	passingTests =
+		completeStep(
+			methodName,
+			thisStepMessage,
+			thisStepResult,
+			thisStepEvalFunction
+		) && passingTests;
+	
+	
+	
+	
+	//TEST ITEM ------------------------------------------------------
+	methodName = 'qtNumberKeysToArray';
+	thisStepMessage =
+		'test #3, result is wrong, non-numeric element is missing or length is wrong';
+	thisStepResult = testArray[methodName]({
+		collapseHoles: true,
+		omitNonNumeric: false
+	});
+	thisStepEvalFunction = item =>
+		(item = item.length == 4 && typeof item[3] == 'object');
+	passingTests =
+		completeStep(
+			methodName,
+			thisStepMessage,
+			thisStepResult,
+			thisStepEvalFunction
+		) && passingTests;
+	
+
+	
+	
+	
+	//TEST ITEM ------------------------------------------------------
+	methodName = 'qtNumberKeysToArray';
+	thisStepMessage = 'test #4, subordinate element was not converted properly';
+	thisStepResult = testArray2[methodName]({
+		collapseHoles: true,
+		omitNonNumeric: false
+	});
+	thisStepEvalFunction = item =>
+		(item =
+			item.length == 5 &&
+			typeof item[4] == 'object' &&
+			item[4].value.length == 3);
+	passingTests =
+		completeStep(
+			methodName,
+			thisStepMessage,
+			thisStepResult,
+			thisStepEvalFunction
+		) && passingTests;
+	
+	
+	//TEST ITEM ------------------------------------------------------
+	methodName = 'qtNumberKeysToArray';
+	thisStepMessage = 'test #5, empty object returns empty array';
+	thisStepResult = emptyArray[methodName]({
+		collapseHoles: true,
+		omitNonNumeric: false
+	});
+	thisStepEvalFunction = item => (item = item.length === 0);
+	passingTests =
+		completeStep(
+			methodName,
+			thisStepMessage,
+			thisStepResult,
+			thisStepEvalFunction
+		) && passingTests;
+	
+	
+	
+
+	return passingTests;
+};
+
+//END OF moduleFunction() ============================================================
+
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();
+

package/libDotD_Working_Example/node_modules/qtools-functional-library/lib/qtools-object-sure-path/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "qtools-object-sure-path",
+  "version": "1.0.0",
+  "description": "mutate properties in an object based on a dotted path",
+  "main": "qtools-object-sure-path.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "TQ White II",
+  "license": "ISC"
+}

package/libDotD_Working_Example/node_modules/qtools-functional-library/lib/qtools-object-sure-path/qtools-object-sure-path.js

@@ -0,0 +1,204 @@
+'use strict';
+//START OF moduleFunction() ============================================================
+var moduleFunction = function(args = {}) {
+	const { commonFunctions } = args;
+	
+	const addToPrototypeActual = functionObject => () =>
+		commonFunctions.universalAddToPrototype(commonFunctions, functionObject);
+	
+
+		let getDottedPathLastProgressiveString = ''; //needed for recursive function
+		let putDottedPathLastProgressiveString=''; //needed for recursive function
+	
+		function qtGetSurePath(dottedPathString, defaultReturn) {
+			var baseObj = this;
+			var target = this;
+			var elements;
+			
+			if (typeof(dottedPathString)!='string'){
+				console.trace();
+				throw `qtGetSurePath() says, dottedPathString argument is ${typeof(dottedPathString)}, must be of type string`;
+			}
+			
+			if (dottedPathString==''){
+				return defaultReturn;
+			}
+
+			if (baseObj == null) {
+				if (
+					typeof defaultReturn != 'undefined' &&
+					typeof target == 'undefined'
+				) {
+					return defaultReturn;
+				} else {
+					return;
+				}
+			}
+			if (dottedPathString.toString().match(/\.|\[/)) {
+				var elements = dottedPathString.split(/\.|\[(.*?)]/);
+			} else {
+				var elements = [];
+				elements.push(dottedPathString);
+			}
+
+			if (!dottedPathString) {
+				return baseObj;
+			}
+
+			if (elements.length < 2) {
+				if (
+					typeof defaultReturn != 'undefined' &&
+					typeof baseObj[dottedPathString] == 'undefined'
+				) {
+					return defaultReturn;
+				}
+				return baseObj[dottedPathString];
+			} else {
+				for (var i = 0, len = elements.length; i < len; i++) {
+					if (elements[i]) {
+						//mainly eliminates trailing periods but would also eliminates double periods and other regex anomalies
+						target = target?target[elements[i]]:undefined;
+
+						getDottedPathLastProgressiveString += elements[i] + '.';
+						if (typeof target == 'undefined' || target === '') {
+							if (
+								typeof defaultReturn != 'undefined' &&
+								(typeof target == 'undefined' || target === '')
+							) {
+								return defaultReturn;
+							}
+
+							return;
+						}
+					}
+				}
+			}
+
+			return target;
+		}
+		
+		function qtPutSurePath(dottedPathString, value, preserveExisting) {
+			var baseObj = this;
+			var elements;
+			var intermediate;
+			var propName;
+			putDottedPathLastProgressiveString = '';
+
+			preserveExisting =
+				typeof preserveExisting != 'undefined' ? preserveExisting : false;
+
+			if (baseObj == null) {
+				throw 'qtGetDottedPath() says, baseObj cannot be nullx ' +
+					dottedPathString;
+			}
+			if (dottedPathString.toString().match(/\.|\[/)) {
+				var elements = dottedPathString.split(/\.|(\[.*?)]/);
+			} else {
+				var elements = [];
+				elements.push(dottedPathString);
+			}
+
+			if (!dottedPathString) {
+				return baseObj;
+			}
+			if (dottedPathString.match(/(__proto__|constructor|prototype)/)){
+				return baseObj; //avoid prototype pollution
+			}
+
+			if (elements.length < 2) {
+				baseObj[dottedPathString] = value;
+			} else {
+				intermediate = baseObj;
+				for (var i = 0, len = elements.length; i < len; i++) {
+					if (elements[i]) {
+						//mainly eliminates trailing periods but would also eliminates double periods and other regex anomalies
+						propName = elements[i];
+
+						if (elements[i + 1] && elements[i + 1].replace(/^\[/)) {
+							elements[i + 1] = elements[i + 1].replace(/^\[/, '');
+							var nextElement = [];
+							var nextElementType = 'array';
+						} else {
+							var nextElement = {};
+							var nextElementType = 'object';
+						}
+
+						if (propName) {
+							//ignore trailing and redundant dots
+							if (
+								commonFunctions.toType(intermediate[propName]) !=
+								nextElementType
+							) {
+								intermediate[propName] = nextElement;
+							} else if (preserveExisting) {
+								throw "'preserveExisting' flag is set, found non-object in path: " +
+									propName +
+									' in ' +
+									dottedPathString;
+							}
+
+							intermediate = intermediate[propName];
+						}
+					}
+				}
+
+				intermediate = baseObj;
+				for (var i = 0, len = elements.length; i < len - 1; i++) {
+					if (elements[i]) {
+						//mainly eliminates trailing periods but would also eliminate double periods
+						propName = elements[i];
+						intermediate = intermediate[propName];
+					}
+				}
+
+				intermediate[elements[len - 1]] = value;
+			}
+			return baseObj;
+		}
+		
+
+	
+	
+	//first method definition function ==========================
+	const firstMethodFunction = commonFunctions => {
+		const functionObject = new Map(); // prettier-ignore
+		
+		functionObject.set('qtGetSurePath', {
+			description: `({}).qtGetSurePath('path.to.something', defaultValue) retrieves the value at the end of the dotted path. It does not crash in an intermediate path element is undefined. If it is, qtGetSurePath() returns either undefined or defaultValue`,
+			supportedTypeList: [Object],
+			method: () => qtGetSurePath,
+			test: args => {
+				return require('./test.js')({
+					...args,
+					...{
+						moduleName: module.id.replace(module.path, '')
+					}
+				});
+			}
+		});
+		
+		functionObject.set('qtPutSurePath', {
+			description: `({}).qtPutSurePath('path.to'value', valueToBePut, preserveExisting) injects a value into an object by creating, if necessary, any intermediary objects to complete the path. If preserveExisting==true, nothing is placed if a value is already present.`,
+			supportedTypeList: [Object],
+			method: () => qtPutSurePath,
+			test: args => {
+				return require('./test.js')({
+					...args,
+					...{
+						moduleName: module.id.replace(module.path, '')
+					}
+				});
+			}
+		});
+		
+		
+		return functionObject;
+	};  
+	 this.addToPrototype = addToPrototypeActual(
+		firstMethodFunction(commonFunctions)
+	);
+	
+};
+//END OF moduleFunction() ============================================================
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();