fable 3.1.64 → 3.1.65

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

@@ -339,10 +339,153 @@ class ExpressionTokenizerDirectiveMutation extends libExpressionParserOperationB
 		return tmpNewDirectiveDescription;
 	}
 
+	rewriteTernaryOperators(pResultObject)
+	{
+		let tmpTokens = pResultObject.RawTokens;
+
+		// Scan right-to-left so nested ternaries (innermost first) are handled correctly.
+		for (let i = tmpTokens.length - 1; i >= 0; i--)
+		{
+			if (tmpTokens[i] !== '?')
+			{
+				continue;
+			}
+
+			// Found a ? token at index i.
+			// Walk left to find the start of the condition expression.
+			// The condition starts after the previous comma, open parenthesis, assignment operator, or beginning of tokens.
+			let tmpConditionStart = 0;
+			let tmpParenDepth = 0;
+			for (let j = i - 1; j >= 0; j--)
+			{
+				if (tmpTokens[j] === ')')
+				{
+					tmpParenDepth++;
+				}
+				else if (tmpTokens[j] === '(')
+				{
+					if (tmpParenDepth > 0)
+					{
+						tmpParenDepth--;
+					}
+					else
+					{
+						// We hit an unmatched open paren — condition starts after it
+						tmpConditionStart = j + 1;
+						break;
+					}
+				}
+				else if (tmpParenDepth === 0)
+				{
+					let tmpTokenDescriptor = this.ExpressionParser.tokenMap[tmpTokens[j]];
+					if (tmpTokenDescriptor && (tmpTokenDescriptor.Type === 'Assignment' || tmpTokens[j] === ','))
+					{
+						tmpConditionStart = j + 1;
+						break;
+					}
+				}
+			}
+
+			// Walk right from ? to find the matching :: at the same parenthesis depth.
+			let tmpSeparatorIndex = -1;
+			tmpParenDepth = 0;
+			for (let j = i + 1; j < tmpTokens.length; j++)
+			{
+				if (tmpTokens[j] === '(')
+				{
+					tmpParenDepth++;
+				}
+				else if (tmpTokens[j] === ')')
+				{
+					if (tmpParenDepth > 0)
+					{
+						tmpParenDepth--;
+					}
+					else
+					{
+						// Hit closing paren at our depth — no :: found in this group
+						break;
+					}
+				}
+				else if (tmpTokens[j] === '::' && tmpParenDepth === 0)
+				{
+					tmpSeparatorIndex = j;
+					break;
+				}
+			}
+
+			if (tmpSeparatorIndex === -1)
+			{
+				pResultObject.ExpressionParserLog.push(`ExpressionParser.rewriteTernaryOperators found a ? at token index ${i} with no matching :: separator.`);
+				this.log.warn(pResultObject.ExpressionParserLog[pResultObject.ExpressionParserLog.length - 1]);
+				continue;
+			}
+
+			// Walk right from :: to find the end of the false branch.
+			// The false branch ends at the next comma, close parenthesis, or end of tokens at the same depth.
+			let tmpFalseBranchEnd = tmpTokens.length;
+			tmpParenDepth = 0;
+			for (let j = tmpSeparatorIndex + 1; j < tmpTokens.length; j++)
+			{
+				if (tmpTokens[j] === '(')
+				{
+					tmpParenDepth++;
+				}
+				else if (tmpTokens[j] === ')')
+				{
+					if (tmpParenDepth > 0)
+					{
+						tmpParenDepth--;
+					}
+					else
+					{
+						// Unmatched close paren — false branch ends here
+						tmpFalseBranchEnd = j;
+						break;
+					}
+				}
+				else if (tmpParenDepth === 0)
+				{
+					if (tmpTokens[j] === ',')
+					{
+						tmpFalseBranchEnd = j;
+						break;
+					}
+				}
+			}
+
+			// Extract the three segments
+			let tmpConditionTokens = tmpTokens.slice(tmpConditionStart, i);
+			let tmpTrueBranchTokens = tmpTokens.slice(i + 1, tmpSeparatorIndex);
+			let tmpFalseBranchTokens = tmpTokens.slice(tmpSeparatorIndex + 1, tmpFalseBranchEnd);
+
+			// Build the replacement: ternary((condition), trueBranch, falseBranch)
+			// The condition is wrapped in its own parentheses to ensure correct
+			// precedence grouping when arithmetic appears on both sides of a comparison.
+			let tmpReplacementTokens = ['ternary', '(', '('];
+			tmpReplacementTokens = tmpReplacementTokens.concat(tmpConditionTokens);
+			tmpReplacementTokens.push(')');
+			tmpReplacementTokens.push(',');
+			tmpReplacementTokens = tmpReplacementTokens.concat(tmpTrueBranchTokens);
+			tmpReplacementTokens.push(',');
+			tmpReplacementTokens = tmpReplacementTokens.concat(tmpFalseBranchTokens);
+			tmpReplacementTokens.push(')');
+
+			// Splice the replacement into the token array
+			tmpTokens.splice(tmpConditionStart, tmpFalseBranchEnd - tmpConditionStart, ...tmpReplacementTokens);
+
+			// Adjust i to re-scan from the start of what we just inserted (in case of nested ternaries in the condition)
+			i = tmpConditionStart;
+		}
+	}
+
 	parseDirectives(pResultObject)
 	{
 		let tmpResults = (typeof(pResultObject) === 'object') ? pResultObject : { ExpressionParserLog: [] };
 
+		// Rewrite ternary operators before directive parsing
+		this.rewriteTernaryOperators(tmpResults);
+
 		tmpResults.SolverDirectives = this.defaultDirective;
 		tmpResults.SolverDirectiveTokens = [];
 

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

@@ -215,7 +215,7 @@ class ExpressionTokenizer extends libExpressionParserOperationBase
 						{
 							if (tmpCurrentToken.length > 0)
 							{
-								tmpResults.RawTokens.push(tmpTokenKey);
+								tmpResults.RawTokens.push(tmpCurrentToken);
 							}
 							tmpCurrentToken = '';
 							tmpCurrentTokenType = false;

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

@@ -285,6 +285,11 @@
 		"Address": "fable.Logic.when"
 	},
 
+	"ternary": {
+		"Name": "numeric-aware ternary selection (used by ? :: operator desugaring)",
+		"Address": "fable.Logic.ternary"
+	},
+
 	"entryinset": {
 		"Name": "Entry in Set",
 		"Address": "fable.Math.entryInSet"
@@ -465,10 +470,6 @@
 		"Address": "fable.Math.interceptPrecise"
 	},
 
-	"polynomialregression": {
-		"Name": "Perform an nth degree Polynomial Regression on a Set of X and Y Values",
-		"Address": "fable.Math.polynomialRegression"
-	},
 	"leastsquares": {
 		"Name": "Perform a Least Squares Regression on a Set of Independent Variable Vectors and a Dependent Variable Vector",
 		"Address": "fable.Math.leastSquares"

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

@@ -46,7 +46,7 @@
 			"Name": "Set Concatenate",
 			"Token": ",",
 			"Function": "fable.Math.setConcatenate",
-			"Precedence": 5,
+			"Precedence": 6,
 			"Type": "Operator"
 		},
 
@@ -99,5 +99,69 @@
 			"Function": "fable.Math.subtractPrecise",
 			"Precedence": 4,
 			"Type": "Operator"
+		},
+
+	">":
+		{
+			"Name": "Greater Than",
+			"Token": ">",
+			"Function": "fable.Math.greaterThanOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+	">=":
+		{
+			"Name": "Greater Than or Equal",
+			"Token": ">=",
+			"Function": "fable.Math.greaterThanOrEqualOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+	"<":
+		{
+			"Name": "Less Than",
+			"Token": "<",
+			"Function": "fable.Math.lessThanOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+	"<=":
+		{
+			"Name": "Less Than or Equal",
+			"Token": "<=",
+			"Function": "fable.Math.lessThanOrEqualOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+	"==":
+		{
+			"Name": "Equal",
+			"Token": "==",
+			"Function": "fable.Math.equalOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+	"!=":
+		{
+			"Name": "Not Equal",
+			"Token": "!=",
+			"Function": "fable.Math.notEqualOperator",
+			"Precedence": 5,
+			"Type": "Operator"
+		},
+
+	"?":
+		{
+			"Name": "Ternary Condition",
+			"Token": "?",
+			"Precedence": 0,
+			"Type": "Ternary"
+		},
+	"::":
+		{
+			"Name": "Ternary Separator",
+			"Token": "::",
+			"Precedence": 0,
+			"Type": "Ternary"
 		}
 }

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

@@ -112,6 +112,7 @@ class FableServiceExpressionParser extends libFableServiceBase
 
 		// Wire each sub service into this instance of the solver.
 		this.Tokenizer.connectExpressionParser(this);
+		this.Tokenizer.TokenizerDirectiveMutation.connectExpressionParser(this);
 		this.Linter.connectExpressionParser(this);
 		this.Postfix.connectExpressionParser(this);
 		this.ValueMarshal.connectExpressionParser(this);

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

@@ -126,6 +126,39 @@ class FableServiceLogic extends libFableServiceBase
 		}
 		return pOnTrue;
 	}
+
+	/**
+	 * Numeric-aware ternary selection for the expression parser.
+	 * Treats 0, "0", "", null, undefined, false, NaN, empty arrays, and empty objects as falsy.
+	 * Used by the ternary operator desugaring (condition ? trueVal :: falseVal).
+	 *
+	 * @param {any} pCondition - The condition to evaluate
+	 * @param {any} pOnTrue - The value to return if the condition is truthy
+	 * @param {any} [pOnFalse = ''] - The value to return if the condition is falsy
+	 * @return {any} - The selected value
+	 */
+	ternary(pCondition, pOnTrue, pOnFalse = '')
+	{
+		// Standard JS falsy check
+		if (!pCondition)
+		{
+			return pOnFalse;
+		}
+		// Numeric zero as a string (from comparison operators returning "0")
+		if (pCondition === '0')
+		{
+			return pOnFalse;
+		}
+		if (Array.isArray(pCondition) && pCondition.length < 1)
+		{
+			return pOnFalse;
+		}
+		if (typeof pCondition === 'object' && Object.keys(pCondition).length < 1)
+		{
+			return pOnFalse;
+		}
+		return pOnTrue;
+	}
 }
 
 module.exports = FableServiceLogic;

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

@@ -460,6 +460,84 @@ class FableServiceMath extends libFableServiceBase
 		return tmpLeftArbitraryValue.lte(tmpRightValue);
 	}
 
