qtools-functional-library 1.1.10 → 1.1.12

package/README.md

@@ -4,20 +4,26 @@ This is a collection of tools that allow chained operations on various Javascrip
 
 Most of the functions included in this library (except, eg, qt.log()) are implemented on the prototype of the data type in question. For example, almost any element can take the .qtDump() function.
 
-- qtools-clone
-- qtools-get-by-property
-- qtools-includes-regex
-- qtools-log-output
-- qtools-merge
-- qtools-new-method-template
-- qtools-number-iterator
-- qtools-number-keys-to-array
-- qtools-object-sure-path
-- qtools-pass-through
-- qtools-pop
+- qtools-clone: Does a deep clone of an object or array.
+- qtools-get-by-property: Operates on an array of objects. Retrieves one or more elements based on the value of an object property specified by a dotted path.
+- qtools-includes-regex: Operations on a simple array of strings. Retrieves one or more elements based on an regEx match.
+- qtools-log-output: Substitutes properties into a <!template!> string and send to log. (Note to self, verify array operation)
+- qtools-merge: Deep merge of two objects including array propterties.
+- qtools-number-iterator: Operates on a number. EG, (5).qtStart(7).qtIncrement(3).qtIterate(item=>item*100)
+- qtools-number-keys-to-array: Converts an object with properties that are numbers to an array, including subordinate properties.
+- qtools-object-sure-path: Gets or Sets the value of a property based on a dotted string path. No crash if intermediate elements are missing. Provides default. Predates and is prettier to use than optional chaining and supports setting the value.
+- qtools-pass-through: Sits in a declarative chain and executes an arbitrary function. It returns 'this' regardless of what the function does. 'this' is available to the function.
+- qtools-pop: Pops the last value off an array. If a default is supplied and there is nothing left on the list, that will be returned. Really good for ArrayOfObjects.qtPop({}).
+- qtools-qtLast: Delivers the element that would have been pop'd but does not change the array.
+- qtoolspush: Pushes a value onto an array and returns the array (unlike normal .push() which returns the length of the array)
 - qtools-print-debug
 - qtools-template-replace
 - qtools-to-key-value-array
 - qtools-to-string
 
+NEW:
+
+- qtools-select-properties
+- qtools-map-properties
+
 DESCRIPTION

package/lib/qtools-map-properties/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "qtools-map-properties",
+  "version": "1.0.0",
+  "description": " Transform and add properties to a javascript object or array of objects",
+  "main": "qtools-map-properties.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "TQ White II",
+  "license": "ISC"
+}

package/lib/qtools-map-properties/qtools-map-properties.js

@@ -0,0 +1,99 @@
+'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 = 'qtMapProperties';
+		const description = `operand.qtMapProperties() transforms and adds properties to a javascript object or array of objects`;
+		const supportedTypeList = [Array, Object];
+
+		const method = () =>
+			function(mappings = {}, options = {}) {
+				const mappingFunction = item => {
+					const outObj = item.qtClone();
+					const originalThis = item.qtClone();
+
+					// mappingElementFunction=(item, name, entire)=>{}; //note: synthetic elements have item==undefined
+
+					Object.keys(mappings).forEach(name => {
+						if (typeof mappings[name] == 'function') {
+							outObj[name] = mappings[name](
+								originalThis[name],
+								name,
+								originalThis
+							);
+						} else {
+							outObj[name] = mappings[name];
+						}
+					});
+					return outObj;
+				};
+
+				
+				
+				if (this instanceof Array) {
+					return this.map(item => mappingFunction(item));
+				} else {
+					return mappingFunction(this);
+				}
+				
+			};
+
+		const test = args => {
+			return require('./test.js')({
+				...args,
+				...{
+					moduleName: module.id.replace(module.path, '')
+				}
+			});
+		};
+
+		return {
+			methodName,
+			description,
+			supportedTypeList,
+			method,
+			test
+		};
+	};
+	
+	
+	const functionObject = new Map(); // prettier-ignore
+	const addFunction = definition => {
+		const {
+			methodName,
+			description,
+			supportedTypeList,
+			method,
+			test
+		} = definition;
+		functionObject.set(methodName, {
+			description,
+			supportedTypeList,
+			method,
+			test: args => {
+				return require('./test.js')({
+					...args,
+					...{
+						moduleName: module.id.replace(module.path, '')
+					}
+				});
+			}
+		});
+	};
+	
+	addFunction(firstMethodFunction());
+
+	this.addToPrototype = addToPrototypeActual(functionObject);
+	
+};
+//END OF moduleFunction() ============================================================
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();

