manyfest 1.0.41 → 1.0.43

package/source/Manyfest-SchemaManipulation.js

@@ -10,6 +10,10 @@ let libSimpleLog = require('./Manyfest-LogToConsole.js');
 */
 class ManyfestSchemaManipulation
 {
+	/**
+	 * @param {function} [pInfoLog] - (optional) A logging function for info messages
+	 * @param {function} [pErrorLog] - (optional) A logging function for error messages
+	 */
 	constructor(pInfoLog, pErrorLog)
 	{
 		// Wire in logging
@@ -17,24 +21,31 @@ class ManyfestSchemaManipulation
 		this.logError = (typeof(pErrorLog) === 'function') ? pErrorLog : libSimpleLog;
 	}
 
-    // This translates the default address mappings to something different.
-    //
-    // For instance you can pass in manyfest schema descriptor object:
-    // 	{
-	//	  "Address.Of.a": { "Hash": "a", "Type": "Number" },
-	//	  "Address.Of.b": { "Hash": "b", "Type": "Number" }
-	//  }
-    //
-    //
-    // And then an address mapping (basically a Hash->Address map)
-    //  {
-    //    "a": "New.Address.Of.a",
-    //    "b": "New.Address.Of.b"
-    //  }
-    //
-    // NOTE: This mutates the schema object permanently, altering the base hash.
-    //       If there is a collision with an existing address, it can lead to overwrites.
-    // TODO: Discuss what should happen on collisions.
+	/**
+     * This translates the default address mappings to something different.
+     *
+     * For instance you can pass in manyfest schema descriptor object:
+     * 	{
+	 *	  "Address.Of.a": { "Hash": "a", "Type": "Number" },
+	 *	  "Address.Of.b": { "Hash": "b", "Type": "Number" }
+	 *  }
+     *
+     *
+     * And then an address mapping (basically a Hash->Address map)
+     *  {
+     *    "a": "New.Address.Of.a",
+     *    "b": "New.Address.Of.b"
+     *  }
+     *
+     * NOTE: This mutates the schema object permanently, altering the base hash.
+     *       If there is a collision with an existing address, it can lead to overwrites.
+     * TODO: Discuss what should happen on collisions.
+	 *
+	 * @param {object} pManyfestSchemaDescriptors - The manyfest schema descriptors to resolve address mappings for
+	 * @param {object} pAddressMapping - The address mapping object to use for remapping
+	 *
+	 * @return {boolean} True if successful, false if there was an error
+	 */
 	resolveAddressMappings(pManyfestSchemaDescriptors, pAddressMapping)
 	{
 		if (typeof(pManyfestSchemaDescriptors) != 'object')
@@ -67,8 +78,8 @@ class ManyfestSchemaManipulation
 			(pInputAddress) =>
 			{
 				let tmpNewDescriptorAddress = pAddressMapping[pInputAddress];
-				let tmpOldDescriptorAddress = false;
-				let tmpDescriptor = false;
+				let tmpOldDescriptorAddress = null;
+				let tmpDescriptor;
 
 				// See if there is a matching descriptor either by Address directly or Hash
 				if (pInputAddress in pManyfestSchemaDescriptors)
@@ -99,6 +110,12 @@ class ManyfestSchemaManipulation
 		return true;
 	}
 
+	/**
+	 * @param {object} pManyfestSchemaDescriptors - The manyfest schema descriptors to resolve address mappings for
+	 * @param {object} pAddressMapping - The address mapping object to use for remapping
+	 *
+	 * @return {object} A new object containing the remapped schema descriptors
+	 */
 	safeResolveAddressMappings(pManyfestSchemaDescriptors, pAddressMapping)
 	{
 		// This returns the descriptors as a new object, safely remapping without mutating the original schema Descriptors
@@ -107,6 +124,12 @@ class ManyfestSchemaManipulation
 		return tmpManyfestSchemaDescriptors;
 	}
 
+	/**
+	 * @param {object} pManyfestSchemaDescriptorsDestination - The destination manyfest schema descriptors
+	 * @param {object} pManyfestSchemaDescriptorsSource - The source manyfest schema descriptors
+	 *
+	 * @return {object} A new object containing the merged schema descriptors
+	 */
 	mergeAddressMappings(pManyfestSchemaDescriptorsDestination, pManyfestSchemaDescriptorsSource)
 	{
 		if ((typeof(pManyfestSchemaDescriptorsSource) != 'object') || (typeof(pManyfestSchemaDescriptorsDestination) != 'object'))
@@ -134,4 +157,4 @@ class ManyfestSchemaManipulation
 	}
 }
 
-module.exports = ManyfestSchemaManipulation;
+module.exports = ManyfestSchemaManipulation;

package/source/Manyfest.js

@@ -45,8 +45,14 @@ class Manyfest extends libFableServiceProviderBase
 			super(pFable, pManifest, pServiceHash);
 		}
 
