manyfest 1.0.39 → 1.0.41

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "manyfest",
-    "version": "1.0.39",
+    "version": "1.0.41",
     "description": "JSON Object Manifest for Data Description and Parsing",
     "main": "source/Manyfest.js",
     "scripts": {
@@ -13,8 +13,10 @@
         "build": "npx quack build",
         "build-compatible": "GULP_CUSTOM_BUILD_TARGET=compatible ./node_modules/.bin/gulp build",
         "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t manyfest-image:local",
-        "docker-dev-shell": "docker exec -it manyfest-dev /bin/bash"
+        "docker-dev-shell": "docker exec -it manyfest-dev /bin/bash",
+        "types": "tsc -p ."
     },
+    "types": "types/Manyfest.d.ts",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/stevenvelozo/manyfest.git"
@@ -47,7 +49,8 @@
         "fable-serviceproviderbase": "^3.0.15"
     },
     "devDependencies": {
-        "quackage": "^1.0.41"
+        "quackage": "^1.0.41",
+        "typescript": "^5.8.3"
     },
     "author": "steven velozo <steven@velozo.com>",
     "license": "MIT",

package/source/Manyfest-ObjectAddress-CheckAddressExists.js

@@ -28,9 +28,13 @@ let _MockFable = { DataFormat: require('./Manyfest-ObjectAddress-Parser.js') };
 */
 class ManyfestObjectAddressResolverCheckAddressExists
 {
-	constructor()
+	constructor(pInfoLog, pErrorLog)
 	{
-		this.getObjectValueClass = new libGetObjectValue(libSimpleLog, libSimpleLog);
+		// Wire in logging
+		this.logInfo = (typeof(pInfoLog) == 'function') ? pInfoLog : libSimpleLog;
+		this.logError = (typeof(pErrorLog) == 'function') ? pErrorLog : libSimpleLog;
+
+		this.getObjectValueClass = new libGetObjectValue(this.logInfo, this.logError);
 	}
 
 	// Check if an address exists.
@@ -340,4 +344,4 @@ class ManyfestObjectAddressResolverCheckAddressExists
 	}
 };
 
-module.exports = ManyfestObjectAddressResolverCheckAddressExists;
+module.exports = ManyfestObjectAddressResolverCheckAddressExists;

package/source/Manyfest-ObjectAddress-SetValue.js

@@ -66,6 +66,24 @@ class ManyfestObjectAddressSetValue
 				// The "Name" of the Object contained too the left of the bracket
 				let tmpBoxedPropertyName = pAddress.substring(0, tmpBracketStartIndex).trim();
 
+				// The "Reference" to the property within it, either an array element or object property
+				let tmpBoxedPropertyReference = pAddress.substring(tmpBracketStartIndex+1, tmpBracketStopIndex).trim();
+				// Attempt to parse the reference as a number, which will be used as an array element
+				let tmpBoxedPropertyNumber = parseInt(tmpBoxedPropertyReference, 10);
+				let tmpIndexIsNumeric = !isNaN(tmpBoxedPropertyNumber);
+
+				if (pObject[tmpBoxedPropertyName] == null)
+				{
+					if (tmpIndexIsNumeric)
+					{
+						pObject[tmpBoxedPropertyName] = [];
+					}
+					else
+					{
+						pObject[tmpBoxedPropertyName] = {};
+					}
+				}
+
 				// If the subproperty doesn't test as a proper Object, none of the rest of this is possible.
 				// This is a rare case where Arrays testing as Objects is useful
 				if (typeof(pObject[tmpBoxedPropertyName]) !== 'object')
@@ -73,11 +91,6 @@ class ManyfestObjectAddressSetValue
 					return false;
 				}
 
-				// The "Reference" to the property within it, either an array element or object property
-				let tmpBoxedPropertyReference = pAddress.substring(tmpBracketStartIndex+1, tmpBracketStopIndex).trim();
-				// Attempt to parse the reference as a number, which will be used as an array element
-				let tmpBoxedPropertyNumber = parseInt(tmpBoxedPropertyReference, 10);
-
 				// Guard: If the referrant is a number and the boxed property is not an array, or vice versa, return undefined.
 				//        This seems confusing to me at first read, so explaination:
 				//        Is the Boxed Object an Array?  TRUE
