manyfest 1.0.42 → 1.0.44

package/source/Manyfest-ParseConditionals.js

@@ -27,20 +27,16 @@ const testCondition = (pManyfest, pRecord, pSearchAddress, pSearchComparator, pV
 	{
 		case 'TRUE':
 			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) === true);
-			break;
 		case 'FALSE':
 			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) === false);
-			break;
 		case 'LNGT':
 		case 'LENGTH_GREATER_THAN':
 			switch(typeof(pManyfest.getValueAtAddress(pRecord, pSearchAddress)))
 			{
 				case 'string':
 					return (pManyfest.getValueAtAddress(pRecord, pSearchAddress).length > pValue);
-					break;
 				case 'object':
 					return (pManyfest.getValueAtAddress(pRecord, pSearchAddress).length > pValue);
-					break;
 				default:
 					return false;
 					break;
@@ -52,10 +48,8 @@ const testCondition = (pManyfest, pRecord, pSearchAddress, pSearchComparator, pV
 			{
 				case 'string':
 					return (pManyfest.getValueAtAddress(pRecord, pSearchAddress).length < pValue);
-					break;
 				case 'object':
 					return (pManyfest.getValueAtAddress(pRecord, pSearchAddress).length < pValue);
-					break;
 				default:
 					return false;
 					break;
@@ -72,26 +66,19 @@ const testCondition = (pManyfest, pRecord, pSearchAddress, pSearchComparator, pV
 		// 	break;
 		case '!=':
 			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) != pValue);
-			break;
 		case '<':
 			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) < pValue);
-			break;
 		case '>':
 			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) > pValue);
-			break;
 		case '<=':
 			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) <= pValue);
-			break;
 		case '>=':
 			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) >= pValue);
-			break;
 		case '===':
 			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) === pValue);
-			break;
 		case '==':
 		default:
 			return (pManyfest.getValueAtAddress(pRecord, pSearchAddress) == pValue);
-			break;
 	}
 };
 
@@ -123,7 +110,7 @@ const parseConditionals = (pManyfest, pAddress, pRecord) =>
 			let tmpSearchComparator = 'EXISTS';
 			if (tmpMagicComparisonPatternSet.length > 1)
 			{
-				tmpSearchComparator = tmpMagicComparisonPatternSet[1];				
+				tmpSearchComparator = tmpMagicComparisonPatternSet[1];
 			}
 
 			// The value to search for
@@ -141,10 +128,10 @@ const parseConditionals = (pManyfest, pAddress, pRecord) =>
 		{
 			tmpStartIndex = -1;
 		}
-		
+
 	}
 
 	return tmpKeepRecord;
 }
 
-module.exports = parseConditionals;
+module.exports = parseConditionals;

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
@@ -195,20 +229,25 @@ class Manyfest extends libFableServiceProviderBase
 		{
 			if (typeof(tmpManifest.HashTranslations) === 'object')
 			{
-				for (let i = 0; i < tmpManifest.HashTranslations.length; i++)
-				{
-					// Each translation is 
-				}
+				// HashTranslations is serialized as a plain object of source:target pairs
+				this.hashTranslations.addTranslation(tmpManifest.HashTranslations);
 			}
 		}
 	}
 
-	// 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 (
@@ -364,13 +403,15 @@ class Manyfest extends libFableServiceProviderBase
 
 	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('..'))
+		// Guard against non-string input
+		if (typeof(pAddress) != 'string')
 		{
-			tmpLintedAddress = tmpLintedAddress.slice(0, -1);
+			return '';
 		}
-		else if (tmpLintedAddress.endsWith('.'))
+		let tmpLintedAddress = pAddress.trim();
+		// Check for a single trailing . (but not a ..) at the end of the address and remove it.
+		// We must not strip '..' because that is back-navigation syntax.
+		if (tmpLintedAddress.endsWith('.') && !tmpLintedAddress.endsWith('..'))
 		{
 			tmpLintedAddress = tmpLintedAddress.slice(0, -1);
 		}
@@ -412,16 +453,16 @@ class Manyfest extends libFableServiceProviderBase
 	}
 
 	// Delete the value of an element by its hash
-	deleteValueByHash(pObject, pHash, pValue)
+	deleteValueByHash(pObject, pHash)
 	{
-		return this.deleteValueAtAddress(pObject, this.resolveHashAddress(pHash), pValue);
+		return this.deleteValueAtAddress(pObject, this.resolveHashAddress(pHash));
 	}
 
 	// Delete the value of an element at an address
-	deleteValueAtAddress (pObject, pAddress, pValue)
+	deleteValueAtAddress (pObject, pAddress)
 	{
 		let tmpLintedAddress = this.lintAddress(pAddress);
-		return this.objectAddressDeleteValue.deleteValueAtAddress(pObject, tmpLintedAddress, pValue);
+		return this.objectAddressDeleteValue.deleteValueAtAddress(pObject, tmpLintedAddress);
 	}
 
 	// Validate the consistency of an object against the schema
@@ -518,12 +559,20 @@ class Manyfest extends libFableServiceProviderBase
 						}
 						break;
 
+					case 'boolean':
+						if (tmpElementType != 'boolean')
+						{
+							addValidationError(tmpDescriptor.Address, `has a DataType ${tmpDescriptor.DataType} but is of the type ${tmpElementType}`);
+						}
+						break;
+
 					case 'datetime':
 						let tmpValueDate = new Date(tmpValue);
 						if (tmpValueDate.toString() == 'Invalid Date')
 						{
 							addValidationError(tmpDescriptor.Address, `has a DataType ${tmpDescriptor.DataType} but is not parsable as a Date by Javascript`);
 						}
+						break;
 
 					default:
 						// Check if this is a string, in the default case
@@ -563,7 +612,13 @@ class Manyfest extends libFableServiceProviderBase
 			let tmpDataType = ('DataType' in pDescriptor) ? pDescriptor.DataType : 'String';
 			if (tmpDataType in this.options.defaultValues)
 			{
-				return this.options.defaultValues[tmpDataType];
+				let tmpDefaultValue = this.options.defaultValues[tmpDataType];
+				// Return a copy of mutable defaults (Array and Object) to prevent shared state
+				if (typeof(tmpDefaultValue) == 'object' && tmpDefaultValue !== null)
+				{
+					return JSON.parse(JSON.stringify(tmpDefaultValue));
+				}
+				return tmpDefaultValue;
 			}
 			else
 			{

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"}