+		/** @type {import('fable')} */
+		this.fable;
 		/** @type {Record<string, any>} */
 		this.options;
+		/** @type {string} */
+		this.Hash;
+		/** @type {string} */
+		this.UUID;
 
         this.serviceType = 'Manifest';
 
@@ -82,9 +88,13 @@ class Manyfest extends libFableServiceProviderBase
 			this.options.strict = false;
 		}
 
+		/** @type {string} */
 		this.scope = undefined;
+		/** @type {Array<string>} */
 		this.elementAddresses = undefined;
+		/** @type {Record<string, string>} */
 		this.elementHashes = undefined;
+		/** @type {Record<string, ManifestDescriptor>} */
 		this.elementDescriptors = undefined;
 
 		this.reset();
@@ -120,7 +130,25 @@ class Manyfest extends libFableServiceProviderBase
 		// Make a copy of the options in-place
 		let tmpNewOptions = JSON.parse(JSON.stringify(this.options));
 
-		let tmpNewManyfest = new Manyfest(this.getManifest(), this.logInfo, this.logError, tmpNewOptions);
+		let tmpNewManyfest = new Manyfest(this.fable, tmpNewOptions, this.Hash);
+		tmpNewManyfest.logInfo = this.logInfo;
+		tmpNewManyfest.logError = this.logError;
+		//FIXME: mostly written by co-pilot
+		const { Scope, Descriptors, HashTranslations } = this.getManifest();
+		tmpNewManyfest.scope = Scope;
+		tmpNewManyfest.elementDescriptors = Descriptors;
+		tmpNewManyfest.elementAddresses = Object.keys(Descriptors);
+		// Rebuild the element hashes
+		for (let i = 0; i < tmpNewManyfest.elementAddresses.length; i++)
+		{
+			let tmpAddress = tmpNewManyfest.elementAddresses[i];
+			let tmpDescriptor = tmpNewManyfest.elementDescriptors[tmpAddress];
+			tmpNewManyfest.elementHashes[tmpAddress] = tmpAddress;
+			if ('Hash' in tmpDescriptor)
+			{
+				tmpNewManyfest.elementHashes[tmpDescriptor.Hash] = tmpAddress;
+			}
+		}
 
 		// Import the hash translations
 		tmpNewManyfest.hashTranslations.addTranslation(this.hashTranslations.translationTable);
@@ -129,10 +157,16 @@ class Manyfest extends libFableServiceProviderBase
 	}
 
 	// Deserialize a Manifest from a string
+	/**
+	 * @param {string} pManifestString - The manifest string to deserialize
+	 *
+	 * @return {Manyfest} The deserialized manifest
+	 */
 	deserialize(pManifestString)
 	{
 		// TODO: Add guards for bad manifest string
-		return this.loadManifest(JSON.parse(pManifestString));
+		this.loadManifest(JSON.parse(pManifestString));
+		return this;
 	}
 
 	// Load a manifest from an object
@@ -197,18 +231,26 @@ class Manyfest extends libFableServiceProviderBase
 			{
 				for (let i = 0; i < tmpManifest.HashTranslations.length; i++)
 				{
-					// Each translation is 
+					// Each translation is
+					//FIXME: ?????????
 				}
 			}
 		}
 	}
 
-	// Serialize the Manifest to a string
+	/**
+	 * Serialize the Manifest to a string
+	 *
+	 * @return {string} - The serialized manifest
+	 */
 	serialize()
 	{
 		return JSON.stringify(this.getManifest());
 	}
 