@@ -105,6 +118,7 @@ class ManyfestObjectAddressSetValue
 					}
 
 					// Return the value in the property
+					//TODO: For cases where we have chained [][] properties, this needs to recurse somehow
 					pObject[tmpBoxedPropertyName][tmpBoxedPropertyReference] = pValue;
 					return true;
 				}
@@ -156,6 +170,20 @@ class ManyfestObjectAddressSetValue
 				let tmpBoxedPropertyReference = tmpSubObjectName.substring(tmpBracketStartIndex+1, tmpBracketStopIndex).trim();
 
 				let tmpBoxedPropertyNumber = parseInt(tmpBoxedPropertyReference, 10);
+				let tmpIndexIsNumeric = !isNaN(tmpBoxedPropertyNumber);
+
+				//if (typeof(pObject[tmpBoxedPropertyName]) !== 'object')
+				if (pObject[tmpBoxedPropertyName] == null)
+				{
+					if (tmpIndexIsNumeric)
+					{
+						pObject[tmpBoxedPropertyName] = [];
+					}
+					else
+					{
+						pObject[tmpBoxedPropertyName] = {};
+					}
+				}
 
 				// Guard: If the referrant is a number and the boxed property is not an array, or vice versa, return undefined.
 				//        This seems confusing to me at first read, so explaination:
@@ -171,7 +199,7 @@ class ManyfestObjectAddressSetValue
 				//       BUT
 				//         StudentData.Sections.Algebra.Students is an array, so the ["JaneDoe"].Grade is not possible to access
 				// TODO: Should this be an error or something?  Should we keep a log of failures like this?
-				if (Array.isArray(pObject[tmpBoxedPropertyName]) == isNaN(tmpBoxedPropertyNumber))
+				if (Array.isArray(pObject[tmpBoxedPropertyName]) != tmpIndexIsNumeric)
 				{
 					return false;
 				}

package/source/Manyfest.js

@@ -15,6 +15,18 @@ let libSchemaManipulation = require('./Manyfest-SchemaManipulation.js');
 
 const _DefaultConfiguration = { Scope:'DEFAULT', Descriptors: {} }
 
+/**
+ * @typedef {{
+ *   Hash?: string,
+ *   Name?: string,
+ *   DataType?: string,
+ *   Required?: boolean,
+ *   Address?: string,
+ *   Description?: string,
+ *   [key: string]: any,
+ * }} ManifestDescriptor
+ */
+
 /**
 * Manyfest object address-based descriptions and manipulations.
 *
@@ -33,6 +45,9 @@ class Manyfest extends libFableServiceProviderBase
 			super(pFable, pManifest, pServiceHash);
 		}
 
+		/** @type {Record<string, any>} */
+		this.options;
+
         this.serviceType = 'Manifest';
 
 		// Wire in logging
@@ -204,7 +219,12 @@ class Manyfest extends libFableServiceProviderBase
 			});
 	}
 
-	// Add a descriptor to the manifest
+	/**
+	 * Add a descriptor to the manifest
+	 *
+	 * @param {string} pAddress - The address of the element to add the descriptor for.
+	 * @param {ManifestDescriptor} pDescriptor - The descriptor object to add.
+	 */
 	addDescriptor(pAddress, pDescriptor)
 	{
 		if (typeof(pDescriptor) === 'object')
@@ -246,17 +266,30 @@ class Manyfest extends libFableServiceProviderBase
 		}
 	}
 
+	/**
+	 * @param {string} pHash - The hash of the address to resolve.
+	 *
+	 * @return {ManifestDescriptor} The descriptor for the address
+	 */
 	getDescriptorByHash(pHash)
 	{
 		return this.getDescriptor(this.resolveHashAddress(pHash));
 	}
 
+	/**
+	 * @param {string} pAddress - The address of the element to get the descriptor for.
+	 *
+	 * @return {ManifestDescriptor} The descriptor for the address
+	 */
 	getDescriptor(pAddress)
 	{
 		return this.elementDescriptors[pAddress];
 	}
 