+	/**
+	 * Comparison operator: returns "1" if left > right, "0" otherwise.
+	 * For use as an infix operator in the expression parser.
+	 *
+	 * @param {number|string} pLeftValue - The left value to compare.
+	 * @param {number|string} pRightValue - The right value to compare.
+	 * @returns {string} - "1" if left > right, "0" otherwise.
+	 */
+	greaterThanOperator(pLeftValue, pRightValue)
+	{
+		return this.gtPrecise(pLeftValue, pRightValue) ? '1' : '0';
+	}
+
+	/**
+	 * Comparison operator: returns "1" if left >= right, "0" otherwise.
+	 * For use as an infix operator in the expression parser.
+	 *
+	 * @param {number|string} pLeftValue - The left value to compare.
+	 * @param {number|string} pRightValue - The right value to compare.
+	 * @returns {string} - "1" if left >= right, "0" otherwise.
+	 */
+	greaterThanOrEqualOperator(pLeftValue, pRightValue)
+	{
+		return this.gtePrecise(pLeftValue, pRightValue) ? '1' : '0';
+	}
+
+	/**
+	 * Comparison operator: returns "1" if left < right, "0" otherwise.
+	 * For use as an infix operator in the expression parser.
+	 *
+	 * @param {number|string} pLeftValue - The left value to compare.
+	 * @param {number|string} pRightValue - The right value to compare.
+	 * @returns {string} - "1" if left < right, "0" otherwise.
+	 */
+	lessThanOperator(pLeftValue, pRightValue)
+	{
+		return this.ltPrecise(pLeftValue, pRightValue) ? '1' : '0';
+	}
+
+	/**
+	 * Comparison operator: returns "1" if left <= right, "0" otherwise.
+	 * For use as an infix operator in the expression parser.
+	 *
+	 * @param {number|string} pLeftValue - The left value to compare.
+	 * @param {number|string} pRightValue - The right value to compare.
+	 * @returns {string} - "1" if left <= right, "0" otherwise.
+	 */
+	lessThanOrEqualOperator(pLeftValue, pRightValue)
+	{
+		return this.ltePrecise(pLeftValue, pRightValue) ? '1' : '0';
+	}
+
+	/**
+	 * Comparison operator: returns "1" if left == right, "0" otherwise.
+	 * For use as an infix operator in the expression parser.
+	 *
+	 * @param {number|string} pLeftValue - The left value to compare.
+	 * @param {number|string} pRightValue - The right value to compare.
+	 * @returns {string} - "1" if left == right, "0" otherwise.
+	 */
+	equalOperator(pLeftValue, pRightValue)
+	{
+		return this.comparePrecise(pLeftValue, pRightValue) == 0 ? '1' : '0';
+	}
+
+	/**
+	 * Comparison operator: returns "1" if left != right, "0" otherwise.
+	 * For use as an infix operator in the expression parser.
+	 *
+	 * @param {number|string} pLeftValue - The left value to compare.
+	 * @param {number|string} pRightValue - The right value to compare.
+	 * @returns {string} - "1" if left != right, "0" otherwise.
+	 */
+	notEqualOperator(pLeftValue, pRightValue)
+	{
+		return this.comparePrecise(pLeftValue, pRightValue) != 0 ? '1' : '0';
+	}
+
 	/**
 	 * Converts degrees to radians with arbitrary precision.
 	 *

package/test/ExpressionParser_tests.js

@@ -2155,3 +2155,293 @@ suite
 				);
 		}
 	);
+
+suite
+	(
+		'Comparison Operators',
+		function ()
+		{
+			suite
+				(
+					'Greater Than',
+					function ()
+					{
+						test
+							(
+								'Basic greater than comparisons.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									Expect(_Parser.solve('Result = 5 > 3')).to.equal('1');
+									Expect(_Parser.solve('Result = 3 > 5')).to.equal('0');
+									Expect(_Parser.solve('Result = 5 > 5')).to.equal('0');
+									return fDone();
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Greater Than or Equal',
+					function ()
+					{
+						test
+							(
+								'Basic greater than or equal comparisons.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									Expect(_Parser.solve('Result = 5 >= 3')).to.equal('1');
+									Expect(_Parser.solve('Result = 3 >= 5')).to.equal('0');
+									Expect(_Parser.solve('Result = 5 >= 5')).to.equal('1');
+									return fDone();
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Less Than',
+					function ()
+					{
+						test
+							(
+								'Basic less than comparisons.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									Expect(_Parser.solve('Result = 3 < 5')).to.equal('1');
+									Expect(_Parser.solve('Result = 5 < 3')).to.equal('0');
+									Expect(_Parser.solve('Result = 5 < 5')).to.equal('0');
+									return fDone();
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Less Than or Equal',
+					function ()
+					{
+						test
+							(
+								'Basic less than or equal comparisons.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									Expect(_Parser.solve('Result = 3 <= 5')).to.equal('1');
+									Expect(_Parser.solve('Result = 5 <= 3')).to.equal('0');
+									Expect(_Parser.solve('Result = 5 <= 5')).to.equal('1');
+									return fDone();
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Equal',
+					function ()
+					{
+						test
+							(
+								'Basic equality comparisons.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									Expect(_Parser.solve('Result = 5 == 5')).to.equal('1');
+									Expect(_Parser.solve('Result = 5 == 3')).to.equal('0');
+									return fDone();
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Not Equal',
+					function ()
+					{
+						test
+							(
+								'Basic inequality comparisons.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									Expect(_Parser.solve('Result = 5 != 3')).to.equal('1');
+									Expect(_Parser.solve('Result = 5 != 5')).to.equal('0');
+									return fDone();
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Comparison with Arithmetic',
+					function ()
+					{
+						test
+							(
+								'Arithmetic is evaluated before comparison.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									// 2 + 3 = 5, 1 + 2 = 3, so 5 > 3 = 1
+									Expect(_Parser.solve('Result = 2 + 3 > 1 + 2')).to.equal('1');
+									// 1 + 1 = 2, 3 + 1 = 4, so 2 > 4 = 0
+									Expect(_Parser.solve('Result = 1 + 1 > 3 + 1')).to.equal('0');
+									// 10 - 5 = 5, 2 * 3 = 6, so 5 < 6 = 1
+									Expect(_Parser.solve('Result = 10 - 5 < 2 * 3')).to.equal('1');
+									return fDone();
+								}
+							);
+						test
+							(
+								'Comparison with variables.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									let tmpData = { Height: 10, Width: 5 };
+									let tmpDestination = {};
+									_Parser.solve('Result = Height > Width', tmpData, {}, false, tmpDestination);
+									Expect(tmpDestination.Result).to.equal('1');
+									_Parser.solve('Result = Width > Height', tmpData, {}, false, tmpDestination);
+									Expect(tmpDestination.Result).to.equal('0');
+									_Parser.solve('Result = Height == Width', tmpData, {}, false, tmpDestination);
+									Expect(tmpDestination.Result).to.equal('0');
+									_Parser.solve('Result = Height != Width', tmpData, {}, false, tmpDestination);
+									Expect(tmpDestination.Result).to.equal('1');
+									return fDone();
+								}
+							);
+					}
+				);
+		}
+	);
+
+suite
+	(
+		'Ternary Operator',
+		function ()
+		{
+			suite
+				(
+					'Basic Ternary',
+					function ()
+					{
+						test
+							(
+								'True branch is selected when condition is truthy.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									Expect(_Parser.solve('Result = 5 > 3 ? 100 :: 200')).to.equal('100');
+									return fDone();
+								}
+							);
+						test
+							(
+								'False branch is selected when condition is falsy.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									Expect(_Parser.solve('Result = 3 > 5 ? 100 :: 200')).to.equal('200');
+									return fDone();
+								}
+							);
+						test
+							(
+								'Ternary with equality comparison.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									Expect(_Parser.solve('Result = 5 == 5 ? 10 :: 20')).to.equal('10');
+									Expect(_Parser.solve('Result = 5 == 3 ? 10 :: 20')).to.equal('20');
+									return fDone();
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Ternary with Variables',
+					function ()
+					{
+						test
+							(
+								'Ternary selects based on variable comparison.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									let tmpData = { Height: 10, Width: 5, A: 42, B: 99 };
+									let tmpDestination = {};
+									_Parser.solve('SomeValue = Height > Width ? A :: B', tmpData, {}, false, tmpDestination);
+									Expect(tmpDestination.SomeValue).to.equal('42');
+									_Parser.solve('SomeValue = Width > Height ? A :: B', tmpData, {}, false, tmpDestination);
+									Expect(tmpDestination.SomeValue).to.equal('99');
+									return fDone();
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Ternary with Arithmetic in Branches',
+					function ()
+					{
+						test
+							(
+								'Arithmetic expressions work in ternary branches.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									let tmpData = { A: 10, B: 5 };
+									let tmpDestination = {};
+									// A > B is true, so A + 1 = 11
+									_Parser.solve('Result = A > B ? A + 1 :: B + 1', tmpData, {}, false, tmpDestination);
+									Expect(tmpDestination.Result).to.equal('11');
+									// B > A is false, so B + 1 = 6
+									_Parser.solve('Result = B > A ? A + 1 :: B + 1', tmpData, {}, false, tmpDestination);
+									Expect(tmpDestination.Result).to.equal('6');
+									return fDone();
+								}
+							);
+						test
+							(
+								'Arithmetic expressions work in the ternary condition.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									// 2 + 3 = 5, 1 + 2 = 3, so 5 > 3 = true, result is 100
+									Expect(_Parser.solve('Result = 2 + 3 > 1 + 2 ? 100 :: 200')).to.equal('100');
+									// 1 + 1 = 2, 3 + 1 = 4, so 2 > 4 = false, result is 200
+									Expect(_Parser.solve('Result = 1 + 1 > 3 + 1 ? 100 :: 200')).to.equal('200');
+									return fDone();
+								}
+							);
+					}
+				);
+			suite
+				(
+					'Nested Ternary',
+					function ()
+					{
+						test
+							(
+								'Nested ternary with parenthesized inner ternary.',
+								(fDone) =>
+								{
+									let _Parser = getExpressionParser();
+									let tmpData = { A: 5, B: 3 };
+									let tmpDestination = {};
+									// A > 0 is true, then B > 0 is true, so result is 1
+									_Parser.solve('Result = A > 0 ? (B > 0 ? 1 :: 2) :: 3', tmpData, {}, false, tmpDestination);
+									Expect(tmpDestination.Result).to.equal('1');
+									// A > 0 is true, then B > 10 is false, so result is 2
+									_Parser.solve('Result = A > 0 ? (B > 10 ? 1 :: 2) :: 3', tmpData, {}, false, tmpDestination);
+									Expect(tmpDestination.Result).to.equal('2');
+									return fDone();
+								}
+							);
+					}
+				);
+		}
+	);