+	/**
+	 * @return {{ Scope: string, Descriptors: Record<string, ManifestDescriptor>, HashTranslations: Record<string, string> }} - A copy of the manifest state.
+	 */
 	getManifest()
 	{
 		return (
@@ -362,21 +404,37 @@ class Manyfest extends libFableServiceProviderBase
 		return tmpValue;
 	}
 
+	lintAddress(pAddress)
+	{
+		let tmpLintedAddress = pAddress.trim();
+		// Check for a single . (but not a ..) at the end of the address and remove it.
+		if (tmpLintedAddress.endsWith('..'))
+		{
+			tmpLintedAddress = tmpLintedAddress.slice(0, -1);
+		}
+		else if (tmpLintedAddress.endsWith('.'))
+		{
+			tmpLintedAddress = tmpLintedAddress.slice(0, -1);
+		}
+
+		return tmpLintedAddress;
+	}
+
 	// Get the value of an element at an address
 	getValueAtAddress (pObject, pAddress)
 	{
-		let tmpLintedAddress = pAddress.trim();
+		let tmpLintedAddress = this.lintAddress(pAddress);
 		if (tmpLintedAddress == '')
 		{
 			this.logError(`(${this.scope}) Error getting value at address; address is an empty string.`, pObject);
 			return undefined;
 		}
-		let tmpValue = this.objectAddressGetValue.getValueAtAddress(pObject, pAddress);
+		let tmpValue = this.objectAddressGetValue.getValueAtAddress(pObject, tmpLintedAddress);
 
 		if (typeof(tmpValue) == 'undefined')
 		{
 			// Try to get a default if it exists
-			tmpValue = this.getDefaultValue(this.getDescriptor(pAddress));
+			tmpValue = this.getDefaultValue(this.getDescriptor(tmpLintedAddress));
 		}
 
 		return tmpValue;
@@ -391,7 +449,8 @@ class Manyfest extends libFableServiceProviderBase
 	// Set the value of an element at an address
 	setValueAtAddress (pObject, pAddress, pValue)
 	{
-		return this.objectAddressSetValue.setValueAtAddress(pObject, pAddress, pValue);
+		let tmpLintedAddress = this.lintAddress(pAddress);
+		return this.objectAddressSetValue.setValueAtAddress(pObject, tmpLintedAddress, pValue);
 	}
 
 	// Delete the value of an element by its hash
@@ -403,7 +462,8 @@ class Manyfest extends libFableServiceProviderBase
 	// Delete the value of an element at an address
 	deleteValueAtAddress (pObject, pAddress, pValue)
 	{
-		return this.objectAddressDeleteValue.deleteValueAtAddress(pObject, pAddress, pValue);
+		let tmpLintedAddress = this.lintAddress(pAddress);
+		return this.objectAddressDeleteValue.deleteValueAtAddress(pObject, tmpLintedAddress, pValue);
 	}
 
 	// Validate the consistency of an object against the schema

package/test/Manyfest_Object_Read_tests.js

@@ -160,6 +160,19 @@ suite
 					}
 				);
 				test
