jsuites 6.5.2 → 6.6.0

package/dist/jsuites.js

@@ -991,6 +991,8 @@ var jSuites;
         const methodCache = {};
         // Cache for getTokens results
         const tokensCache = {};
+        // Cache for the parsed layout of each mask
+        const layoutCache = {};
         // Cache for autoCasting results
         const autoCastingCache = {};
 
@@ -1752,32 +1754,33 @@ var jSuites;
             '#(.{1})##0?(.{1}[0#]+)?( ?;(.*)?)?': function(v) {
                 // Process first the number
                 parseMethods['[0#]+([.,]{1}0*#*)?'].call(this, v, true);
-                // Create the separators
-                let separator = this.tokens[this.index].substring(1,2);
-
 
                 let currentValue = this.values[this.index];
-                // Remove existing separators and negative sign
+                // The value is already grouped: only a new digit in the integer part changes it
+                if (! (v >= '0' && v <= '9') || currentValue.indexOf(this.decimal) !== -1) {
+                    return;
+                }
+                // Create the separators
+                let separator = this.tokens[this.index].substring(1,2);
+                // Remove existing separators
                 currentValue = currentValue.replaceAll(separator, '');
                 // Process separators
-                let val = currentValue.split(this.decimal);
-                if (val[0].length > 3) {
-                    let number = [];
+                if (currentValue.length > 3) {
+                    let number = '';
                     let count = 0;
-                    for (var j = val[0].length - 1; j >= 0 ; j--) {
-                        let c = val[0][j];
-                        if (c >= 0 && c <= 9) {
+                    for (let j = currentValue.length - 1; j >= 0 ; j--) {
+                        let c = currentValue[j];
+                        if (c >= '0' && c <= '9') {
                             if (count && ! (count % 3)) {
-                                number.unshift(separator);
+                                number = separator + number;
                             }
                             count++;
                         }
-                        number.unshift(c);
+                        number = c + number;
                     }
-                    val[0] = number.join('');
+                    currentValue = number;
                 }
-                // Reconstruct the value
-                this.values[this.index] = val.join(this.decimal);
+                this.values[this.index] = currentValue;
             },
             '[0#]+([.,]{1}0*#*)?E{1}\\+0+': function(v) {
                 parseMethods['[0#]+([.,]{1}0*#*)?'].call(this, v);
@@ -2260,6 +2263,26 @@ var jSuites;
 
         // TODO, get negative mask automatically based on the input sign?
 
+        /**
+         * Parse the parts of a mask that do not depend on the value
+         */
+        const getLayout = function(mask) {
+            const layout = {};
+            // Transform Excel locale patterns (e.g., [$$-409]#,##0.00) - only if pattern exists
+            if (mask.indexOf('[$') !== -1) {
+                mask = transformExcelLocaleMask(mask);
+            }
+            // Cleaning the mask
+            layout.mask = cleanMask(mask, layout);
+            // Get tokens which are the methods for parsing
+            layout.tokens = getTokens(layout.mask);
+            // Get methods from the tokens
+            layout.methods = getMethodsFromTokens(layout.tokens);
+            // Type
+            layout.type = getType(layout);
+            return layout;
+        }
+
         const getConfig = function(config, value) {
             // Internal default control of the mask system
             const control = {
@@ -2326,21 +2349,28 @@ var jSuites;
                     control.section = mask;
                 }
 
-                // Transform Excel locale patterns (e.g., [$$-409]#,##0.00) - only if pattern exists
-                if (mask.indexOf('[$') !== -1) {
-                    mask = transformExcelLocaleMask(mask);
+                // The layout depends only on the mask: parse it once
+                let layout = layoutCache[mask];
+                if (layout === undefined) {
+                    layout = layoutCache[mask] = getLayout(mask);
+                }
+                if (layout.parenthesisForNegativeNumbers) {
+                    control.parenthesisForNegativeNumbers = true;
                 }
-
-                // Cleaning the mask
-                mask = cleanMask(mask, control);
                 // Get only the first mask for now and remove
-                control.mask = mask;
-                // Get tokens which are the methods for parsing
-                let tokens = control.tokens = getTokens(mask);
-                // Get methods from the tokens
-                control.methods = getMethodsFromTokens(tokens);
-                // Type
-                control.type = getType(control);
+                control.mask = layout.mask;
+                // Tokens and methods are shared and read-only
+                control.tokens = layout.tokens;
+                control.methods = layout.methods;
+                control.type = layout.type;
+
+                // Decimal only for numbers. Without options, it comes from the mask
+                if (isNumeric(control.type) && ! control.decimal && ! control.locale) {
+                    if (layout.decimal === undefined) {
+                        layout.decimal = getDecimal.call(control);
+                    }
+                    control.decimal = layout.decimal;
+                }
             }
 
             // Decimal only for numbers
@@ -12595,13 +12625,14 @@ function Path(pathString, value, remove) {
             return false;
         }
 
+        // Own keys only: a write never walks into what the object inherits
         // If the key exists but is null/undefined or a non-object, replace it with an empty object
         if (
-            key in currentObject &&
+            Object.hasOwn(currentObject, key) &&
             (currentObject[key] == null || ! isValidPathObj(currentObject[key]))
         ) {
             currentObject[key] = {};
-        } else if (!(key in currentObject)) {
+        } else if (! Object.hasOwn(currentObject, key)) {
             // If the key doesn't exist, create an empty object
             currentObject[key] = {};
         }
@@ -23551,7 +23582,7 @@ var jSuites = {
     ...dictionary,
     ...helpers,
     /** Current version */
-    version: '6.5.2',
+    version: '6.6.0',
     /** Bind new extensions to Jsuites */
     setExtensions: function(o) {
         if (typeof(o) == 'object') {

package/package.json

@@ -26,13 +26,13 @@
     },
     "main": "dist/jsuites.js",
     "types": "dist/jsuites.d.ts",
-    "version": "6.5.2",
+    "version": "6.6.0",
     "bugs": "https://github.com/jsuites/jsuites/issues",
     "homepage": "https://github.com/jsuites/jsuites",
     "docs": "https://jsuites.net",
     "download": "https://github.com/jsuites/jsuites/archive/master.zip",
     "dependencies": {
-        "@jsuites/utils": "^6.1.1",
+        "@jsuites/utils": "^6.2.0",
         "@lemonadejs/calendar": "^5.9.3",
         "@lemonadejs/color": "^5.8.0",
         "@lemonadejs/contextmenu": "^5.8.6",