fable 3.1.8 → 3.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.1.8",
+  "version": "3.1.9",
   "description": "A service dependency injection, configuration and logging library.",
   "main": "source/Fable.js",
   "scripts": {

package/source/Fable.js

@@ -75,6 +75,7 @@ class Fable extends libFableServiceBase.CoreServiceProviderBase
 		this.addAndInstantiateServiceType('DataFormat', require('./services/Fable-Service-DataFormat.js'));
 		this.addAndInstantiateServiceType('DataGeneration', require('./services/Fable-Service-DataGeneration.js'));
 		this.addAndInstantiateServiceType('Utility', require('./services/Fable-Service-Utility.js'));
+		this.addAndInstantiateServiceType('Logic', require('./services/Fable-Service-Logic.js'));
 		this.addAndInstantiateServiceType('Math', require('./services/Fable-Service-Math.js'));
 		this.addServiceType('ExpressionParser', require('./services/Fable-Service-ExpressionParser.js'));
 		this.addServiceType('RestClient', require('./services/Fable-Service-RestClient.js'));

package/source/services/Fable-Service-DataFormat.js

@@ -22,6 +22,7 @@ class DataFormat extends libFableServiceProviderBase
 		this._Regex_formatterDollarsRemoveCommas = /,/gi;
 		this._Regex_formatterCleanNonAlphaChar = /[^a-zA-Z]/gi;
 		this._Regex_formatterCapitalizeEachWord = /([a-zA-Z]+)/g;
+		this._Regex_matcherHTMLEntities = /&(#?[a-zA-Z0-9]+);/g;
 
 		// TODO: Potentially pull these in from a configuration.
 		// TODO: Use locale data for this if it's defaults all the way down.
@@ -157,6 +158,66 @@ class DataFormat extends libFableServiceProviderBase
 			});
 	}
 