+				(
+					'Access relative objects with invalid dots',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest();
+						Expect(_Manyfest.getValueAtAddress(_SampleDataYahooWeather, 'location.city')).to.equal('Sunnyvale');
+						Expect(_Manyfest.getValueAtAddress(_SampleDataYahooWeather, 'location.city.')).to.equal('Sunnyvale');
+						Expect(_Manyfest.getValueAtAddress(_SampleDataYahooWeather, 'current_observation.wind.').chill).to.equal(59);
+						Expect(_Manyfest.getValueAtAddress(_SampleDataYahooWeather, 'current_observation.BadObjectPropertyName.')).to.equal(undefined);
+						fTestComplete();
+					}
+				);
+				test
 				(
 					'Access specific array elements',
 					(fTestComplete)=>

package/test/Manyfest_Performance_tests.js

@@ -0,0 +1,48 @@
+/**
+* Unit tests for Manyfest
+*
+* @license     MIT
+*
+* @author      Steven Velozo <steven@velozo.com>
+*/
+
+var Chai = require('chai');
+var Expect = Chai.expect;
+
+let libManyfest = require('../source/Manyfest.js');
+
+suite
+(
+	'Manyfest Performance',
+	function()
+	{
+		suite
+		(
+			'Brute Force Performance Tests',
+			()=>
+			{
+				test
+				(
+					'Deep Address Performance Test',
+					()=>
+					{
+						let _Manyfest = new libManyfest();
+						const tmpData = {};
+						const tmpValueAddress = 'level1.level2.level3.level4.level5';
+						const tmpNumIterations = 200000;
+						// start timing
+						console.time('Brute Force Initial Load Performance Test');
+						for (let i = 0; i < tmpNumIterations; i++)
+						{
+							const tmpUpdatedValue = (_Manyfest.getValueAtAddress(tmpData, tmpValueAddress) || 0) + 1;
+							_Manyfest.setValueAtAddress(tmpData, tmpValueAddress, tmpUpdatedValue);
+						}
+						// stop timing
+						console.timeEnd('Brute Force Initial Load Performance Test', { tmpData });
+						Expect(_Manyfest.getValueAtAddress(tmpData, tmpValueAddress)).to.equal(tmpNumIterations);
+					}
+				);
+			}
+		);
+	}
+);

package/types/Manyfest-CleanWrapCharacters.d.ts

@@ -1,3 +1,9 @@
 export = cleanWrapCharacters;
-declare function cleanWrapCharacters(pCharacter: any, pString: any): any;
+/**
+ * @param {string} pCharacter - The character to remove from the start and end of the string
+ * @param {string} pString - The string to clean
+ *
+ * @return {string} The cleaned string
+ */
+declare function cleanWrapCharacters(pCharacter: string, pString: string): string;
 //# sourceMappingURL=Manyfest-CleanWrapCharacters.d.ts.map

package/types/Manyfest-CleanWrapCharacters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manyfest-CleanWrapCharacters.d.ts","sourceRoot":"","sources":["../source/Manyfest-CleanWrapCharacters.js"],"names":[],"mappings":";AAeA,yEAUC"}
+{"version":3,"file":"Manyfest-CleanWrapCharacters.d.ts","sourceRoot":"","sources":["../source/Manyfest-CleanWrapCharacters.js"],"names":[],"mappings":";AAeA;;;;;GAKG;AACH,iDALW,MAAM,WACN,MAAM,GAEL,MAAM,CAYjB"}

package/types/Manyfest-HashTranslation.d.ts

@@ -15,15 +15,42 @@ export = ManyfestHashTranslation;
 * @class ManyfestHashTranslation
 */
 declare class ManyfestHashTranslation {
-    constructor(pInfoLog: any, pErrorLog: any);
-    logInfo: any;
-    logError: any;
+    /**
+     * @param {function} [pInfoLog] - (optional) A logging function for info messages
+     * @param {function} [pErrorLog] - (optional) A logging function for error messages
+     */
+    constructor(pInfoLog?: Function, pErrorLog?: Function);
+    logInfo: Function;
+    logError: Function;
     translationTable: {};
+    /**
+     * @return {number} The number of translations in the table
+     */
     translationCount(): number;
-    addTranslation(pTranslation: any): boolean;
-    removeTranslationHash(pTranslationHash: any): void;
-    removeTranslation(pTranslation: any): boolean;
+    /**
+     * @param {object} pTranslation - An object containing source:destination hash pairs to add to the translation table
+     */
+    addTranslation(pTranslation: object): boolean;
+    /**
+     * @param {string} pTranslationHash - The source hash to remove from the translation table
+     */
+    removeTranslationHash(pTranslationHash: string): void;
+    /**
+     * This removes translations.
+     * If passed a string, just removes the single one.
+     * If passed an object, it does all the source keys.
+     *
+     * @param {string|object} pTranslation - Either a source hash string to remove, or an object containing source:destination hash pairs to remove
+     *
+     * @return {boolean} True if the removal was successful, false otherwise
+     */
+    removeTranslation(pTranslation: string | object): boolean;
     clearTranslations(): void;
-    translate(pTranslation: any): any;
+    /**
+     * @param {string} pTranslation - The source hash to translate
+     *
+     * @return {string} The translated hash, or the original if no translation exists
+     */
+    translate(pTranslation: string): string;
 }
 //# sourceMappingURL=Manyfest-HashTranslation.d.ts.map

package/types/Manyfest-HashTranslation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manyfest-HashTranslation.d.ts","sourceRoot":"","sources":["../source/Manyfest-HashTranslation.js"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;EAcE;AACF;IAEC,2CAOC;IAJA,aAA0E;IAC1E,cAA6E;IAEvE,qBAA0B;IAG9B,2BAGC;IAED,2CAwBC;IAED,mDAMC;IAKD,8CAuBC;IAED,0BAGC;IAED,kCAUC;CACJ"}
+{"version":3,"file":"Manyfest-HashTranslation.d.ts","sourceRoot":"","sources":["../source/Manyfest-HashTranslation.js"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;EAcE;AACF;IAEI;;;OAGG;IACN,uDAOC;IAJA,kBAA0E;IAC1E,mBAA6E;IAEvE,qBAA0B;IAG9B;;OAEG;IACH,oBAFY,MAAM,CAKjB;IAED;;OAEG;IACH,6BAFW,MAAM,WA0BhB;IAED;;OAEG;IACH,wCAFW,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,gCAJW,MAAM,GAAC,MAAM,GAEZ,OAAO,CAyBlB;IAED,0BAGC;IAED;;;;OAIG;IACH,wBAJW,MAAM,GAEL,MAAM,CAYjB;CACJ"}

package/types/Manyfest-ObjectAddress-CheckAddressExists.d.ts

@@ -18,11 +18,30 @@ export = ManyfestObjectAddressResolverCheckAddressExists;
 * @class ManyfestObjectAddressResolverCheckAddressExists
 */
 declare class ManyfestObjectAddressResolverCheckAddressExists {
-    constructor(pInfoLog: any, pErrorLog: any);
-    logInfo: any;
-    logError: any;
+    /**
+     * @param {function} [pInfoLog] - (optional) Function to use for info logging
+     * @param {function} [pErrorLog] - (optional) Function to use for error logging
+     */
+    constructor(pInfoLog?: Function, pErrorLog?: Function);
+    logInfo: Function;
+    logError: Function;
     getObjectValueClass: libGetObjectValue;
-    checkAddressExists(pObject: any, pAddress: any, pRootObject: any): any;
+    cleanWrapCharacters: (pCharacter: string, pString: string) => string;
+    /**
+     * Check if an address exists.
+     *
+     * This is necessary because the getValueAtAddress function is ambiguous on
+     * whether the element/property is actually there or not (it returns
+     * undefined whether the property exists or not).  This function checks for
+     * existance and returns true or false dependent.
+     *
+     * @param {object} pObject - The object to check within
+     * @param {string} pAddress - The address to check for
+     * @param {object} [pRootObject] - (optional) The root object for function resolution context
+     *
+     * @return {boolean} - True if the address exists, false if it does not
+     */
+    checkAddressExists(pObject: object, pAddress: string, pRootObject?: object): boolean;
 }
 import libGetObjectValue = require("./Manyfest-ObjectAddress-GetValue.js");
 //# sourceMappingURL=Manyfest-ObjectAddress-CheckAddressExists.d.ts.map

package/types/Manyfest-ObjectAddress-CheckAddressExists.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manyfest-ObjectAddress-CheckAddressExists.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddress-CheckAddressExists.js"],"names":[],"mappings":";AAUA;;;;;;;;;;;;;;;;;EAiBE;AACF;IAEC,2CAOC;IAJA,aAAyE;IACzE,cAA4E;IAE5E,uCAA6E;IAS9E,uEA0SC;CACD"}
+{"version":3,"file":"Manyfest-ObjectAddress-CheckAddressExists.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddress-CheckAddressExists.js"],"names":[],"mappings":";AAYA;;;;;;;;;;;;;;;;;EAiBE;AACF;IAEC;;;OAGG;IACH,uDAQC;IALA,kBAAyE;IACzE,mBAA4E;IAE5E,uCAA6E;IAC7E,qEAA+C;IAGhD;;;;;;;;;;;;;OAaG;IACH,4BANW,MAAM,YACN,MAAM,gBACN,MAAM,GAEL,OAAO,CA4SlB;CACD"}

package/types/Manyfest-ObjectAddress-DeleteValue.d.ts

@@ -20,11 +20,30 @@ export = ManyfestObjectAddressResolverDeleteValue;
 * @class ManyfestObjectAddressResolverDeleteValue
 */
 declare class ManyfestObjectAddressResolverDeleteValue {
-    constructor(pInfoLog: any, pErrorLog: any);
-    logInfo: any;
-    logError: any;
-    cleanWrapCharacters: (pCharacter: any, pString: any) => any;
-    checkRecordFilters(pAddress: any, pRecord: any): boolean;
-    deleteValueAtAddress(pObject: any, pAddress: any, pParentAddress: any): any;
+    /**
+     * @param {function} [pInfoLog] - (optional) A logging function for info messages
+     * @param {function} [pErrorLog] - (optional) A logging function for error messages
+     */
+    constructor(pInfoLog?: Function, pErrorLog?: Function);
+    logInfo: Function;
+    logError: Function;
+    cleanWrapCharacters: (pCharacter: string, pString: string) => string;
+    /**
+     * @param {string} pAddress - The address being evaluated
+     * @param {object} pRecord - The record being evaluated
+     *
+     * @return {boolean} True if the record passes the filters, false if it does not
+     */
+    checkRecordFilters(pAddress: string, pRecord: object): boolean;
+    /**
+     * Delete the value of an element at an address
+     *
+     * @param {object} pObject - The object to delete the value from
+     * @param {string} pAddress - The address to delete the value at
+     * @param {string} [pParentAddress] - (optional) The parent address for recursion
+     *
+     * @return {boolean|object|undefined} - True if the value was deleted, false if it could not be deleted, undefined on error
+     */
+    deleteValueAtAddress(pObject: object, pAddress: string, pParentAddress?: string): boolean | object | undefined;
 }
 //# sourceMappingURL=Manyfest-ObjectAddress-DeleteValue.d.ts.map

package/types/Manyfest-ObjectAddress-DeleteValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manyfest-ObjectAddress-DeleteValue.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddress-DeleteValue.js"],"names":[],"mappings":";AAOA;;;;;;;;;;;;;;;;;;;EAmBE;AACF;IAEC,2CAOC;IAJA,aAAyE;IACzE,cAA4E;IAE5E,4DAA+C;IAIhD,yDAGC;IAGD,4EAkTC;CACD"}
+{"version":3,"file":"Manyfest-ObjectAddress-DeleteValue.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddress-DeleteValue.js"],"names":[],"mappings":";AAOA;;;;;;;;;;;;;;;;;;;EAmBE;AACF;IAEC;;;OAGG;IACH,uDAOC;IAJA,kBAAyE;IACzE,mBAA4E;IAE5E,qEAA+C;IAIhD;;;;;OAKG;IACH,6BALW,MAAM,WACN,MAAM,GAEL,OAAO,CAKlB;IAED;;;;;;;;OAQG;IACH,8BANW,MAAM,YACN,MAAM,mBACN,MAAM,GAEL,OAAO,GAAC,MAAM,GAAC,SAAS,CAoTnC;CACD"}