-	// execute an action function for each descriptor
+	/**
+	 * execute an action function for each descriptor
+	 * @param {(d: ManifestDescriptor) => void} fAction - The action function to execute for each descriptor.
+	 */
 	eachDescriptor(fAction)
 	{
         let tmpDescriptorAddresses = Object.keys(this.elementDescriptors);
@@ -489,7 +522,11 @@ class Manyfest extends libFableServiceProviderBase
 		return tmpValidationData;
 	}
 
-	// Returns a default value, or, the default value for the data type (which is overridable with configuration)
+	/**
+	 * Returns a default value, or, the default value for the data type (which is overridable with configuration)
+	 *
+	 * @param {ManifestDescriptor} pDescriptor - The descriptor definition.
+	 */
 	getDefaultValue(pDescriptor)
 	{
 		if (typeof(pDescriptor) != 'object')
@@ -560,4 +597,4 @@ class Manyfest extends libFableServiceProviderBase
 	}
 };
 
-module.exports = Manyfest;
+module.exports = Manyfest;

package/test/Manyfest_Object_Write_tests.js

@@ -165,6 +165,52 @@ suite
 						fTestComplete();
 					}
 				);
+				test
+				(
+					'Indexed subobject are settable',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({});
+						let _SimpleObject = {};
+						_Manyfest.setValueAtAddress(_SimpleObject, `_Object['SubObject'].Property`, '123');
+						Expect(_Manyfest.getValueAtAddress(_SimpleObject, `_Object.SubObject.Property`))
+							.to.equal('123');
+						Expect(_SimpleObject._Object.SubObject.Property)
+							.to.equal('123');
+						fTestComplete();
+					}
+				);
+				test
+				(
+					'Indexed subobject are settable unquoted',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({});
+						let _SimpleObject = {};
+						_Manyfest.setValueAtAddress(_SimpleObject, `_Object[SubObject].Property`, '123');
+						Expect(_Manyfest.getValueAtAddress(_SimpleObject, `_Object.SubObject.Property`))
+							.to.equal('123');
+						Expect(_SimpleObject._Object.SubObject.Property)
+							.to.equal('123');
+						fTestComplete();
+					}
+				);
+				//TODO: known broken case for multiple bracketed properties
+				test.skip
+				(
+					'Indexed subobject are settable double brackets',
+					(fTestComplete)=>
+					{
+						let _Manyfest = new libManyfest({});
+						let _SimpleObject = {};
+						_Manyfest.setValueAtAddress(_SimpleObject, `_Object[SubObject]['Property']`, '123');
+						Expect(_Manyfest.getValueAtAddress(_SimpleObject, `_Object.SubObject.Property`))
+							.to.equal('123');
+						Expect(_SimpleObject._Object.SubObject.Property)
+							.to.equal('123');
+						fTestComplete();
+					}
+				);
 			}
 		);
 	}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+	"include": ["source"],
+	"compilerOptions":
+	{
+		"lib": ["es5", "es6", "dom"],
+		"module": "commonjs",
+		"allowJs": true,
+		"checkJs": true,
+		"declaration": true,
+		"emitDeclarationOnly": true,
+		"outDir": "types",
+		"declarationMap": true,
+		"resolveJsonModule": true
+	}
+}

package/types/Manyfest-Browser-Shim.d.ts

@@ -0,0 +1,3 @@
+export = libManyfest;
+import libManyfest = require("./Manyfest.js");
+//# sourceMappingURL=Manyfest-Browser-Shim.d.ts.map

package/types/Manyfest-Browser-Shim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Manyfest-Browser-Shim.d.ts","sourceRoot":"","sources":["../source/Manyfest-Browser-Shim.js"],"names":[],"mappings":""}

package/types/Manyfest-CleanWrapCharacters.d.ts

@@ -0,0 +1,3 @@
+export = cleanWrapCharacters;
+declare function cleanWrapCharacters(pCharacter: any, pString: any): any;
+//# sourceMappingURL=Manyfest-CleanWrapCharacters.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Manyfest-CleanWrapCharacters.d.ts","sourceRoot":"","sources":["../source/Manyfest-CleanWrapCharacters.js"],"names":[],"mappings":";AAeA,yEAUC"}