package/lib/qtools-map-properties/test.js

@@ -0,0 +1,118 @@
+'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 testObject={
+		one: 1,
+		two: 2
+	}
+	
+	const testArray=[
+	{
+		alpha: 11,
+		beta: 12
+	},{
+		alpha: 21,
+		beta: 22
+	}
+	];
+	
+	const testOneArgument={
+		one: (item, name, entire)=>item*1000
+	}
+	const testTwoArgument={
+		one: (item, name, entire)=>item*1000,
+		addedValue:(item, name, entire)=>`${name} says, item:${item} becomes ${Object.keys(entire).join(', ')}`
+	}
+	const testThreeArgument={
+		alpha: (item, name, entire)=>item*1000,
+		addedValue:(item, name, entire)=>`${name} says, item:${item} becomes ${Object.keys(entire).join(', ')}`
+	}
+// map one object 
+// map one with added property
+// map array 
+
+
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtMapProperties'
+	thisStepMessage = "did not get map one object ";
+	thisStepResult = testObject[methodName](testOneArgument);
+	thisStepEvalFunction = item => (item.one==1000 && item.two==2);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+	
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtMapProperties'
+	thisStepMessage = "did not map one with added property";
+	thisStepResult = testObject[methodName](testTwoArgument);
+	thisStepEvalFunction = item => (item.one==1000 && item.two==2 && item.addedValue=='addedValue says, item:undefined becomes one, two');
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+	
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtMapProperties'
+	thisStepMessage = "did not map array woth added property";
+	thisStepResult = testArray[methodName](testThreeArgument);
+	thisStepEvalFunction = item => (
+		item[0].alpha==11000 &&
+		item[0].beta==12 &&
+		item[0].addedValue=='addedValue says, item:undefined becomes alpha, beta' &&
+		item[1].alpha==21000 &&
+		item[1].beta==22 &&
+		item[1].addedValue=='addedValue says, item:undefined becomes alpha, beta'
+	);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+	
+	
+	return passingTests;
+};
+
+//END OF moduleFunction() ============================================================
+
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();
+

package/lib/qtools-merge/test.js

@@ -123,10 +123,6 @@ const moduleFunction = function(args) {
 	methodName='qtMerge'
 	thisStepMessage = "Failed to replace base type with complex one or vice versa";
 	thisStepResult = arrayTestA[methodName](arrayTestE, {mergeNonExistent:true});
-thisStepResult.qtDump({label:"thisStepResult"});
-
-
-
 	thisStepEvalFunction = item => 
 		item.qtGetSurePath('c.arrayOfBasicTypes[0]')=='replacesFirst' &&
 		item.qtGetSurePath('c.arrayOfBasicTypes[1]')=='second';

package/lib/qtools-number-keys-to-array/test.js

@@ -5,24 +5,24 @@
 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 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.log(
+				`Result for: ${methodName} (${thisStepPass ? 'PASS' : 'FAIL'}):`
+			);
 			console.dir(thisStepResult);
 			console.log('\n\n');
 		}
-		
+
 		return passingTests && thisStepPass;
 	};
 