package/types/Manyfest-ObjectAddress-GetValue.d.ts

@@ -20,11 +20,31 @@ export = ManyfestObjectAddressResolverGetValue;
 * @class ManyfestObjectAddressResolverGetValue
 */
 declare class ManyfestObjectAddressResolverGetValue {
-    constructor(pInfoLog: any, pErrorLog: any);
-    logInfo: any;
-    logError: any;
-    cleanWrapCharacters: (pCharacter: any, pString: any) => any;
-    checkRecordFilters(pAddress: any, pRecord: any): boolean;
-    getValueAtAddress(pObject: any, pAddress: any, pParentAddress: any, pRootObject: any): any;
+    /**
+     * @param {function} [pInfoLog] - (optional) A logging function for info messages
+     * @param {function} [pErrorLog] - (optional) A logging function for error messages
+     */
+    constructor(pInfoLog?: Function, pErrorLog?: Function);
+    logInfo: Function;
+    logError: Function;
+    cleanWrapCharacters: (pCharacter: string, pString: string) => string;
+    /**
+     * @param {string} pAddress - The address of the record to check
+     * @param {object} pRecord - The record to check against the filters
+     *
+     * @return {boolean} - True if the record passes the filters, false otherwise
+     */
+    checkRecordFilters(pAddress: string, pRecord: object): boolean;
+    /**
+     * Get the value of an element at an address
+     *
+     * @param {object} pObject - The object to resolve the address against
+     * @param {string} pAddress - The address to resolve
+     * @param {string} [pParentAddress] - (optional) The parent address for back-navigation
+     * @param {object} [pRootObject] - (optional) The root object for function argument resolution
+     *
+     * @return {any} The value at the address, or undefined if not found
+     */
+    getValueAtAddress(pObject: object, pAddress: string, pParentAddress?: string, pRootObject?: object): any;
 }
 //# sourceMappingURL=Manyfest-ObjectAddress-GetValue.d.ts.map