package/types/Manyfest-HashTranslation.d.ts

@@ -0,0 +1,29 @@
+export = ManyfestHashTranslation;
+/**
+* Hash Translation
+*
+* This is a very simple translation table for hashes, which allows the same schema to resolve
+* differently based on a loaded translation table.
+*
+* This is to prevent the requirement for mutating schemas over and over again when we want to
+* reuse the structure but look up data elements by different addresses.
+*
+* One side-effect of this is that a translation table can "override" the built-in hashes, since
+* this is always used to resolve hashes before any of the functionCallByHash(pHash, ...) perform
+* their lookups by hash.
+*
+* @class ManyfestHashTranslation
+*/
+declare class ManyfestHashTranslation {
+    constructor(pInfoLog: any, pErrorLog: any);
+    logInfo: any;
+    logError: any;
+    translationTable: {};
+    translationCount(): number;
+    addTranslation(pTranslation: any): boolean;
+    removeTranslationHash(pTranslationHash: any): void;
+    removeTranslation(pTranslation: any): boolean;
+    clearTranslations(): void;
+    translate(pTranslation: any): any;
+}
+//# sourceMappingURL=Manyfest-HashTranslation.d.ts.map

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

@@ -0,0 +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"}

package/types/Manyfest-LogToConsole.d.ts

@@ -0,0 +1,9 @@
+export = logToConsole;
+/**
+* @author <steven@velozo.com>
+*/
+/**
+* Manyfest simple logging shim (for browser and dependency-free running)
+*/
+declare function logToConsole(pLogLine: any, pLogObject: any): void;
+//# sourceMappingURL=Manyfest-LogToConsole.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Manyfest-LogToConsole.d.ts","sourceRoot":"","sources":["../source/Manyfest-LogToConsole.js"],"names":[],"mappings":";AAAA;;EAEE;AAEF;;EAEE;AAEF,oEAOC"}

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

