fable 3.1.61 → 3.1.63

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "fable",
-  "version": "3.1.61",
+  "version": "3.1.63",
   "description": "A service dependency injection, configuration and logging library.",
   "main": "source/Fable.js",
   "scripts": {
     "start": "node source/Fable.js",
-    "coverage": "./node_modules/.bin/nyc --reporter=lcov --reporter=text-lcov ./node_modules/mocha/bin/_mocha -- -u tdd -R spec",
-    "test": "./node_modules/.bin/mocha -u tdd -R spec",
+    "coverage": "npx quack coverage",
+    "test": "npx quack test",
     "build": "npx quack build",
     "docker-dev-build": "docker build ./ -f Dockerfile_LUXURYCode -t fable-image:local",
     "docker-dev-run": "docker run -it -d --name fable-dev -p 30001:8080 -p 38086:8086 -v \"$PWD/.config:/home/coder/.config\"  -v \"$PWD:/home/coder/fable\" -u \"$(id -u):$(id -g)\" -e \"DOCKER_USER=$USER\" fable-image:local",
     "docker-dev-shell": "docker exec -it fable-dev /bin/bash",
-    "tests": "./node_modules/mocha/bin/_mocha -u tdd --exit -R spec --grep"
+    "tests": "npx quack test -g"
   },
   "mocha": {
     "diff": true,
@@ -50,21 +50,21 @@
   },
   "homepage": "https://github.com/stevenvelozo/fable",
   "devDependencies": {
-    "quackage": "^1.0.56"
+    "quackage": "^1.0.58"
   },
   "dependencies": {
     "async.eachlimit": "^0.5.2",
     "async.waterfall": "^0.5.2",
     "big.js": "^7.0.1",
-    "cachetrax": "^1.0.5",
+    "cachetrax": "^1.0.6",
     "cookie": "^1.1.1",
     "data-arithmatic": "^1.0.7",
     "dayjs": "^1.11.19",
-    "fable-log": "^3.0.17",
-    "fable-serviceproviderbase": "^3.0.18",
-    "fable-settings": "^3.0.15",
-    "fable-uuid": "^3.0.12",
-    "manyfest": "^1.0.47",
+    "fable-log": "^3.0.18",
+    "fable-serviceproviderbase": "^3.0.19",
+    "fable-settings": "^3.0.16",
+    "fable-uuid": "^3.0.13",
+    "manyfest": "^1.0.48",
     "simple-get": "^4.0.1"
   }
 }

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

@@ -1864,24 +1864,95 @@ class FableServiceMath extends libFableServiceBase
 			}, pRegressionCoefficients[0]);
 	}
 
