strnum 1.0.4 → 1.1.0

package/.vscode/launch.json

@@ -0,0 +1,25 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Jasmine Tests",
+            "program": "${workspaceFolder}/node_modules/jasmine/bin/jasmine.js",
+            "args": [
+                "${workspaceFolder}/spec/attr_spec.js"
+            ],
+            "internalConsoleOptions": "openOnSessionStart"
+        },{
+            "type": "node",
+            "request": "launch",
+            "name": "Jasmine Tests current test file",
+            "program": "${workspaceFolder}/node_modules/jasmine/bin/jasmine.js",
+            "args": [
+                "${file}"
+            ],
+            "internalConsoleOptions": "openOnSessionStart"
+        }
+    ]
+   
+}

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+
+**1.1.0 / 2025-02-20**
+- fix (#9): support missing floating point and e notations

package/README.md

@@ -1,6 +1,16 @@
 # strnum
 Parse string into Number based on configuration
 
+## Users
+
+<a href="https://github.com/aws-amplify" target="_blank"><img src="https://avatars.githubusercontent.com/u/41077760?s=100&v=4"></a>
+<a href="https://github.com/astrapay" target="_blank"><img src="https://avatars.githubusercontent.com/u/90901882?s=100&v=4"></a>
+<a href="https://github.com/process-analytics" target="_blank"><img src="https://avatars.githubusercontent.com/u/60110287?s=100&v=4"></a>
+<a href="https://github.com/NaturalIntelligence" target="_blank"><img src="https://avatars.githubusercontent.com/u/16322633?s=100&v=4"></a>
+Many React Native projects and plugins
+
+## Usage
+
 ```bash
 npm install strnum
 ```
@@ -76,4 +86,12 @@ toNumber("1.0e-2"); //0.01)
 
 toNumber("+1212121212"); // 1212121212
 toNumber("+1212121212", { skipLike: /\+[0-9]{10}/} )); //"+1212121212"