@@ -0,0 +1,28 @@
+export = ManyfestObjectAddressResolverCheckAddressExists;
+/**
+* Object Address Resolver
+*
+* IMPORTANT NOTE: This code is intentionally more verbose than necessary, to
+*                 be extremely clear what is going on in the recursion for
+*                 each of the three address resolution functions.
+*
+*                 Although there is some opportunity to repeat ourselves a
+*                 bit less in this codebase (e.g. with detection of arrays
+*                 versus objects versus direct properties), it can make
+*                 debugging.. challenging.  The minified version of the code
+*                 optimizes out almost anything repeated in here.  So please
+*                 be kind and rewind... meaning please keep the codebase less
+*                 terse and more verbose so humans can comprehend it.
+*
+*
+* @class ManyfestObjectAddressResolverCheckAddressExists
+*/
+declare class ManyfestObjectAddressResolverCheckAddressExists {
+    constructor(pInfoLog: any, pErrorLog: any);
+    logInfo: any;
+    logError: any;
+    getObjectValueClass: libGetObjectValue;
+    checkAddressExists(pObject: any, pAddress: any, pRootObject: any): any;
+}
+import libGetObjectValue = require("./Manyfest-ObjectAddress-GetValue.js");
+//# sourceMappingURL=Manyfest-ObjectAddress-CheckAddressExists.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,30 @@
+export = ManyfestObjectAddressResolverDeleteValue;
+/**
+* Object Address Resolver - DeleteValue
+*
+* IMPORTANT NOTE: This code is intentionally more verbose than necessary, to
+*                 be extremely clear what is going on in the recursion for
+*                 each of the three address resolution functions.
+*
+*                 Although there is some opportunity to repeat ourselves a
+*                 bit less in this codebase (e.g. with detection of arrays
+*                 versus objects versus direct properties), it can make
+*                 debugging.. challenging.  The minified version of the code
+*                 optimizes out almost anything repeated in here.  So please
+*                 be kind and rewind... meaning please keep the codebase less
+*                 terse and more verbose so humans can comprehend it.
+*
+* TODO: Once we validate this pattern is good to go, break these out into
+*       three separate modules.
+*
+* @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;
+}
+//# sourceMappingURL=Manyfest-ObjectAddress-DeleteValue.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,30 @@
+export = ManyfestObjectAddressResolverGetValue;
+/**
+* Object Address Resolver - GetValue
+*
+* IMPORTANT NOTE: This code is intentionally more verbose than necessary, to
+*                 be extremely clear what is going on in the recursion for
+*                 each of the three address resolution functions.
+*
+*                 Although there is some opportunity to repeat ourselves a
+*                 bit less in this codebase (e.g. with detection of arrays
+*                 versus objects versus direct properties), it can make
+*                 debugging.. challenging.  The minified version of the code
+*                 optimizes out almost anything repeated in here.  So please
+*                 be kind and rewind... meaning please keep the codebase less
+*                 terse and more verbose so humans can comprehend it.
+*
+* TODO: Once we validate this pattern is good to go, break these out into
+*       three separate modules.
+*
+* @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;
+}
+//# sourceMappingURL=Manyfest-ObjectAddress-GetValue.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +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;
+//# sourceMappingURL=Manyfest-ObjectAddress-Parser.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,27 @@
+export = ManyfestObjectAddressSetValue;
+/**
+* Object Address Resolver - SetValue
+*
+* IMPORTANT NOTE: This code is intentionally more verbose than necessary, to
+*                 be extremely clear what is going on in the recursion for
+*                 each of the three address resolution functions.
+*
+*                 Although there is some opportunity to repeat ourselves a
+*                 bit less in this codebase (e.g. with detection of arrays
+*                 versus objects versus direct properties), it can make
+*                 debugging.. challenging.  The minified version of the code
+*                 optimizes out almost anything repeated in here.  So please
+*                 be kind and rewind... meaning please keep the codebase less
+*                 terse and more verbose so humans can comprehend it.
+*
+*
+* @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;
+}
+//# sourceMappingURL=Manyfest-ObjectAddress-SetValue.d.ts.map

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

@@ -0,0 +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"}

package/types/Manyfest-ObjectAddressGeneration.d.ts

@@ -0,0 +1,30 @@
+export = ManyfestObjectAddressGeneration;
+/**
+* Object Address Generation
+*
+* Automagically generate addresses and properties based on a passed-in object,
+* to be used for easy creation of schemas.  Meant to simplify the lives of
+* developers wanting to create schemas without typing a bunch of stuff.
+*
+* IMPORTANT NOTE: This code is intentionally more verbose than necessary, to
+*                 be extremely clear what is going on in the recursion for
+*                 each of the three address resolution functions.
+*
+*                 Although there is some opportunity to repeat ourselves a
+*                 bit less in this codebase (e.g. with detection of arrays
+*                 versus objects versus direct properties), it can make
+*                 debugging.. challenging.  The minified version of the code
+*                 optimizes out almost anything repeated in here.  So please
+*                 be kind and rewind... meaning please keep the codebase less
+*                 terse and more verbose so humans can comprehend it.
+*
+*
+* @class ManyfestObjectAddressGeneration
+*/
+declare class ManyfestObjectAddressGeneration {
+    constructor(pInfoLog: any, pErrorLog: any);
+    logInfo: any;
+    logError: any;
+    generateAddressses(pObject: any, pBaseAddress: any, pSchema: any): any;
+}
+//# sourceMappingURL=Manyfest-ObjectAddressGeneration.d.ts.map

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

@@ -0,0 +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"}

package/types/Manyfest-ParseConditionals.d.ts

@@ -0,0 +1,3 @@
+export = parseConditionals;
+declare function parseConditionals(pManyfest: any, pAddress: any, pRecord: any): boolean;
+//# sourceMappingURL=Manyfest-ParseConditionals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Manyfest-ParseConditionals.d.ts","sourceRoot":"","sources":["../source/Manyfest-ParseConditionals.js"],"names":[],"mappings":";AAiGA,yFAkDC"}

package/types/Manyfest-SchemaManipulation.d.ts