+	/**
+	 * Resolves paired Y/X value arrays from flexible argument patterns.
+	 *
+	 * The expression parser's SetConcatArray spreads comma-separated arguments
+	 * as individual function parameters.  This helper normalizes three calling
+	 * conventions into a clean paired-value result:
+	 *
+	 *   1. Two arrays:  SLOPE(yArray, xArray)
+	 *   2. Spread scalars:  SLOPE(y1,y2,...,yN, x1,x2,...,xN) — split in half
+	 *   3. One flat array:  SLOPE([y1,...,yN,x1,...,xN]) — split in half
+	 *
+	 * Non-numeric values are filtered; only pairs where both Y and X parse
+	 * are kept.
+	 *
+	 * @param {...*} pArguments - Flexible: (yArr, xArr) | (y1,y2,...,x1,x2,...) | (flatArr)
+	 *
+	 * @return {Object} { cleanX, cleanY, n }
+	 */
+	cleanPairedValues(...pArguments)
+	{
+		let tmpYValues;
+		let tmpXValues;
+
+		if (pArguments.length === 2 && Array.isArray(pArguments[0]) && Array.isArray(pArguments[1]))
+		{
+			// Two arrays: SLOPE(yArray, xArray)
+			tmpYValues = pArguments[0];
+			tmpXValues = pArguments[1];
+		}
+		else if (pArguments.length === 1 && Array.isArray(pArguments[0]))
+		{
+			// Single flat array — split in half
+			let tmpFlat = pArguments[0];
+			let tmpHalf = Math.floor(tmpFlat.length / 2);
+			tmpYValues = tmpFlat.slice(0, tmpHalf);
+			tmpXValues = tmpFlat.slice(tmpHalf);
+		}
+		else if (pArguments.length > 2)
+		{
+			// Many spread scalars from expression parser — split in half
+			let tmpHalf = Math.floor(pArguments.length / 2);
+			tmpYValues = pArguments.slice(0, tmpHalf);
+			tmpXValues = pArguments.slice(tmpHalf);
+		}
+		else
+		{
+			// Two scalars or other degenerate input
+			tmpYValues = Array.isArray(pArguments[0]) ? pArguments[0] : [pArguments[0]];
+			tmpXValues = Array.isArray(pArguments[1]) ? pArguments[1] : [pArguments[1]];
+		}
+
+		let tmpPairCount = Math.min(tmpYValues.length, tmpXValues.length);
+
+		let tmpCleanX = [];
+		let tmpCleanY = [];
+
+		for (let i = 0; i < tmpPairCount; i++)
+		{
+			let tmpX = this.parsePrecise(tmpXValues[i], NaN);
+			let tmpY = this.parsePrecise(tmpYValues[i], NaN);
+			if (!isNaN(tmpX) && !isNaN(tmpY))
+			{
+				tmpCleanX.push(tmpX);
+				tmpCleanY.push(tmpY);
+			}
+		}
+
+		return { cleanX: tmpCleanX, cleanY: tmpCleanY, n: tmpCleanX.length };
+	}
+
 	/**
 	 * Calculates the slope of a linear regression line through paired data points.
 	 * Equivalent to Excel's SLOPE function.
 	 *
 	 * Formula: slope = (n * Σ(xy) - Σx * Σy) / (n * Σ(x²) - (Σx)²)
 	 *
-	 * @param {Array<number|string>} pYValues - The dependent data points (known y's).
-	 * @param {Array<number|string>} pXValues - The independent data points (known x's).
+	 * Calling conventions (all work through the expression parser):
+	 *   SLOPE(yArray, xArray)                — two resolved arrays
+	 *   SLOPE(y1,y2,...,yN, x1,x2,...,xN)    — inline scalars, split in half
+	 *
+	 * @param {...*} pArguments - Y values followed by X values (see cleanPairedValues).
 	 *
 	 * @return {string} The slope of the regression line.
 	 */