+	/**
+	 * @param {string} pString - The string to resolve
+	 * @return {string} - The input string with all HTML entities resolved to their character counterparts
+	 */
+	resolveHtmlEntities(pString)
+	{
+		if (typeof(pString) !== 'string')
+		{
+			return pString;
+		}
+
+		return pString.replace(this._Regex_matcherHTMLEntities, (pMatch, pEntity) =>
+		{
+			switch (pEntity)
+			{
+				case 'comma':
+					return ',';
+				case 'amp':
+					return '&';
+				case 'lt':
+					return '<';
+				case 'gt':
+					return '>';
+				case 'times':
+					return '×';
+				case 'divide':
+					return '÷';
+				case 'plus':
+					return '+';
+				case 'minus':
+					return '-';
+				case 'infin':
+					return '∞';
+				case 'ang':
+					return '∠';
+				case 'quot':
+					return '"';
+				case 'apos':
+					return '\'';
+				case 'nbsp':
+					return ' ';
+				case 'copy':
+					return '©';
+				case 'reg':
+					return '®';
+				case 'trade':
+					return '™';
+				case 'euro':
+					return '€';
+				default:
+					if (!pEntity.startsWith('#'))
+					{
+						return pMatch;
+					}
+			}
+			const tmpNumericalValue = parseInt(pEntity.substring(1), 10);
+			return String.fromCharCode(tmpNumericalValue);
+		});
+	}
+
 	/**
 	 * Concatenate a list of strings together. Non-strings are excluded.
 	 *
@@ -177,19 +238,7 @@ class DataFormat extends libFableServiceProviderBase
 	concatenateStringsInternal ()
 	{
 		const pParams = [ ...arguments ];
-		const tmpArrayFlattener = (p) =>
-		{
-			if (Array.isArray(p))
-			{
-				return p.flatMap(tmpArrayFlattener);
-			}
-			if (typeof p === 'object')
-			{
-				return Object.values(p);
-			}
-			return [ p ];
-		};
-		const tmpFlattenedArrays = pParams.flatMap(tmpArrayFlattener);
+		const tmpFlattenedArrays = this.fable.Utility.flattenArrayOfSolverInputs(pParams);
 
 		return this.concatenateStrings(...tmpFlattenedArrays);
 	}
@@ -216,19 +265,7 @@ class DataFormat extends libFableServiceProviderBase
 	joinStringsInternal()
 	{
 		const [ pJoinOn, ...pParams ] = arguments;
-		const tmpArrayFlattener = (p) =>
-		{
-			if (Array.isArray(p))
-			{
-				return p.flatMap(tmpArrayFlattener);
-			}
-			if (typeof p === 'object')
-			{
-				return Object.values(p);
-			}
-			return [ p ];
-		};
-		const tmpFlattenedArrays = pParams.flatMap(tmpArrayFlattener);
+		const tmpFlattenedArrays = this.fable.Utility.flattenArrayOfSolverInputs(pParams);
 
 		return this.joinStrings(pJoinOn, ...tmpFlattenedArrays);
 	}
@@ -254,19 +291,7 @@ class DataFormat extends libFableServiceProviderBase
 	concatenateStringsRawInternal (pValueObjectSetAddress)
 	{
 		const pParams = [ ...arguments ];
-		const tmpArrayFlattener = (p) =>
-		{
-			if (Array.isArray(p))
-			{
-				return p.flatMap(tmpArrayFlattener);
-			}
-			if (typeof p === 'object')
-			{
-				return Object.values(p);
-			}
-			return [ p ];
-		};
-		const tmpFlattenedArrays = pParams.flatMap(tmpArrayFlattener);
+		const tmpFlattenedArrays = this.fable.Utility.flattenArrayOfSolverInputs(pParams);
 
 		return this.concatenateStringsRaw(...tmpFlattenedArrays);
 	}
@@ -293,19 +318,7 @@ class DataFormat extends libFableServiceProviderBase
 	joinStringsRawInternal ()
 	{
 		const [ pJoinOn, ...pParams ] = arguments;
-		const tmpArrayFlattener = (p) =>
-		{
-			if (Array.isArray(p))
-			{
-				return p.flatMap(tmpArrayFlattener);
-			}
-			if (typeof p === 'object')
-			{
-				return Object.values(p);
-			}
-			return [ p ];
-		};
-		const tmpFlattenedArrays = pParams.flatMap(tmpArrayFlattener);
+		const tmpFlattenedArrays = this.fable.Utility.flattenArrayOfSolverInputs(pParams);
 
 		return this.joinStringsRaw(pJoinOn, ...tmpFlattenedArrays);
 	}

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-ExpressionTokenizer.js

@@ -45,8 +45,8 @@ class ExpressionTokenizer extends libExpressionParserOperationBase
 			let tmpCharacter = pExpression[i];
 
 			// [ WHITESPACE ]
-			// 1. Space breaks tokens except when we're in an address that's been scoped by a {}
-			if ((tmpCharacter === ' ') && ((tmpCurrentTokenType !== 'StateAddress') && (tmpCurrentTokenType !== 'String')))
+			// 1. Space breaks tokens except when we're in an address that's been scoped by a {} or ""
+			if ((tmpCharacter === ' ' || tmpCharacter === '\t') && ((tmpCurrentTokenType !== 'StateAddress') && (tmpCurrentTokenType !== 'String')))
 			{
 				if (tmpCurrentToken.length > 0)
 				{

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-FunctionMap.json

@@ -129,16 +129,26 @@
 		"Address": "fable.Utility.getInternalValueByHash"
 	},
 
+	"flatten": {
+		"Name": "flatten an array of values",
+		"Address": "fable.Utility.flattenArrayOfSolverInputs"
+	},
+
 	"findfirstvaluebyexactmatch": {
-		"Name": "find + map on array of objects?",
+		"Name": "find + map on array of objects",
 		"Address": "fable.Utility.findFirstValueByExactMatchInternal"
 	},
 
 	"findfirstvaluebystringincludes": {
-		"Name": "find + map on array of objects?",
+		"Name": "find + map on array of objects",
 		"Address": "fable.Utility.findFirstValueByStringIncludesInternal"
 	},
 
+	"resolvehtmlentities": {
+		"Name": "resolve HTML entities",
+		"Address": "fable.Utility.resolveHtmlEntities"
+	},
+
 	"concat": {
 		"Name": "concatenate an array of values and output a string",
 		"Address": "fable.DataFormat.concatenateStringsInternal"
@@ -159,15 +169,25 @@
 		"Address": "fable.DataFormat.joinStringsRawInternal"
 	},
 
+	"if": {
+		"Name": "perform a conditional operator on two values, and choose one of two outcomes based on the result",
+		"Address": "fable.Logic.checkIf"
+	},
+
+	"when": {
+		"Name": "perform a 'truthy' check on one value, and return one of two outcomes based on the result",
+		"Address": "fable.Logic.when"
+	},
+
 	"entryinset": {
 		"Name": "Entry in Set",
 		"Address": "fable.Math.entryInSet"
 	},
-	"smallestInSet": {
+	"smallestinset": {
 		"Name": "Smallest in Set",
 		"Address": "fable.Math.smallestInSet"
 	},
-	"largestInSet": {
+	"largestinset": {
 		"Name": "Largest in Set",
 		"Address": "fable.Math.largestInSet"
 	},

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-Messaging.js

@@ -25,7 +25,7 @@ class ExpressionParserMessaging extends libExpressionParserOperationBase
 	{
 		let tmpVirtualSymbol = this.getOperationVirtualSymbolName(pToken);
 
-		if ((pToken.Type == 'Token.Constant') && (pToken.Value))
+		if ((pToken.Type == 'Token.Symbol' || pToken.Type == 'Token.Constant') && (pToken.Value))
 		{
 			return pToken.Value.toString();
 		}
@@ -166,9 +166,9 @@ class ExpressionParserMessaging extends libExpressionParserOperationBase
 			return;
 		}
 
-		for (let i = 0; i < tmpExpressionParseOutcome.PostfixSolveList.length; i++)
+		for (let i = 0; i < pResultObject.PostfixSolveList.length; i++)
 		{
-			let tmpToken = tmpExpressionParseOutcome.PostfixSolveList[i];
+			let tmpToken = pResultObject.PostfixSolveList[i];
 			console.log(`${i}: ${tmpToken.VirtualSymbolName} = (${tmpToken.LeftValue.Token}::${tmpToken.LeftValue.Value})  ${tmpToken.Operation.Token}  (${tmpToken.RightValue.Token}::${tmpToken.RightValue.Value}) `)
 		}
 

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-Postfix.js

@@ -243,6 +243,9 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 		// This maps layer stack addresses (which match parenthesis virtual symbol names) to the resultant value for that layer stack.
 		// These values change as it solves but the last assignment is the proper assignment because math only reads forward in a line
 		tmpResults.PostfixLayerstackMap = {};
+		//FIXME: vet these - do we need a suffix version?
+		const unaryEligibleOperationTokens = [ '+', '-' ];
+		const unaryOperationPrefixTriggerTypes = [ 'Token.Operator', 'Token.Assignment' ];
 		for (let tmpSolveLayerIndex = 0; tmpSolveLayerIndex < tmpSolveLayerKeys.length; tmpSolveLayerIndex++)
 		{
 			let tmpSolveLayerTokens = tmpSolveLayerMap[tmpSolveLayerKeys[tmpSolveLayerIndex]];
@@ -253,11 +256,22 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 				// There is a recursive way to do this, but given the short length of even the most complex equations we're favoring readability.
 				for (let i = 0; i < tmpSolveLayerTokens.length; i++)
 				{
+					const tmpToken = tmpSolveLayerTokens[i];
+					if (unaryEligibleOperationTokens.includes(tmpToken.Token) &&
+					// promote to unary if:
+					// 1. we are the first token in our group
+					// 2. we are prefixed by a token type that is incompatible with us being binary
+						(i == 0 || unaryOperationPrefixTriggerTypes.includes(tmpSolveLayerTokens[i - 1].Type)))
+					{
+						//FIXME: slow, but don't break the static data
+						tmpToken.Descriptor = JSON.parse(JSON.stringify(tmpToken.Descriptor));
+						tmpToken.Descriptor.Precedence = 1;
+					}
+					//FIXME: handle operators with dynamic precedence (ex. unary vs. bunary + and -)
 					// If the token is an operator and at the current precedence, add it to the postfix solve list and mutate the array.
 					if ((tmpSolveLayerTokens[i].Type === 'Token.Operator') &&
-						(tmpSolveLayerTokens[i].Descriptor.Precedence === tmpPrecedence))
+						(tmpToken.Descriptor.Precedence === tmpPrecedence))
 					{
-						let tmpToken = tmpSolveLayerTokens[i];
 						// If there is a token and nothing else in this layer, then it's an error.
 						if (tmpSolveLayerTokens.length === 1)
 						{
@@ -265,6 +279,13 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 							this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
 							return tmpResults.PostfixSolveList;
 						}
+						// The - at the beginning of an expression is a number line orientation modifier
+						else if ((i == 0) && (tmpToken.Token == '-' || tmpToken.Token == '+'))
+						{
+							tmpToken.VirtualSymbolName = `VNLO_${tmpVirtualSymbolIndex}`;
+							tmpResults.PostfixLayerstackMap[tmpToken.SolveLayerStack] = tmpToken.VirtualSymbolName;
+							tmpVirtualSymbolIndex++;
+						}
 						// If the token is at the beginning of the expression and not a number line orientation modifier, it's an error.
 						else if ((i == 0) && ((tmpToken.Token != '+') || (tmpToken.Token != '-')))
 						{
@@ -280,13 +301,6 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 							return tmpResults.PostfixSolveList;
 						}
 
-						// The - at the beginning of an expression is a number line orientation modifier
-						else if ((i == 0) && (tmpToken.Token == '-'))
-						{
-							tmpToken.VirtualSymbolName = `VNLO_${tmpVirtualSymbolIndex}`;
-							tmpResults.PostfixLayerstackMap[tmpToken.SolveLayerStack] = tmpToken.VirtualSymbolName;
-							tmpVirtualSymbolIndex++;
-						}
 						// The - after an operator or an open parenthesis is also a number line orientation modifier
 						else if ((i > 0) && (tmpToken.Token == '-') && ((tmpSolveLayerTokens[i-1].Type === 'Token.Operator') || (tmpSolveLayerTokens[i-1].Token === '(')))
 						{
@@ -306,7 +320,8 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 						}
 
 						// If the token is next to another operator it's a parsing error
-						else if ((tmpSolveLayerTokens[i-1].Type === 'Token.Operator') || (tmpSolveLayerTokens[i+1].Type === 'Token.Operator'))
+						else if (((tmpSolveLayerTokens[i-1].Type === 'Token.Operator') || (tmpSolveLayerTokens[i+1].Type === 'Token.Operator')) &&
+								(tmpSolveLayerTokens[i+1].Token != '-' && tmpSolveLayerTokens[i+1].Token != '+'))
 						{
 							tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.buildPostfixedSolveList found an operator at token index ${i} that is not surrounded by two values.`);
 							this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-SolvePostfixedExpression.js

@@ -1,4 +1,5 @@
 const libExpressionParserOperationBase = require('./Fable-Service-ExpressionParser-Base.js');
+const libSetConcatArray = require('../Fable-SetConcatArray.js');
 
 class ExpressionParserSolver extends libExpressionParserOperationBase
 {
@@ -41,6 +42,7 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 
 		for (let i = 0; i < pPostfixedExpression.length; i++)
 		{
+			// X = SUM(15, SUM(SIN(25), 10), (5 + 2), 3)
 			if (pPostfixedExpression[i].Operation.Type === 'Token.SolverInstruction')
 			{
 				continue;
@@ -89,7 +91,7 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 			{
 				// TODO: This can be optimized.   A lot.  If necessary.  Seems pretty fast honestly for even thousands of operations.  Slowest part is arbitrary precision.
 				// An operator always has a left and right value.
-				let tmpFunctionAddress = false;
+				let tmpFunctionAddress;
 				// Note: There are easier, passive ways of managing this state.  But this is complex.
 				let tmpIsFunction = false;
 				if (tmpStepResultObject.ExpressionStep.Operation.Token in this.ExpressionParser.tokenMap)
@@ -106,39 +108,27 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 				{
 					try
 					{
-						//this.log.trace(`Solving Function Step ${i} [${tmpStepResultObject.ExpressionStep.VirtualSymbolName}] --> [${tmpStepResultObject.ExpressionStep.Operation.Token}]: ( ${tmpStepResultObject.ExpressionStep.LeftValue.Value} , ${tmpStepResultObject.ExpressionStep.RightValue.Value} )`);
-						// Build the set of arguments to send to the functions.
-						tmpStepResultObject.ExpressionStep.LeftValue.ArgumentString = '';
-						if (typeof(tmpStepResultObject.ExpressionStep.LeftValue.Value) === 'undefined')
+						let tmpResult;
+						const tmpFunction = tmpManifest.getValueAtAddress(tmpStepResultObject, tmpFunctionAddress);
+						if (typeof tmpFunction === 'function')
 						{
-							tmpStepResultObject.ExpressionStep.LeftValue.Arguments = [];
-						}
-						else if (Array.isArray(tmpStepResultObject.ExpressionStep.LeftValue.Value))
-						{
-							// Allow for array-based math sets to just be pased through
-							tmpStepResultObject.ExpressionStep.LeftValue.Arguments = tmpStepResultObject.ExpressionStep.LeftValue.Value;
-							tmpStepResultObject.ExpressionStep.LeftValue.ArgumentString = 'ExpressionStep.LeftValue.Arguments';
-						}
-						else if (typeof(tmpStepResultObject.ExpressionStep.LeftValue.Value) === 'object')
-						{
-							// Allow for array-based math sets to just be pased through
-							tmpStepResultObject.ExpressionStep.LeftValue.Arguments = tmpStepResultObject.ExpressionStep.LeftValue.Value;
-							tmpStepResultObject.ExpressionStep.LeftValue.ArgumentString = 'ExpressionStep.LeftValue.Arguments';
-						}
-						else
-						{
-							// Allow for string-based math sets.
-							tmpStepResultObject.ExpressionStep.LeftValue.Arguments = tmpStepResultObject.ExpressionStep.LeftValue.Value.toString().split(',');
-							for (let j = 0; j < tmpStepResultObject.ExpressionStep.LeftValue.Arguments.length; j++)
+							let tmpFunctionBinding = null;
+							if (tmpFunctionAddress.includes('.'))
+							{
+								tmpFunctionBinding = tmpManifest.getValueAtAddress(tmpStepResultObject, tmpFunctionAddress.split('.').slice(0, -1).join('.'));
+							}
+							let tmpArguments = tmpStepResultObject.ExpressionStep.LeftValue.Value;
+							if (!(tmpArguments instanceof libSetConcatArray))
+							{
+								tmpArguments = [ tmpArguments ];
+							}
+							else
 							{
-								if (tmpStepResultObject.ExpressionStep.LeftValue.ArgumentString !== '')
-								{
-									tmpStepResultObject.ExpressionStep.LeftValue.ArgumentString += ',';
-								}
-								tmpStepResultObject.ExpressionStep.LeftValue.ArgumentString += `ExpressionStep.LeftValue.Arguments[${j}]`;
+								tmpArguments = tmpArguments.values;
 							}
+							tmpResult = tmpFunction.apply(tmpFunctionBinding, tmpArguments);
 						}
-						tmpManifest.setValueAtAddress(tmpResults.VirtualSymbols, tmpStepResultObject.ExpressionStep.VirtualSymbolName, tmpManifest.getValueAtAddress(tmpStepResultObject, `${tmpFunctionAddress}(${tmpStepResultObject.ExpressionStep.LeftValue.ArgumentString})`));
+						tmpManifest.setValueAtAddress(tmpResults.VirtualSymbols, tmpStepResultObject.ExpressionStep.VirtualSymbolName, tmpResult);
 						tmpResults.LastResult = tmpManifest.getValueAtAddress(tmpResults.VirtualSymbols, tmpStepResultObject.ExpressionStep.VirtualSymbolName);
 						//this.log.trace(`   ---> Step ${i}: ${tmpResults.VirtualSymbols[tmpStepResultObject.ExpressionStep.VirtualSymbolName]}`)
 					}

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-TokenMap.json

@@ -63,7 +63,7 @@
 			"Name": "Exponent",
 			"Token": "^",
 			"Function": "fable.Math.powerPrecise",
-			"Precedence": 1,
+			"Precedence": 2,
 			"Type": "Operator"
 		},
 	"%":
@@ -91,4 +91,4 @@
 			"Precedence": 4,
 			"Type": "Operator"
 		}
-}
+}

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-ValueMarshal.js

@@ -60,6 +60,8 @@ class ExpressionParserValueMarshal extends libExpressionParserOperationBase
 				// }
 				if (!tmpValue)
 				{
+					tmpToken.Value = tmpValue;
+					tmpToken.Resolve = true;
 					tmpResults.ExpressionParserLog.push(`WARNING: ExpressionParser.substituteValuesInTokenizedObjects found no value for the symbol hash or address ${tmpToken.Token} at index ${i}`);
 					this.log.warn(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
 					continue;

package/source/services/Fable-Service-FilePersistence.js

@@ -74,17 +74,17 @@ class FableServiceFilePersistence extends libFableServiceBase
 		let tmpRecordFunction = (typeof(fRecordFunction) === 'function') ? fRecordFunction :
 			(pRecord) =>
 			{
-				this.fable.log(`CSV Reader received line ${pRecord}`);
+				this.fable.log.trace(`CSV Reader received line ${pRecord}`);
 			};
 		let tmpCompleteFunction = (typeof(fCompleteFunction) === 'function') ? fCompleteFunction :
 			() =>
 			{
-				this.fable.log(`CSV Read of ${pFilePath} complete.`);
+				this.fable.log.info(`CSV Read of ${pFilePath} complete.`);
 			};
 		let tmpErrorFunction = (typeof(fErrorFunction) === 'function') ? fErrorFunction :
 			(pError) =>
 			{
-				this.fable.log(`CSV Read of ${pFilePath} Error: ${pError}`, pError);
+				this.fable.log.error(`CSV Read of ${pFilePath} Error: ${pError}`, pError);
 			};
 		
 		return this.lineReaderFactory(pFilePath,

package/source/services/Fable-Service-Logic.js

@@ -0,0 +1,129 @@
+const libFableServiceBase = require('fable-serviceproviderbase');
+
+class FableServiceLogic extends libFableServiceBase
+{
+	/**
+	 * @param {import('../Fable.js')} pFable - The fable object
+	 * @param {Record<string, any>} [pOptions] - The options object
+	 * @param {string} [pServiceHash] - The hash of the service
+	 */
+	constructor(pFable, pOptions, pServiceHash)
+	{
+        super(pFable, pOptions, pServiceHash);
+	}
+
+	/**
+	 * Find the first value in an object that contains a specific value
+	 *
+	 * @param {string|number} pLeft - The left value to check
+	 * @param {string} pComparisonOperator - The comparison operator to use
+	 * @param {string|number} pRight - The right value to check
+	 * @param {any} pOnTrue - The value to return if the comparison is true
+	 * @param {any} [pOnFalse = ''] - The value to return if the comparison is false
+	 * @return {any} - The selected value
+	 */
+	checkIf(pLeft, pComparisonOperator, pRight, pOnTrue, pOnFalse)
+	{
+		// precise numeric
+		// string (non-numeric)
+		let tmpMathLeft = this.fable.Math.parsePrecise(pLeft, null);
+		let tmpMathRight = this.fable.Math.parsePrecise(pRight, null);
+		let tmpCheckResult = false;
+		if (tmpMathLeft === null || tmpMathRight === null)
+		{
+			if (typeof pOnFalse === 'undefined')
+			{
+				pOnFalse = '';
+			}
+			switch (pComparisonOperator)
+			{
+				case '<':
+				case 'LT':
+					tmpCheckResult = pLeft < pRight;
+					break;
+				case '<=':
+				case 'LTE':
+					tmpCheckResult = pLeft <= pRight;
+					break;
+				case '>':
+				case 'GT':
+					tmpCheckResult = pLeft > pRight;
+					break;
+				case '>=':
+				case 'GTE':
+					tmpCheckResult = pLeft >= pRight;
+					break;
+				case '==':
+					tmpCheckResult = pLeft == pRight;
+				case '===':
+					tmpCheckResult = pLeft === pRight;
+				default:
+					this.fable.log.warn(`[FableServiceLogic.checkIf] Invalid comparison operator: ${pComparisonOperator}`);
+					tmpCheckResult = pLeft == pRight;
+			}
+		}
+		else
+		{
+			if (typeof pOnFalse === 'undefined')
+			{
+				pOnFalse = '0';
+			}
+			switch (pComparisonOperator)
+			{
+				case '<':
+				case 'LT':
+					tmpCheckResult = this.fable.Math.ltPrecise(tmpMathLeft, tmpMathRight);
+					break;
+				case '<=':
+				case 'LTE':
+					tmpCheckResult = this.fable.Math.ltePrecise(tmpMathLeft, tmpMathRight);
+					break;
+				case '>':
+				case 'GT':
+					tmpCheckResult = this.fable.Math.gtPrecise(tmpMathLeft, tmpMathRight);
+					break;
+				case '>=':
+				case 'GTE':
+					tmpCheckResult = this.fable.Math.gtePrecise(tmpMathLeft, tmpMathRight);
+					break;
+				case '==':
+					tmpCheckResult = this.fable.Math.comparePreciseWithin(tmpMathLeft, tmpMathRight, '0.000001') == 0;
+					break;
+				case '===':
+					tmpCheckResult = this.fable.Math.comparePrecise(tmpMathLeft, tmpMathRight) == 0;
+					break;
+				default:
+					this.fable.log.warn(`[FableServiceLogic.checkIf] Invalid comparison operator: ${pComparisonOperator}`);
+					tmpCheckResult = pLeft == pRight ? pOnTrue : pOnFalse;
+			}
+		}
+		return tmpCheckResult ? pOnTrue : pOnFalse;
+	}
+
+	/**
+	 * Find the first value in an object that contains a specific value
+	 *
+	 * @param {any} pCheckForTruthy - The object to check
+	 * @param {any} pOnTrue - The value to return if the object is truthy
+	 * @param {any} [pOnFalse = ''] - The value to return if the object is falsy
+	 * @return {any} - The value from the object
+	 */
+	when(pCheckForTruthy, pOnTrue, pOnFalse = '')
+	{
+		if (!pCheckForTruthy)
+		{
+			return pOnFalse;
+		}
+		if (Array.isArray(pCheckForTruthy) && pCheckForTruthy.length < 1)
+		{
+			return pOnFalse;
+		}
+		if (typeof pCheckForTruthy === 'object' && Object.keys(pCheckForTruthy).length < 1)
+		{
+			return pOnFalse;
+		}
+		return pOnTrue;
+	}
+}
+
+module.exports = FableServiceLogic;