@@ -40,82 +40,133 @@ const moduleFunction = function(args) {
 	
 	
 	const testArray = {
-['0']:'zero',
-['1']:'one',
-['4']:'four',
-a:'b'
-
-}
+		['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'},
-
-}
+		['0']: 'zero',
+		['1']: 'one',
+		['4']: 'four',
+		a: 'b',
+		subArray: {
+			['0']: 'zeroX',
+			['1']: 'oneX',
+			['4']: 'fourX'
+		}
+	};
 
-const emptyArray={}
+	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');
+	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;
+		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));
+	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;
+		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');
+	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;
+		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);
+	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;
+		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);
+	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;
+		completeStep(
+			methodName,
+			thisStepMessage,
+			thisStepResult,
+			thisStepEvalFunction
+		) && passingTests;
 	
 	
 	

package/lib/qtools-pop/qtools-pop.js

@@ -102,6 +102,41 @@ var moduleFunction = function(args = {}) {
 			test
 		};
 	};
+	//fourth method definition function ==========================
+	const fourthMethodFunction = commonFunctions => {
+		const methodName = 'qtFirst';
+		const description = `operand.qtFirst(value) gets element zero or default`;
+		const supportedTypeList = [Array];
+
+		const method = () =>
+			function(value) {
+				const inData = this;
+				if (typeof inData.length == 'undefined') {
+					throw 'array.qtFirst(defaultValue=undefined) works for Arrays only';
+				}
+				const arrayValue = inData[0]?inData[0]:void('');
+				const result =
+					typeof arrayValue != 'undefined' ? arrayValue : defaultValue;
+				return result;
+			};
+
+		const test = args => {
+			return require('./test.js')({
+				...args,
+				...{
+					moduleName: module.id.replace(module.path, '')
+				}
+			});
+		};
+
+		return {
+			methodName,
+			description,
+			supportedTypeList,
+			method,
+			test
+		};
+	};
 	
 	const functionObject = new Map(); // prettier-ignore
 	const addFunction = definition => {
@@ -130,6 +165,7 @@ var moduleFunction = function(args = {}) {
 	addFunction(firstMethodFunction());
 	addFunction(secondMethodFunction());
 	addFunction(thirdMethodFunction());
+	addFunction(fourthMethodFunction());
 
 	this.addToPrototype = addToPrototypeActual(functionObject);
 	

package/lib/qtools-pop/test.js

@@ -96,6 +96,15 @@ const moduleFunction = function(args) {
 		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
 		passingTests;
 	
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtFirst'
+	thisStepMessage = "element was not added";
+	thisStepResult = testArray[methodName]();
+	thisStepEvalFunction = item => (item=='allocute' && item.length==2);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+	
 	
 	
 

package/lib/qtools-select-properties/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "qtools-select-properties",
+  "version": "1.0.0",
+  "description": "Create new objects (or list of objects) containing only the enumerated properties. Allows defaults to be supplied for missing properties. If an enumerated property name does not exist at all, a property with the default value is created.",
+  "main": "qtools-select-properties.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "TQ White II",
+  "license": "ISC"
+}

package/lib/qtools-select-properties/qtools-select-properties.js

@@ -0,0 +1,132 @@
+'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 = 'qtSelectProperties';
+		const description = `operand.qtSelectProperties(value) create snew objects (or list of objects) containing only the enumerated properties. Allows defaults to be supplied for missing properties. If an enumerated property name does not exist at all, a property with the default value is created.`;
+		const supportedTypeList = [Array, Object];
+
+		const method = () =>
+			function(keepers, options = {}) {
+				
+				const {
+					moreDefaultValues = {},
+					omitUndefined = true,
+					excludeMode = false
+				} = options;
+
+				if (!(keepers instanceof Object)) {
+					throw new Error(
+						'qtSelectProperties() argument one must be instance of Object or Array'
+					);
+				}
+
+				let inclusions = keepers;
+				let defaultValues = {};
+				if (!(keepers instanceof Array)) {
+					inclusions = Object.keys(keepers);
+					defaultValues = keepers;
+				}
+				
+				Object.keys(moreDefaultValues).forEach(
+					name => (defaultValues[name] = moreDefaultValues[name])
+				);
+
+				const selectingFunction = currentObject => {
+					const getDefault = (currentObject, keeperName) =>
+						typeof defaultValues[keeperName] == 'function'
+							? defaultValues[keeperName](currentObject.qtClone(), keeperName)
+							: defaultValues[keeperName];
+
+					// defaultFunction=(currentObject, elementName)=>{}
+
+					let outObj = {};
+
+					if (!excludeMode) {
+						inclusions.forEach(keeperName => {
+							const newValue =
+								typeof currentObject[keeperName] != 'undefined'
+									? currentObject[keeperName]
+									: getDefault(currentObject, keeperName);
+							if (typeof newValue != 'undefined' || !omitUndefined) {
+								outObj[keeperName] = newValue;
+							}
+						});
+					} else {
+						outObj = currentObject;
+						inclusions.forEach(keeperName => {
+							if (typeof (outObj[keeperName] == 'undefined')) {
+								delete outObj[keeperName];
+							}
+						});
+					}
+
+					return outObj;
+				};
+				
+
+				if (this instanceof Array) {
+					return this.map(item => selectingFunction(item));
+				} else {
+					return selectingFunction(this);
+				}
+			};
+
+		const test = args => {
+			return require('./test.js')({
+				...args,
+				...{
+					moduleName: module.id.replace(module.path, '')
+				}
+			});
+		};
+
+		return {
+			methodName,
+			description,
+			supportedTypeList,
+			method,
+			test
+		};
+	};
+	
+	const functionObject = new Map(); // prettier-ignore
+	const addFunction = definition => {
+		const {
+			methodName,
+			description,
+			supportedTypeList,
+			method,
+			test
+		} = definition;
+		functionObject.set(methodName, {
+			description,
+			supportedTypeList,
+			method,
+			test: args => {
+				return require('./test.js')({
+					...args,
+					...{
+						moduleName: module.id.replace(module.path, '')
+					}
+				});
+			}
+		});
+	};
+	
+	addFunction(firstMethodFunction());
+
+	this.addToPrototype = addToPrototypeActual(functionObject);
+	
+};
+//END OF moduleFunction() ============================================================
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();