-	slopePrecise(pYValues, pXValues)
+	slopePrecise(...pArguments)
 	{
-		let tmpYValues = Array.isArray(pYValues) ? pYValues : [pYValues];
-		let tmpXValues = Array.isArray(pXValues) ? pXValues : [pXValues];
-		let tmpN = Math.min(tmpYValues.length, tmpXValues.length);
+		let tmpPaired = this.cleanPairedValues(...pArguments);
 
-		if (tmpN < 2)
+		if (tmpPaired.n < 2)
 		{
 			return '0';
 		}
@@ -1891,23 +1962,17 @@ class FableServiceMath extends libFableServiceBase
 		let tmpSumXY = '0';
 		let tmpSumX2 = '0';
 
-		for (let i = 0; i < tmpN; i++)
+		for (let i = 0; i < tmpPaired.n; i++)
 		{
-			let tmpX = this.parsePrecise(tmpXValues[i], NaN);
-			let tmpY = this.parsePrecise(tmpYValues[i], NaN);
-			if (isNaN(tmpX) || isNaN(tmpY))
-			{
-				continue;
-			}
-			tmpSumX = this.addPrecise(tmpSumX, tmpX);
-			tmpSumY = this.addPrecise(tmpSumY, tmpY);
-			tmpSumXY = this.addPrecise(tmpSumXY, this.multiplyPrecise(tmpX, tmpY));
-			tmpSumX2 = this.addPrecise(tmpSumX2, this.multiplyPrecise(tmpX, tmpX));
+			tmpSumX = this.addPrecise(tmpSumX, tmpPaired.cleanX[i]);
+			tmpSumY = this.addPrecise(tmpSumY, tmpPaired.cleanY[i]);
+			tmpSumXY = this.addPrecise(tmpSumXY, this.multiplyPrecise(tmpPaired.cleanX[i], tmpPaired.cleanY[i]));
+			tmpSumX2 = this.addPrecise(tmpSumX2, this.multiplyPrecise(tmpPaired.cleanX[i], tmpPaired.cleanX[i]));
 		}
 
 		// slope = (n * Σ(xy) - Σx * Σy) / (n * Σ(x²) - (Σx)²)
-		let tmpNumerator = this.subtractPrecise(this.multiplyPrecise(tmpN, tmpSumXY), this.multiplyPrecise(tmpSumX, tmpSumY));
-		let tmpDenominator = this.subtractPrecise(this.multiplyPrecise(tmpN, tmpSumX2), this.multiplyPrecise(tmpSumX, tmpSumX));
+		let tmpNumerator = this.subtractPrecise(this.multiplyPrecise(tmpPaired.n, tmpSumXY), this.multiplyPrecise(tmpSumX, tmpSumY));
+		let tmpDenominator = this.subtractPrecise(this.multiplyPrecise(tmpPaired.n, tmpSumX2), this.multiplyPrecise(tmpSumX, tmpSumX));
 
 		if (this.comparePrecise(tmpDenominator, 0) == 0)
 		{
@@ -1923,19 +1988,21 @@ class FableServiceMath extends libFableServiceBase
 	 *
 	 * Formula: intercept = ȳ - slope * x̄
 	 *
-	 * @param {Array<number|string>} pYValues - The dependent data points (known y's).
-	 * @param {Array<number|string>} pXValues - The independent data points (known x's).
+	 * Calling conventions (all work through the expression parser):
+	 *   INTERCEPT(yArray, xArray)                — two resolved arrays
+	 *   INTERCEPT(y1,y2,...,yN, x1,x2,...,xN)    — inline scalars, split in half
+	 *
+	 * @param {...*} pArguments - Y values followed by X values (see cleanPairedValues).
 	 *
 	 * @return {string} The y-intercept of the regression line.
 	 */
-	interceptPrecise(pYValues, pXValues)
+	interceptPrecise(...pArguments)
 	{
-		let tmpYValues = Array.isArray(pYValues) ? pYValues : [pYValues];
-		let tmpXValues = Array.isArray(pXValues) ? pXValues : [pXValues];
+		let tmpPaired = this.cleanPairedValues(...pArguments);
 
-		let tmpSlope = this.slopePrecise(tmpYValues, tmpXValues);
-		let tmpMeanY = this.meanPrecise(tmpYValues);
-		let tmpMeanX = this.meanPrecise(tmpXValues);
+		let tmpSlope = this.slopePrecise(tmpPaired.cleanY, tmpPaired.cleanX);
+		let tmpMeanY = this.meanPrecise(tmpPaired.cleanY);
+		let tmpMeanX = this.meanPrecise(tmpPaired.cleanX);
 
 		// intercept = ȳ - slope * x̄
 		return this.subtractPrecise(tmpMeanY, this.multiplyPrecise(tmpSlope, tmpMeanX));

package/test/ExpressionParser_tests.js

@@ -1336,10 +1336,38 @@ suite
 									_Parser.solve('InterceptResult = INTERCEPT(AppData.YData, AppData.XData)', testFable, tmpSolverResult, false, tmpSolverResult);
 									Expect(tmpSolverResult.InterceptResult).to.equal('1');
 
-									// Solver with inline sets
+									// Solver with inline scalars (split in half: first 5 = Y, last 5 = X)
 									let tmpInlineResult = {};
 									_Parser.solve('InlineSlope = SLOPE(3,5,7,9,11, 1,2,3,4,5)', testFable, tmpInlineResult, false, tmpInlineResult);
-									testFable.log.info('Inline slope result:', tmpInlineResult.InlineSlope);
+									Expect(tmpInlineResult.InlineSlope).to.equal('2');
+
+									_Parser.solve('InlineIntercept = INTERCEPT(3,5,7,9,11, 1,2,3,4,5)', testFable, tmpInlineResult, false, tmpInlineResult);
+									Expect(tmpInlineResult.InlineIntercept).to.equal('1');
+
+									// Solver chain: SERIES produces string arrays, then SLOPE/INTERCEPT consume them
+									let tmpChainData = {};
+									_Parser.solve('XValues = SERIES FROM 1 TO 5 STEP 1 : n + 0', tmpChainData, {}, false, tmpChainData);
+									_Parser.solve('YValues = SERIES FROM 1 TO 5 STEP 1 : 2 * n + 1', tmpChainData, {}, false, tmpChainData);
+									// Verify the arrays are string-typed (expression parser produces strings)
+									Expect(tmpChainData.XValues[0]).to.equal('1');
+									Expect(typeof tmpChainData.XValues[0]).to.equal('string');
+									Expect(tmpChainData.YValues[0]).to.equal('3');
+									Expect(typeof tmpChainData.YValues[0]).to.equal('string');
+
+									_Parser.solve('ChainSlope = SLOPE(YValues, XValues)', tmpChainData, {}, false, tmpChainData);
+									Expect(tmpChainData.ChainSlope).to.equal('2');
+
+									_Parser.solve('ChainIntercept = INTERCEPT(YValues, XValues)', tmpChainData, {}, false, tmpChainData);
+									Expect(tmpChainData.ChainIntercept).to.equal('1');
+
+									// String arrays at AppData addresses
+									testFable.AppData.XStrings = ['1', '2', '3', '4', '5'];
+									testFable.AppData.YStrings = ['3', '5', '7', '9', '11'];
+									_Parser.solve('StringSlope = SLOPE(AppData.YStrings, AppData.XStrings)', testFable, tmpSolverResult, false, tmpSolverResult);
+									Expect(tmpSolverResult.StringSlope).to.equal('2');
+
+									_Parser.solve('StringIntercept = INTERCEPT(AppData.YStrings, AppData.XStrings)', testFable, tmpSolverResult, false, tmpSolverResult);
+									Expect(tmpSolverResult.StringIntercept).to.equal('1');
 
 									// Solver with non-perfect data
 									testFable.AppData.YData2 = [2, 4, 5, 4, 5];
@@ -1350,12 +1378,8 @@ suite
 									Expect(Number(tmpSolverResult.Intercept2)).to.be.closeTo(2.2, 0.0001);
 
 									// Verify slope and intercept reconstruct the regression line
-									// y_predicted = intercept + slope * x
-									for (let i = 0; i < tmpXValues2.length; i++)
-									{
-										let tmpPredicted = testFable.Math.addPrecise(tmpSolverResult.Intercept2, testFable.Math.multiplyPrecise(tmpSolverResult.Slope2, tmpXValues2[i]));
-										testFable.log.info(`x=${tmpXValues2[i]}, y=${tmpYValues2[i]}, predicted=${tmpPredicted}`);
-									}
+									_Parser.solve('Predicted = ChainIntercept + ChainSlope * 6', tmpChainData, {}, false, tmpChainData);
+									Expect(tmpChainData.Predicted).to.equal('13');
 								}
 							);
 					}

package/.babelrc

@@ -1,3 +0,0 @@
-{
-	"presets": ["@babel/preset-env"]
-}

package/.browserslistrc

@@ -1 +0,0 @@
-since 2020