package/types/Manyfest-ObjectAddress-GetValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manyfest-ObjectAddress-GetValue.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddress-GetValue.js"],"names":[],"mappings":";AASA;;;;;;;;;;;;;;;;;;;EAmBE;AACF;IAEC,2CAOC;IAJA,aAAyE;IACzE,cAA4E;IAE5E,4DAA+C;IAGhD,yDAGC;IAGD,2FAwkBC;CACD"}
+{"version":3,"file":"Manyfest-ObjectAddress-GetValue.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddress-GetValue.js"],"names":[],"mappings":";AASA;;;;;;;;;;;;;;;;;;;EAmBE;AACF;IAEC;;;OAGG;IACH,uDAOC;IAJA,kBAAyE;IACzE,mBAA4E;IAE5E,qEAA+C;IAGhD;;;;;OAKG;IACH,6BALW,MAAM,WACN,MAAM,GAEL,OAAO,CAKlB;IAED;;;;;;;;;OASG;IACH,2BAPW,MAAM,YACN,MAAM,mBACN,MAAM,gBACN,MAAM,GAEL,GAAG,CA0kBd;CACD"}

package/types/Manyfest-ObjectAddress-Parser.d.ts

@@ -1,6 +1,6 @@
-export function stringCountSegments(pString: string, pSeparator: string, pEnclosureStartSymbolMap: object, pEnclosureEndSymbolMap: object): number;
-export function stringGetFirstSegment(pString: string, pSeparator: string, pEnclosureStartSymbolMap: object, pEnclosureEndSymbolMap: object): string | 0;
-export function stringGetSegments(pString: string, pSeparator: string, pEnclosureStartSymbolMap: object, pEnclosureEndSymbolMap: object): any[];
-export function stringCountEnclosures(pString: string, pEnclosureStart: string, pEnclosureEnd: string): number;
-export function stringGetEnclosureValueByIndex(pString: string, pEnclosureIndexToGet: number, pEnclosureStart: string, pEnclosureEnd: any): string;
+export function stringCountSegments(pString: string, pSeparator?: string, pEnclosureStartSymbolMap?: Record<string, number>, pEnclosureEndSymbolMap?: Record<string, number>): number;
+export function stringGetFirstSegment(pString: string, pSeparator?: string, pEnclosureStartSymbolMap?: Record<string, number>, pEnclosureEndSymbolMap?: Record<string, number>): string;
+export function stringGetSegments(pString: string, pSeparator?: string, pEnclosureStartSymbolMap?: Record<string, number>, pEnclosureEndSymbolMap?: Record<string, number>): Array<string>;
+export function stringCountEnclosures(pString: string, pEnclosureStart?: string, pEnclosureEnd?: string): number;
+export function stringGetEnclosureValueByIndex(pString: string, pEnclosureIndexToGet: number, pEnclosureStart?: string, pEnclosureEnd?: string): string;
 //# sourceMappingURL=Manyfest-ObjectAddress-Parser.d.ts.map

