refactor: replace primitive string throws with Error objects (#6602)

gcharpe1604 · web-flow · commit 3f3107173872 · 2026-04-14T20:50:28.000-04:00
Standardized error handling in math utilities, pitch actions, and
program blocks by replacing string throws with standard Error objects.
Updated NumberBlocks catch sites and unit tests to handle the new
Error object format.

Reference: Linked to issue created by user.
diff --git a/js/blocks/NumberBlocks.js b/js/blocks/NumberBlocks.js
@@ -307,9 +307,9 @@ function setupNumberBlocks(activity) {
                 return MathUtility.doSqrt(a);
             } catch (e) {
                 logo.stopTurtle = true;
-                if (e === "NanError") {
+                if (e.message === "NanError") {
                     activity.errorMsg(NANERRORMSG, blk);
-                } else if (e === "NoSqrtError") {
+                } else if (e.message === "NoSqrtError") {
                     activity.errorMsg(NOSQRTERRORMSG, blk);
                     return MathUtility.doSqrt(-a);
                 }
@@ -464,9 +464,9 @@ function setupNumberBlocks(activity) {
                 return MathUtility.doDivide(a, b);
             } catch (e) {
                 logo.stopTurtle = true;
-                if (e === "NanError") {
+                if (e.message === "NanError") {
                     activity.errorMsg(NANERRORMSG, blk);
-                } else if (e === "DivByZeroError") {
+                } else if (e.message === "DivByZeroError") {
                     activity.errorMsg(ZERODIVIDEERRORMSG, blk);
                 }
                 return 0;
@@ -785,9 +785,9 @@ function setupNumberBlocks(activity) {
                     return MathUtility.doPlus(a, b);
                 } catch (e) {
                     activity.errorMsg(NOINPUTERRORMSG, blk);
-                    // eslint-disable-next-line no-console
+
                     console.debug(a + " " + b);
-                    // eslint-disable-next-line no-console
+
                     console.debug(e);
                     if (!isNaN(a)) {
                         return a;
diff --git a/js/blocks/ProgramBlocks.js b/js/blocks/ProgramBlocks.js
@@ -253,7 +253,7 @@ function setupProgramBlocks(activity) {
                             activity.blocks.blockList[c].value[1]
                         );
                         if (!Array.isArray(logo.turtleHeaps[turtle])) {
-                            throw "is not array";
+                            throw new Error("is not array");
                         }
                     } catch (e) {
                         logo.turtleHeaps[turtle] = oldHeap;
@@ -324,7 +324,7 @@ function setupProgramBlocks(activity) {
                 try {
                     logo.turtleHeaps[turtle] = JSON.parse(activity.blocks.blockList[c].value);
                     if (!Array.isArray(logo.turtleHeaps[turtle])) {
-                        throw "is not array";
+                        throw new Error("is not array");
                     }
                 } catch (e) {
                     logo.turtleHeaps[turtle] = oldHeap;
diff --git a/js/blocks/__tests__/NumberBlocks.test.js b/js/blocks/__tests__/NumberBlocks.test.js
@@ -131,13 +131,13 @@ global.MathUtility = {
     doMod: (a, b) => Number(a) % Number(b),
     doPower: (a, b) => Math.pow(Number(a), Number(b)),
     doSqrt: a => {
-        if (Number(a) < 0) throw "NoSqrtError";
+        if (Number(a) < 0) throw new Error("NoSqrtError");
         return Math.sqrt(Number(a));
     },
     doAbs: a => Math.abs(Number(a)),
     doCalculateDistance: (x1, y1, x2, y2) => Math.hypot(x2 - x1, y2 - y1),
     doDivide: (a, b) => {
-        if (Number(b) === 0) throw "DivByZeroError";
+        if (Number(b) === 0) throw new Error("DivByZeroError");
         return Number(a) / Number(b);
     },
     doMultiply: (a, b) => Number(a) * Number(b),
@@ -320,7 +320,7 @@ describe("setupNumberBlocks", () => {
             activity.blocks.blockList[130] = { connections: [null, "c1"] };
             logo.parseArg = jest.fn(() => -9);
             global.MathUtility.doSqrt = a => {
-                if (Number(a) < 0) throw "NoSqrtError";
+                if (Number(a) < 0) throw new Error("NoSqrtError");
                 return Math.sqrt(Number(a));
             };
             const sqrtBlock = createdBlocks["sqrt"];
@@ -332,7 +332,7 @@ describe("setupNumberBlocks", () => {
             activity.blocks.blockList[130] = { connections: [null, "c1"] };
             logo.parseArg = jest.fn(() => "bad");
             global.MathUtility.doSqrt = () => {
-                throw "NanError";
+                throw new Error("NanError");
             };
             const sqrtBlock = createdBlocks["sqrt"];
             const result = sqrtBlock.arg(logo, 0, 130, null);
@@ -396,14 +396,14 @@ describe("setupNumberBlocks", () => {
             activity.blocks.blockList[160] = { connections: [null, "c1", "c2"] };
             logo.parseArg = jest.fn(() => 5);
             global.MathUtility.doDivide = () => {
-                throw "NanError";
+                throw new Error("NanError");
             };
             const divideBlock = createdBlocks["divide"];
             const result = divideBlock.arg(logo, 0, 160, null);
             expect(activity.errorMsg).toHaveBeenCalledWith(global.NANERRORMSG, 160);
             expect(result).toEqual(0);
             global.MathUtility.doDivide = (a, b) => {
-                if (Number(b) === 0) throw "DivByZeroError";
+                if (Number(b) === 0) throw new Error("DivByZeroError");
                 return Number(a) / Number(b);
             };
         });
diff --git a/js/turtleactions/PitchActions.js b/js/turtleactions/PitchActions.js
@@ -573,7 +573,7 @@ function setupPitchActions(activity) {
                     return obj[1];
                 }
             } else {
-                throw "NoArgError";
+                throw new Error("NoArgError");
             }
         }
 
diff --git a/js/utils/mathutils.js b/js/utils/mathutils.js
@@ -102,7 +102,7 @@ class MathUtility {
         ) {
             return GetRandomSolfege(a, b, c);
         } else {
-            throw "NanError";
+            throw new Error("NanError");
         }
     }
 
@@ -149,12 +149,12 @@ class MathUtility {
     static doSqrt(a) {
         if (typeof a === "number") {
             if (a < 0) {
-                throw "NoSqrtError";
+                throw new Error("NoSqrtError");
             }
 
             return Math.sqrt(Number(a));
         } else {
-            throw "NanError";
+            throw new Error("NanError");
         }
     }
 
@@ -188,7 +188,7 @@ class MathUtility {
      */
     static doMinus(a, b) {
         if (typeof a === "string" || typeof b === "string") {
-            throw "NanError";
+            throw new Error("NanError");
         }
 
         return Number(a) - Number(b);
@@ -205,7 +205,7 @@ class MathUtility {
      */
     static doMultiply(a, b) {
         if (typeof a === "string" || typeof b === "string") {
-            throw "NanError";
+            throw new Error("NanError");
         }
 
         return Number(a) * Number(b);
@@ -223,12 +223,12 @@ class MathUtility {
     static doDivide(a, b) {
         if (typeof a === "number" && typeof b === "number") {
             if (Number(b) === 0) {
-                throw "DivByZeroError";
+                throw new Error("DivByZeroError");
             }
 
             return Number(a) / Number(b);
         } else {
-            throw "NanError";
+            throw new Error("NanError");
         }
     }
 
@@ -256,7 +256,7 @@ class MathUtility {
 
             return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
         } else {
-            throw "NanError";
+            throw new Error("NanError");
         }
     }
 
@@ -273,7 +273,7 @@ class MathUtility {
         if (typeof a === "number" && typeof b === "number") {
             return Math.pow(a, b);
         } else {
-            throw "NanError";
+            throw new Error("NanError");
         }
     }
 
@@ -289,7 +289,7 @@ class MathUtility {
         if (typeof a === "number") {
             return Math.abs(a);
         } else {
-            throw "NanError";
+            throw new Error("NanError");
         }
     }
 
@@ -308,7 +308,7 @@ class MathUtility {
             const obj = a.split("");
             return obj.reverse().join("");
         } else {
-            throw "NoNegError";
+            throw new Error("NoNegError");
         }
     }
 
@@ -324,7 +324,7 @@ class MathUtility {
         try {
             return Math.floor(Number(a) + 0.5);
         } catch (e) {
-            throw "NanError";
+            throw new Error("NanError");
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -573,7 +573,7 @@ function setupPitchActions(activity) {`
`573`	`573`	`return obj[1];`
`574`	`574`	`}`
`575`	`575`	`} else {`
`576`		`- throw "NoArgError";`
	`576`	`+ throw new Error("NoArgError");`
`577`	`577`	`}`
`578`	`578`	`}`
`579`	`579`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ class MathUtility {`
`102`	`102`	`) {`
`103`	`103`	`return GetRandomSolfege(a, b, c);`
`104`	`104`	`} else {`
`105`		`- throw "NanError";`
	`105`	`+ throw new Error("NanError");`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`
`@@ -149,12 +149,12 @@ class MathUtility {`
`149`	`149`	`static doSqrt(a) {`
`150`	`150`	`if (typeof a === "number") {`
`151`	`151`	`if (a < 0) {`
`152`		`- throw "NoSqrtError";`
	`152`	`+ throw new Error("NoSqrtError");`
`153`	`153`	`}`
`154`	`154`
`155`	`155`	`return Math.sqrt(Number(a));`
`156`	`156`	`} else {`
`157`		`- throw "NanError";`
	`157`	`+ throw new Error("NanError");`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`@@ -188,7 +188,7 @@ class MathUtility {`
`188`	`188`	`*/`
`189`	`189`	`static doMinus(a, b) {`
`190`	`190`	`if (typeof a === "string" \|\| typeof b === "string") {`
`191`		`- throw "NanError";`
	`191`	`+ throw new Error("NanError");`
`192`	`192`	`}`
`193`	`193`
`194`	`194`	`return Number(a) - Number(b);`
`@@ -205,7 +205,7 @@ class MathUtility {`
`205`	`205`	`*/`
`206`	`206`	`static doMultiply(a, b) {`
`207`	`207`	`if (typeof a === "string" \|\| typeof b === "string") {`
`208`		`- throw "NanError";`
	`208`	`+ throw new Error("NanError");`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`return Number(a) * Number(b);`
`@@ -223,12 +223,12 @@ class MathUtility {`
`223`	`223`	`static doDivide(a, b) {`
`224`	`224`	`if (typeof a === "number" && typeof b === "number") {`
`225`	`225`	`if (Number(b) === 0) {`
`226`		`- throw "DivByZeroError";`
	`226`	`+ throw new Error("DivByZeroError");`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`return Number(a) / Number(b);`
`230`	`230`	`} else {`
`231`		`- throw "NanError";`
	`231`	`+ throw new Error("NanError");`
`232`	`232`	`}`
`233`	`233`	`}`
`234`	`234`
`@@ -256,7 +256,7 @@ class MathUtility {`
`256`	`256`
`257`	`257`	`return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));`
`258`	`258`	`} else {`
`259`		`- throw "NanError";`
	`259`	`+ throw new Error("NanError");`
`260`	`260`	`}`
`261`	`261`	`}`
`262`	`262`
`@@ -273,7 +273,7 @@ class MathUtility {`
`273`	`273`	`if (typeof a === "number" && typeof b === "number") {`
`274`	`274`	`return Math.pow(a, b);`
`275`	`275`	`} else {`
`276`		`- throw "NanError";`
	`276`	`+ throw new Error("NanError");`
`277`	`277`	`}`
`278`	`278`	`}`
`279`	`279`
`@@ -289,7 +289,7 @@ class MathUtility {`
`289`	`289`	`if (typeof a === "number") {`
`290`	`290`	`return Math.abs(a);`
`291`	`291`	`} else {`
`292`		`- throw "NanError";`
	`292`	`+ throw new Error("NanError");`
`293`	`293`	`}`
`294`	`294`	`}`
`295`	`295`
`@@ -308,7 +308,7 @@ class MathUtility {`
`308`	`308`	`const obj = a.split("");`
`309`	`309`	`return obj.reverse().join("");`
`310`	`310`	`} else {`
`311`		`- throw "NoNegError";`
	`311`	`+ throw new Error("NoNegError");`
`312`	`312`	`}`
`313`	`313`	`}`
`314`	`314`
`@@ -324,7 +324,7 @@ class MathUtility {`
`324`	`324`	`try {`
`325`	`325`	`return Math.floor(Number(a) + 0.5);`
`326`	`326`	`} catch (e) {`
`327`		`- throw "NanError";`
	`327`	`+ throw new Error("NanError");`
`328`	`328`	`}`
`329`	`329`	`}`
`330`	`330`	`}`