-```
+```
+
+Supported Options
+```js
+hex: true,          //when hexadecimal string should be parsed
+leadingZeros: true, //when number with leading zeros like 08 should be parsed. 0.0 is not impacted
+eNotation: true,    //when number with eNotation or number parsed in eNotation should be considered
+skipLike: /regex/   //when string should not be parsed when it matches the specified regular expression
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "strnum",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "Parse String to Number based on configuration",
   "main": "strnum.js",
   "scripts": {
@@ -17,5 +17,8 @@
     "url": "https://github.com/NaturalIntelligence/strnum"
   },
   "author": "Amit Gupta (https://amitkumargupta.work/)",
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "jasmine": "^3.10.0"
+  }
 }

package/strnum.js

@@ -1,50 +1,106 @@
 const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
-const numRegex = /^([\-\+])?(0*)(\.[0-9]+([eE]\-?[0-9]+)?|[0-9]+(\.[0-9]+([eE]\-?[0-9]+)?)?)$/;
-// const octRegex = /0x[a-z0-9]+/;
+const numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
+// const octRegex = /^0x[a-z0-9]+/;
 // const binRegex = /0x[a-z0-9]+/;
 
+ 
 const consider = {
     hex :  true,
+    // oct: false,
     leadingZeros: true,
     decimalPoint: "\.",
+    eNotation: true,
     //skipLike: /regex/
 };
 
 function toNumber(str, options = {}){
-    // const options = Object.assign({}, consider);
-    // if(opt.leadingZeros === false){
-    //     options.leadingZeros = false;
-    // }else if(opt.hex === false){
-    //     options.hex = false;
-    // }
-
     options = Object.assign({}, consider, options );
     if(!str || typeof str !== "string" ) return str;
     
     let trimmedStr  = str.trim();
-    
+
     if(options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;
     else if (options.hex && hexRegex.test(trimmedStr)) {
-        return Number.parseInt(trimmedStr, 16);
-    // } else if (options.parseOct && octRegex.test(str)) {
+        return parse_int(trimmedStr, 16);
+    // }else if (options.oct && octRegex.test(str)) {
     //     return Number.parseInt(val, 8);
+    }else if (trimmedStr.search(/[eE]/)!== -1) { //eNotation
+        const notation = trimmedStr.match(/^([-\+])?(0*)([0-9]*(\.[0-9]*)?[eE][-\+]?[0-9]+)/); 
+        // +00.123 => [ , '+', '00', '.123', ..
+        if(notation){
+            if(options.leadingZeros){ //accept with leading zeros
+                trimmedStr = (notation[1] || "") + notation[3];
+            }else{
+                if(notation[2] === "0" && notation[3][0]=== "."){ //valid number
+                }else{
+                    return trimmedStr;
+                }
+            }
+            return options.eNotation ? Number(trimmedStr) : trimmedStr;
+        }else{
+            return trimmedStr;
+        }
     // }else if (options.parseBin && binRegex.test(str)) {
     //     return Number.parseInt(val, 2);
     }else{
         //separate negative sign, leading zeros, and rest number
         const match = numRegex.exec(trimmedStr);
+        // +00.123 => [ , '+', '00', '.123', ..
         if(match){
-            const negative = match[1];
+            const sign = match[1];
             const leadingZeros = match[2];
-            const num = match[3]; //complete num
-            const eNotation = match[4] || match[6];
-            if(leadingZeros.length === 1 && num[0] === ".") return Number(str);
-            else if(!options.leadingZeros && leadingZeros.length > 0) return str;
-            else return Number(trimmedStr);
+            let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros
+            //trim ending zeros for floating number
+            
+            if(!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".") return str; //-0123
+            else if(!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".") return str; //0123
+            else{//no leading zeros or leading zeros are allowed
+                const num = Number(trimmedStr);
+                const numStr = "" + num;
+
+                if(numStr.search(/[eE]/) !== -1){ //given number is long and parsed to eNotation
+                    if(options.eNotation) return num;
+                    else return str;
+                }else if(trimmedStr.indexOf(".") !== -1){ //floating number
+                    if(numStr === "0" && (numTrimmedByZeros === "") ) return num; //0.0
+                    else if(numStr === numTrimmedByZeros) return num; //0.456. 0.79000
+                    else if( sign && numStr === "-"+numTrimmedByZeros) return num;
+                    else return str;
+                }
+                
+                if(leadingZeros){
+                    return (numTrimmedByZeros === numStr) || (sign+numTrimmedByZeros === numStr) ? num : str
+                }else  {
+                    return (trimmedStr === numStr) || (trimmedStr === sign+numStr) ? num : str
+                }
+            }
         }else{ //non-numeric string
             return str;
         }
     }
 }
 
+/**
+ * 
+ * @param {string} numStr without leading zeros
+ * @returns 
+ */
+function trimZeros(numStr){
+    if(numStr && numStr.indexOf(".") !== -1){//float
+        numStr = numStr.replace(/0+$/, ""); //remove ending zeros
+        if(numStr === ".")  numStr = "0";
+        else if(numStr[0] === ".")  numStr = "0"+numStr;
+        else if(numStr[numStr.length-1] === ".")  numStr = numStr.substr(0,numStr.length-1);
+        return numStr;
+    }
+    return numStr;
+}
+
+function parse_int(numStr, base){
+    //polyfill
+    if(parseInt) return parseInt(numStr, base);
+    else if(Number.parseInt) return Number.parseInt(numStr, base);
+    else if(window && window.parseInt) return window.parseInt(numStr, base);
+    else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported")
+}
 module.exports = toNumber

package/strnum.test.js

@@ -15,6 +15,7 @@ describe("Should convert all the valid numeric strings to number", () => {
     })
     it("should consider + sign", () => {
         expect(toNumber("+12")).toEqual(12);
+        expect(toNumber("+ 12")).toEqual("+ 12");
         expect(toNumber("12+12")).toEqual("12+12");
         expect(toNumber("1212+")).toEqual("1212+");
     })
@@ -40,9 +41,22 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber("006")).toEqual(6);
         expect(toNumber("006", { leadingZeros :  true})).toEqual(6);
         expect(toNumber("006", { leadingZeros :  false})).toEqual("006");
+
+        expect(toNumber("000000000000000000000000017717"  ,  { leadingZeros :  false})).toEqual("000000000000000000000000017717");
+        expect(toNumber("000000000000000000000000017717"  ,  { leadingZeros :  true})).toEqual(17717);
+        expect(toNumber("020211201030005811824")  ).toEqual("020211201030005811824");
+        expect(toNumber("0420926189200190257681175017717")  ).toEqual(4.209261892001902e+29);
     })
+    it("invalid floating number", () => {
+        expect(toNumber("20.21.030")  ).toEqual("20.21.030");
+        expect(toNumber("0.21.030")  ).toEqual("0.21.030");
+        expect(toNumber("0.21.")  ).toEqual("0.21.");
+        expect(toNumber("0.")).toEqual(0);
+        expect(toNumber("+0.")).toEqual(0);
+        expect(toNumber("-0.")).toEqual(-0);
+        expect(toNumber("1.")  ).toEqual(1);
+    });
     it("floating point and leading zeros", () => {
-        expect(toNumber("0.0")).toEqual(0);
         expect(toNumber("00.00")).toEqual(0);
         expect(toNumber("0.06")).toEqual(0.06);
         expect(toNumber("00.6")).toEqual(0.6);
@@ -59,6 +73,7 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber("06.0"  ,  { leadingZeros :  false})).toEqual("06.0");
     })
     it("negative number  leading zeros", () => {
+        expect(toNumber("+06")).toEqual(6);
         expect(toNumber("-06")).toEqual(-6);
         expect(toNumber("-06", { leadingZeros :  true})).toEqual(-6);
         expect(toNumber("-06", { leadingZeros :  false})).toEqual("-06");
@@ -80,9 +95,10 @@ describe("Should convert all the valid numeric strings to number", () => {
         expect(toNumber("-06.0"  ,  { leadingZeros :  false})).toEqual("-06.0");
     })
     it("long number", () => {
-        expect(toNumber("420926189200190257681175017717")  ).toEqual(4.209261892001902e+29);
-        expect(toNumber("000000000000000000000000017717"  ,  { leadingZeros :  false})).toEqual("000000000000000000000000017717");
-        expect(toNumber("000000000000000000000000017717"  ,  { leadingZeros :  true})).toEqual(17717);
+        expect(toNumber("020211201030005811824")  ).toEqual("020211201030005811824");
+        expect(toNumber("20211201030005811824")  ).toEqual("20211201030005811824");
+        expect(toNumber("20.211201030005811824")  ).toEqual("20.211201030005811824");
+        expect(toNumber("0.211201030005811824")  ).toEqual("0.211201030005811824");
     });
     it("scientific notation", () => {
         expect(toNumber("01.0e2"  ,  { leadingZeros :  false})).toEqual("01.0e2");
@@ -93,6 +109,13 @@ describe("Should convert all the valid numeric strings to number", () => {
 
         expect(toNumber("-1.0e2") ).toEqual(-100);
         expect(toNumber("1.0e-2")).toEqual(0.01);
+        
+        expect(toNumber("420926189200190257681175017717")  ).toEqual(4.209261892001902e+29);
+        expect(toNumber("420926189200190257681175017717" , { eNotation: false} )).toEqual("420926189200190257681175017717");
+        
+        expect(toNumber("1e-2")).toEqual(0.01);
+        expect(toNumber("1e+2")).toEqual(100);
+        expect(toNumber("1.e+2")).toEqual(100);
     });
 
     it("scientific notation with upper E", () => {
@@ -120,4 +143,12 @@ describe("Should convert all the valid numeric strings to number", () => {
     it("should ignore sorrounded spaces ", () => {
         expect(toNumber("   +1212   ")).toEqual(1212);
     })
+    
+    it("negative numbers", () => {
+        expect(toNumber("+1212")).toEqual(1212);
+        expect(toNumber("+12.12")).toEqual(12.12);
+        expect(toNumber("-12.12")).toEqual(-12.12);
+        expect(toNumber("-012.12")).toEqual(-12.12);
+        expect(toNumber("-012.12")).toEqual(-12.12);
+    })
 });

package/test.js

@@ -0,0 +1,6 @@
+const toNumber = require("./strnum");
+
+// console.log(toNumber("01.0e2"))
+console.log(toNumber("-06"))
+// console.log(toNumber("+01.0e2"))
+// console.log(toNumber("+001.0e2"))