@@ -0,0 +1,15 @@
+export = ManyfestSchemaManipulation;
+/**
+* Schema Manipulation Functions
+*
+* @class ManyfestSchemaManipulation
+*/
+declare class ManyfestSchemaManipulation {
+    constructor(pInfoLog: any, pErrorLog: any);
+    logInfo: any;
+    logError: any;
+    resolveAddressMappings(pManyfestSchemaDescriptors: any, pAddressMapping: any): boolean;
+    safeResolveAddressMappings(pManyfestSchemaDescriptors: any, pAddressMapping: any): any;
+    mergeAddressMappings(pManyfestSchemaDescriptorsDestination: any, pManyfestSchemaDescriptorsSource: any): any;
+}
+//# sourceMappingURL=Manyfest-SchemaManipulation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Manyfest-SchemaManipulation.d.ts","sourceRoot":"","sources":["../source/Manyfest-SchemaManipulation.js"],"names":[],"mappings":";AAKA;;;;EAIE;AACF;IAEC,2CAKC;IAFA,aAA0E;IAC1E,cAA6E;IAqB9E,uFA8DC;IAED,uFAMC;IAED,6GAwBC;CACD"}

package/types/Manyfest.d.ts

@@ -0,0 +1,119 @@
+export = Manyfest;
+/**
+ * @typedef {{
+ *   Hash?: string,
+ *   Name?: string,
+ *   DataType?: string,
+ *   Required?: boolean,
+ *   Address?: string,
+ *   Description?: string,
+ *   [key: string]: any,
+ * }} ManifestDescriptor
+ */
+/**
+* Manyfest object address-based descriptions and manipulations.
+*
+* @class Manyfest
+*/
+declare class Manyfest {
+    constructor(pFable: any, pManifest: any, pServiceHash: any);
+    /** @type {Record<string, any>} */
+    options: Record<string, any>;
+    serviceType: string;
+    logInfo: (pLogLine: any, pLogObject: any) => void;
+    logError: (pLogLine: any, pLogObject: any) => void;
+    objectAddressCheckAddressExists: libObjectAddressCheckAddressExists;
+    objectAddressGetValue: libObjectAddressGetValue;
+    objectAddressSetValue: libObjectAddressSetValue;
+    objectAddressDeleteValue: libObjectAddressDeleteValue;
+    scope: any;
+    elementAddresses: any[];
+    elementHashes: {};
+    elementDescriptors: {};
+    schemaManipulations: libSchemaManipulation;
+    objectAddressGeneration: libObjectAddressGeneration;
+    hashTranslations: libHashTranslation;
+    numberRegex: RegExp;
+    /*************************************************************************
+     * Schema Manifest Loading, Reading, Manipulation and Serialization Functions
+     */
+    reset(): void;
+    clone(): import("./Manyfest.js");
+    deserialize(pManifestString: any): void;
+    loadManifest(pManifest: any): void;
+    serialize(): string;
+    getManifest(): {
+        Scope: any;
+        Descriptors: any;
+        HashTranslations: any;
+    };
+    /**
+     * Add a descriptor to the manifest
+     *
+     * @param {string} pAddress - The address of the element to add the descriptor for.
+     * @param {ManifestDescriptor} pDescriptor - The descriptor object to add.
+     */
+    addDescriptor(pAddress: string, pDescriptor: ManifestDescriptor): boolean;
+    /**
+     * @param {string} pHash - The hash of the address to resolve.
+     *
+     * @return {ManifestDescriptor} The descriptor for the address
+     */
+    getDescriptorByHash(pHash: string): ManifestDescriptor;
+    /**
+     * @param {string} pAddress - The address of the element to get the descriptor for.
+     *
+     * @return {ManifestDescriptor} The descriptor for the address
+     */
+    getDescriptor(pAddress: string): ManifestDescriptor;
+    /**
+     * execute an action function for each descriptor
+     * @param {(d: ManifestDescriptor) => void} fAction - The action function to execute for each descriptor.
+     */
+    eachDescriptor(fAction: (d: ManifestDescriptor) => void): void;
+    /*************************************************************************
+     * Beginning of Object Manipulation (read & write) Functions
+     */
+    checkAddressExistsByHash(pObject: any, pHash: any): any;
+    checkAddressExists(pObject: any, pAddress: any): any;
+    resolveHashAddress(pHash: any): any;
+    getValueByHash(pObject: any, pHash: any): any;
+    getValueAtAddress(pObject: any, pAddress: any): any;
+    setValueByHash(pObject: any, pHash: any, pValue: any): any;
+    setValueAtAddress(pObject: any, pAddress: any, pValue: any): any;
+    deleteValueByHash(pObject: any, pHash: any, pValue: any): any;
+    deleteValueAtAddress(pObject: any, pAddress: any, pValue: any): any;
+    validate(pObject: any): {
+        Error: any;
+        Errors: any[];
+        MissingElements: any[];
+    };
+    /**
+     * Returns a default value, or, the default value for the data type (which is overridable with configuration)
+     *
+     * @param {ManifestDescriptor} pDescriptor - The descriptor definition.
+     */
+    getDefaultValue(pDescriptor: ManifestDescriptor): any;
+    populateDefaults(pObject: any, pOverwriteProperties: any): any;
+    populateObject(pObject: any, pOverwriteProperties: any, fFilter: any): any;
+}
+declare namespace Manyfest {
+    export { ManifestDescriptor };
+}
+import libObjectAddressCheckAddressExists = require("./Manyfest-ObjectAddress-CheckAddressExists.js");
+import libObjectAddressGetValue = require("./Manyfest-ObjectAddress-GetValue.js");
+import libObjectAddressSetValue = require("./Manyfest-ObjectAddress-SetValue.js");
+import libObjectAddressDeleteValue = require("./Manyfest-ObjectAddress-DeleteValue.js");
+import libSchemaManipulation = require("./Manyfest-SchemaManipulation.js");
+import libObjectAddressGeneration = require("./Manyfest-ObjectAddressGeneration.js");
+import libHashTranslation = require("./Manyfest-HashTranslation.js");
+type ManifestDescriptor = {
+    Hash?: string;
+    Name?: string;
+    DataType?: string;
+    Required?: boolean;
+    Address?: string;
+    Description?: string;
+    [key: string]: any;
+};
+//# sourceMappingURL=Manyfest.d.ts.map