package/lib/qtools-select-properties/test.js

@@ -0,0 +1,156 @@
+'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 testObject={
+		one: 1,
+		two: 2
+	}
+	
+	const testArray=[
+	{
+		alpha: 11,
+		beta: 12,
+		gamma:13
+	},{
+		alpha: 21,
+		gamma:23
+	}
+	];
+	
+	const testOneArgument=[ 'one'];
+	const testTwoArgument=['alpha'];
+	
+	const testThreeArgument=['alpha', 'beta'];
+	const testThreeMoreValues={moreDefaultValues:{beta:(currentObject, elementName)=>`default function ${elementName} produces ${Object.keys(currentObject).join(', ')}`}}
+	
+	const testFourArgument={
+		alpha: (item, name, entire)=>item*1000,
+		addedValue:(item, name, entire)=>`${name} says, item:${item} becomes ${Object.keys(entire).join(', ')}`
+	}
+	
+	const testFiveArgument={
+		alpha: 'eleven',
+		beta: 'twelve'
+	}
+	
+// array of strings for one object 
+// array of strings for array of objects
+// array of strings for one object with moreDefaultValues
+// object with defaults for object 
+// EXCLUDE MODE
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtSelectProperties'
+	thisStepMessage = "did not get array of strings for one object ";
+	thisStepResult = testObject[methodName](testOneArgument);
+	thisStepEvalFunction = item => (item.one==1 && typeof(item.two)=='undefined');
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests; 
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtSelectProperties'
+	thisStepMessage = "did not get array of strings for array of objects";
+	thisStepResult = testArray[methodName](testTwoArgument);
+	thisStepEvalFunction = item => (
+		item[0].alpha==11 &&
+		typeof(item[0].beta)=='undefined' &&
+		item[1].alpha==21 &&
+		typeof(item[1].beta)=='undefined'
+	);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests; 
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtSelectProperties'
+	thisStepMessage = "did not get array of strings for one object with moreDefaultValues";
+	thisStepResult = testArray[methodName](testThreeArgument, testThreeMoreValues);
+	thisStepEvalFunction = item => (
+		item[0].alpha==11 &&
+		item[0].beta==12 &&
+		item[1].alpha==21 &&
+		item[1].beta=='default function beta produces alpha, gamma'
+	);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtSelectProperties'
+	thisStepMessage = "did not get object argument containing defaults";
+	thisStepResult = testArray[methodName](testFiveArgument);
+	thisStepEvalFunction = item => (
+		item[0].alpha==11 &&
+		item[0].beta==12 &&
+		item[1].alpha==21 &&
+		item[1].beta=='twelve'
+	);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtSelectProperties'
+	thisStepMessage = "did not get EXCLUDE MODE";
+	thisStepResult = testArray[methodName](testThreeArgument, {excludeMode:true});
+	thisStepEvalFunction = item => (
+		typeof(item[0].alpha)=='undefined' &&
+		typeof(item[0].beta)=='undefined' &&
+		item[0].gamma==13 &&
+		typeof(item[1].alpha)=='undefined' &&
+		typeof(item[1].beta)=='undefined' &&
+		item[1].gamma==23
+	);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+	
+	
+	
+
+	return passingTests;
+};
+
+//END OF moduleFunction() ============================================================
+
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();
+

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "qtools-functional-library",
-  "version": "1.1.10",
+  "version": "1.1.12",
   "description": "Useful additions to JS prototypes to facilliate chainable, functional (mostly) style. Also make life more convenient.\"",
   "main": "qtools-functional-library.js",
   "scripts": {
     "sample": "node test.js -listTests -logErrors -verbose --methodList=qtClone,qtToString,qtPop",
     "sample2": "node test.js -listTests -logErrors --methodList=qtClone,qtToString,qtPop",
     "logTest": "node --trace-uncaught test.js -listTests -logErrors --methodList=qtLog",
-    "test": "node test.js -verbose -logErrors",
+    "test": "node test.js -logErrors",
     "quiet": "node test.js -listTests -logErrors"
   },
   "repository": {

package/test.js

@@ -8,7 +8,6 @@ const verbose=process.argv.filter(item=>item.match(/verbose/i))[0]?true:false
 const logErrors=process.argv.filter(item=>item.match(/logErrors/i))[0]?true:false
 const listTests=process.argv.filter(item=>item.match(/listTests/i))[0]?true:false
 
-
 const methodList=process.argv
 	.qtClone() //create a deep copy so changes can't leak back to the source
 	.filter(item=>item.match(/^--methodList/)) //['--methodList=qtClone,qtToString,qtPop']
@@ -21,7 +20,28 @@ const methodList=process.argv
 
 const result=qt.test({logErrors, verbose, methodList, listTests});
 console.log(result?"PASSED ALL TESTS":"");
-console.log("note: npm test runs all tests. For subset, type, eg, node test.js -listTests -logErrors -verbose --methodList=qtNumberKeysToArray")
 
+const showAdditionalInfo=(verbose, result)=>{
+console.log(`result=${result}`);
+
+if (!verbose && result){
+	return;
+}
+console.log(`
+
+Additional Usage:
+npm logTest; #node --trace-uncaught test.js -listTests -logErrors --methodList=qtLog
+npm test; #node test.js -verbose -logErrors
+npm quiet; #node test.js -listTests -logErrors
+
+# -logErrors shows the message from any failing tests
+
+or find .../qtools-functional-library/test.js and execute, eg,
+    cd .../qtools-functional-library/test.js;
+    node test.js --methodList=qtMapProperties
+    `)
+    
+    }
+showAdditionalInfo(verbose, result)
 
 process.exit(result?0:1);