fable 3.1.64 → 3.1.66

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/source/services/Fable-Service-RestClient.js

@@ -305,6 +305,111 @@ class FableServiceRestClient extends libFableServiceBase
 		return this.executeJSONRequest(pOptions, fCallback);
 	}
 
+	/**
+	 * Upload binary data via POST.
+	 *
+	 * Accepts Buffer, Blob, or File as the body. In the browser, Blob/File
+	 * bodies are converted to Buffer (via ArrayBuffer) before being passed
+	 * to simple-get so the stream-http shim can send them correctly.
+	 *
+	 * The response body is read as a string (servers typically return JSON
+	 * status for upload endpoints).
+	 *
+	 * @param {Record<string, any>} pOptions - Request options (url, body, headers, method)
+	 * @param {(pError?: Error, pResponse: any, pBody?: any) => void} fCallback - Callback (pError, pResponse, pBody)
+	 * @param {(pProgress: number) => void} [fOnProgress] - Optional progress callback (0.0 to 1.0); called with 1.0 on completion
+	 */
+	executeBinaryUpload(pOptions, fCallback, fOnProgress)
+	{
+		// Blob/File → Buffer conversion for simple-get compatibility
+		let tmpBody = pOptions.body;
+
+		if (typeof Blob !== 'undefined' && tmpBody instanceof Blob)
+		{
+			let tmpSelf = this;
+			tmpBody.arrayBuffer()
+				.then(
+					(pArrayBuffer) =>
+					{
+						pOptions.body = Buffer.from(pArrayBuffer);
+						tmpSelf._executeBinaryUploadInternal(pOptions, fCallback, fOnProgress);
+					})
+				.catch(
+					(pError) =>
+					{
+						return fCallback(pError);
+					});
+			return;
+		}
+
+		// Already a Buffer, string, or stream — proceed directly
+		return this._executeBinaryUploadInternal(pOptions, fCallback, fOnProgress);
+	}
+
+	/**
+	 * Internal binary upload implementation using simple-get.
+	 *
+	 * @param {Record<string, any>} pOptions - Request options with body already as Buffer
+	 * @param {(pError?: Error, pResponse: any, pBody?: any) => void} fCallback - Callback (pError, pResponse, pBody)
+	 * @param {(pProgress: number) => void} [fOnProgress] - Optional progress callback (0.0 to 1.0); called with 1.0 on completion
+	 * @private
+	 */
+	_executeBinaryUploadInternal(pOptions, fCallback, fOnProgress)
+	{
+		let tmpOptions = this.preRequest(pOptions);
+
+		tmpOptions.RequestStartTime = this.fable.log.getTimeStamp();
+
+		if (this.TraceLog)
+		{
+			this.fable.log.debug(`Beginning ${tmpOptions.method} binary upload to ${tmpOptions.url} at ${tmpOptions.RequestStartTime}`);
+		}
+
+		tmpOptions.json = false;
+
+		return libSimpleGet(tmpOptions,
+			(pError, pResponse) =>
+			{
+				if (pError)
+				{
+					return fCallback(pError, pResponse);
+				}
+
+				if (this.TraceLog)
+				{
+					let tmpConnectTime = this.fable.log.getTimeStamp();
+					this.fable.log.debug(`--> Binary upload ${tmpOptions.method} connected in ${this.dataFormat.formatTimeDelta(tmpOptions.RequestStartTime, tmpConnectTime)}ms code ${pResponse.statusCode}`);
+				}
+
+				let tmpData = '';
+
+				pResponse.on('data', (pChunk) =>
+					{
+						if (this.TraceLog)
+						{
+							let tmpChunkTime = this.fable.log.getTimeStamp();
+							this.fable.log.debug(`--> Binary upload ${tmpOptions.method} response chunk size ${pChunk.length}b received in ${this.dataFormat.formatTimeDelta(tmpOptions.RequestStartTime, tmpChunkTime)}ms`);
+						}
+						tmpData += pChunk;
+					});
+
+				pResponse.on('end', () =>
+					{
+						if (this.TraceLog)
+						{
+							let tmpCompletionTime = this.fable.log.getTimeStamp();
+							this.fable.log.debug(`==> Binary upload ${tmpOptions.method} completed in ${this.dataFormat.formatTimeDelta(tmpOptions.RequestStartTime, tmpCompletionTime)}ms`);
+						}
+						// Signal completion via progress callback
+						if (typeof fOnProgress === 'function')
+						{
+							fOnProgress(1.0);
+						}
+						return fCallback(pError, pResponse, tmpData);
+					});
+			});
+	}
+
 	getRawText(pOptionsOrURL, fCallback)
 	{
 		let tmpRequestOptions = (typeof(pOptionsOrURL) == 'object') ? pOptionsOrURL : {};