package/types/Manyfest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Manyfest.d.ts","sourceRoot":"","sources":["../source/Manyfest.js"],"names":[],"mappings":";AAiBA;;;;;;;;;;GAUG;AAEH;;;;EAIE;AACF;IAEC,4DAkEC;IAvDA,kCAAkC;IAClC,SADW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAClB;IAEN,oBAA6B;IAGnC,kDAA2B;IAC3B,mDAA4B;IAG5B,oEAA0G;IAC1G,gDAAsF;IACtF,gDAAsF;IACtF,sDAA4F;IAwB5F,WAAsB;IACtB,wBAAiC;IACjC,kBAA8B;IAC9B,uBAAmC;IASnC,2CAAiF;IACjF,oDAA0F;IAE1F,qCAA2E;IAE3E,oBAA8D;IAG/D;;OAEG;IAGH,cAMC;IAED,iCAWC;IAGD,wCAIC;IAGD,mCAiEC;IAGD,oBAGC;IAED;;;;MAQC;IAED;;;;;OAKG;IACH,wBAHW,MAAM,eACN,kBAAkB,WAyC5B;IAED;;;;OAIG;IACH,2BAJW,MAAM,GAEL,kBAAkB,CAK7B;IAED;;;;OAIG;IACH,wBAJW,MAAM,GAEL,kBAAkB,CAK7B;IAED;;;OAGG;IACH,wBAFW,CAAC,CAAC,EAAE,kBAAkB,KAAK,IAAI,QAUzC;IAED;;OAEG;IAEH,wDAGC;IAGD,qDAGC;IAGD,oCA8BC;IAGD,8CAWC;IAGD,oDAiBC;IAGD,2DAGC;IAGD,iEAGC;IAGD,8DAGC;IAGD,oEAGC;IAGD;;;;MAiHC;IAED;;;;OAIG;IACH,6BAFW,kBAAkB,OA4B5B;IAGD,+DAQC;IAID,2EA0BC;CACD;;;;;;;;;;;0BAnkBY;IACR,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACzB,CAAK,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB"}