package/types/Manyfest-ObjectAddress-Parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manyfest-ObjectAddress-Parser.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddress-Parser.js"],"names":[],"mappings":"AAoBsB,6CANV,MAAM,cACN,MAAM,4BACN,MAAM,0BACN,MAAM,UA+ChB;AAWsB,+CANZ,MAAM,cACN,MAAM,4BACN,MAAM,0BACN,MAAM,cA8ChB;AAWkB,2CANR,MAAM,cACN,MAAM,4BACN,MAAM,0BACN,MAAM,SAuDhB;AAYsB,+CALZ,MAAM,mBACN,MAAM,iBACN,MAAM,UA6BhB;AAc+B,wDANrB,MAAM,wBACN,MAAM,mBACN,MAAM,uBAEJ,MAAM,CAiElB"}
+{"version":3,"file":"Manyfest-ObjectAddress-Parser.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddress-Parser.js"],"names":[],"mappings":"AAwBsB,6CAPV,MAAM,eACN,MAAM,6BACN,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,2BACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAErB,MAAM,CA8CjB;AAYsB,+CAPZ,MAAM,eACN,MAAM,6BACN,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,2BACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAErB,MAAM,CA6CjB;AAYkB,2CAPR,MAAM,eACN,MAAM,6BACN,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,2BACtB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAErB,KAAK,CAAC,MAAM,CAAC,CAsDxB;AAYsB,+CALZ,MAAM,oBACN,MAAM,kBACN,MAAM,UA6BhB;AAe+B,wDAPrB,MAAM,wBACN,MAAM,oBACN,MAAM,kBACN,MAAM,GAEL,MAAM,CAiEjB"}

package/types/Manyfest-ObjectAddress-SetValue.d.ts

@@ -18,10 +18,23 @@ export = ManyfestObjectAddressSetValue;
 * @class ManyfestObjectAddressSetValue
 */
 declare class ManyfestObjectAddressSetValue {
-    constructor(pInfoLog: any, pErrorLog: any);
-    logInfo: any;
-    logError: any;
-    cleanWrapCharacters: (pCharacter: any, pString: any) => any;
-    setValueAtAddress(pObject: any, pAddress: any, pValue: any): any;
+    /**
+     * @param {function} [pInfoLog] - (optional) A logging function for info messages
+     * @param {function} [pErrorLog] - (optional) A logging function for error messages
+     */
+    constructor(pInfoLog?: Function, pErrorLog?: Function);
+    logInfo: Function;
+    logError: Function;
+    cleanWrapCharacters: (pCharacter: string, pString: string) => string;
+    /**
+     * Set the value of an element at an address
+     *
+     * @param {object} pObject - The object to set the value in
+     * @param {string} pAddress - The address to set the value at
+     * @param {any} pValue - The value to set at the address
+     *
+     * @return {boolean} True if the value was set, false otherwise
+     */
+    setValueAtAddress(pObject: object, pAddress: string, pValue: any): boolean;
 }
 //# sourceMappingURL=Manyfest-ObjectAddress-SetValue.d.ts.map

package/types/Manyfest-ObjectAddress-SetValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manyfest-ObjectAddress-SetValue.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddress-SetValue.js"],"names":[],"mappings":";AAMA;;;;;;;;;;;;;;;;;EAiBE;AACF;IAEC,2CAOC;IAJA,aAAyE;IACzE,cAA4E;IAE5E,4DAA+C;IAIhD,iEAgOC;CACD"}
+{"version":3,"file":"Manyfest-ObjectAddress-SetValue.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddress-SetValue.js"],"names":[],"mappings":";AAMA;;;;;;;;;;;;;;;;;EAiBE;AACF;IAEC;;;OAGG;IACH,uDAOC;IAJA,kBAAyE;IACzE,mBAA4E;IAE5E,qEAA+C;IAGhD;;;;;;;;OAQG;IACH,2BANW,MAAM,YACN,MAAM,UACN,GAAG,GAEF,OAAO,CAkOlB;CACD"}

package/types/Manyfest-ObjectAddressGeneration.d.ts

@@ -22,9 +22,30 @@ export = ManyfestObjectAddressGeneration;
 * @class ManyfestObjectAddressGeneration
 */
 declare class ManyfestObjectAddressGeneration {
-    constructor(pInfoLog: any, pErrorLog: any);
-    logInfo: any;
-    logError: any;
-    generateAddressses(pObject: any, pBaseAddress: any, pSchema: any): any;
+    /**
+     * @param {function} [pInfoLog] - (optional) A logging function for info messages
+     * @param {function} [pErrorLog] - (optional) A logging function for error messages
+     */
+    constructor(pInfoLog?: Function, pErrorLog?: Function);
+    logInfo: Function;
+    logError: Function;
+    /**
+     * generateAddressses
+     *
+     * This flattens an object into a set of key:value pairs for *EVERY SINGLE
+     * POSSIBLE ADDRESS* in the object.  It can get ... really insane really
+     * quickly.  This is not meant to be used directly to generate schemas, but
+     * instead as a starting point for scripts or UIs.
+     *
+     * This will return a mega set of key:value pairs with all possible schema
+     * permutations and default values (when not an object) and everything else.
+     *
+     * @param {any} pObject - The object to generate addresses for
+     * @param {string} [pBaseAddress] - (optional) The base address to start from
+     * @param {object} [pSchema] - (optional) The schema object to append to
+     *
+     * @return {object} The generated schema object
+     */
+    generateAddressses(pObject: any, pBaseAddress?: string, pSchema?: object): object;
 }
 //# sourceMappingURL=Manyfest-ObjectAddressGeneration.d.ts.map

package/types/Manyfest-ObjectAddressGeneration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Manyfest-ObjectAddressGeneration.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddressGeneration.js"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;;;;;;;;EAqBE;AACF;IAEC,2CAKC;IAFA,aAAyE;IACzE,cAA4E;IAY7E,uEA+EC;CACD"}
+{"version":3,"file":"Manyfest-ObjectAddressGeneration.d.ts","sourceRoot":"","sources":["../source/Manyfest-ObjectAddressGeneration.js"],"names":[],"mappings":";AAKA;;;;;;;;;;;;;;;;;;;;;EAqBE;AACF;IAEC;;;OAGG;IACH,uDAKC;IAFA,kBAAyE;IACzE,mBAA4E;IAG7E;;;;;;;;;;;;;;;;OAgBG;IACH,4BANW,GAAG,iBACH,MAAM,YACN,MAAM,GAEL,MAAM,CAgFjB;CACD"}