@zelgadis87/utils-core 5.3.5 → 5.3.6

package/.rollup/index.mjs

@@ -2343,8 +2343,48 @@ function normalizeMonthName(name) {
         // Trim whitespace
         .trim();
 }
-const PATTERN_REGEX = /(M|y|d|D|h|H|m|s|S|G|Z|P|a)+/g;
 const ESCAPE_REGEX = /\\"|"((?:\\"|[^"])*)"/g;
+/**
+ * Tokenize a date/time pattern by detecting character changes.
+ *
+ * This function uses a character-change detection algorithm to split a pattern into tokens:
+ * 1. Iterates through the pattern character by character
+ * 2. Detects when the character changes (e.g., 'y' → 'M' → 'd')
+ * 3. Creates tokens based on consecutive identical characters
+ * 4. Marks tokens as pattern tokens only if they consist of repeated pattern characters
+ *
+ * This approach works correctly for patterns with or without separators:
+ * - "yyyy-MM-dd" → [{token:"yyyy", type:"y"}, {token:"-", type:null}, {token:"MM", type:"M"}, {token:"-", type:null}, {token:"dd", type:"d"}]
+ * - "yyyyMMdd" → [{token:"yyyy", type:"y"}, {token:"MM", type:"M"}, {token:"dd", type:"d"}]
+ *
+ * @param pattern - The date/time pattern to tokenize
+ * @returns Array of tokens with their types (null for separators/literals, pattern char for pattern tokens)
+ */
+function tokenizePattern(pattern) {
+    const result = [];
+    let currentToken = '';
+    let currentChar = '';
+    for (const char of pattern) {
+        if (char === currentChar) {
+            // Same character, extend current token
+            currentToken += char;
+        }
+        else {
+            // Character changed, end current token and start new one
+            if (currentToken) {
+                // Mark the token with its character (caller will decide if it's a valid pattern)
+                result.push({ token: currentToken, type: currentChar });
+            }
+            currentToken = char;
+            currentChar = char;
+        }
+    }
+    // Don't forget the last token
+    if (currentToken) {
+        result.push({ token: currentToken, type: currentChar });
+    }
+    return result;
+}
 // Formatter configuration mapping: token pattern -> configuration with optional extraction rules
 const formatterConfigs = {
     // Year
@@ -2426,11 +2466,16 @@ function formatTimeInstant(instant, pattern, config = {}) {
         if (index % 2 !== 0) {
             return sub;
         }
-        return sub.replace(PATTERN_REGEX, (match) => {
-            const type = match.charAt(0);
-            const length = match.length;
-            return formatType(type, length, date, locale, timeZone) || match;
-        });
+        // Tokenize the pattern by detecting character changes
+        const tokens = tokenizePattern(sub);
+        // Format each token and join the results
+        return tokens.map(({ token, type }) => {
+            // If type is null or formatting fails, keep token as-is
+            if (!type)
+                return token;
+            const formatted = formatType(type, token.length, date, locale, timeZone);
+            return formatted !== undefined ? formatted : token;
+        }).join('');
     })
         .join('');
 }
@@ -2458,53 +2503,62 @@ function parseTimeInstantComponents(dateString, pattern, config = {}) {
         if (index % 2 !== 0) {
             return sub.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // Escape special regex chars
         }
-        return sub.replace(PATTERN_REGEX, (match) => {
-            const type = match.charAt(0);
-            tokens.push({ type, length: match.length, position: position++ });
+        // Tokenize the pattern by detecting character changes
+        const patternTokens = tokenizePattern(sub);
+        // Build regex pattern from tokens
+        return patternTokens.map(({ token, type }) => {
+            // Check if this is a valid pattern by looking it up in formatterConfigs
+            const isValidPattern = type && formatterConfigs[token];
+            if (!isValidPattern) {
+                // This is a literal/separator, escape it for regex
+                return token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            }
+            // This is a pattern token, track it and create regex
+            tokens.push({ type, length: token.length, position: position++ });
             // Create appropriate regex for each token type
             switch (type) {
                 case 'y':
-                    return match.length === 2 ? '(\\d{2})' : '(\\d{4})';
+                    return token.length === 2 ? '(\\d{2})' : '(\\d{4})';
                 case 'M':
-                    if (match.length === 1)
+                    if (token.length === 1)
                         return '(\\d{1,2})';
-                    if (match.length === 2)
+                    if (token.length === 2)
                         return '(\\d{2})';
-                    if (match.length === 3)
+                    if (token.length === 3)
                         return '([A-Za-z.]{1,7})';
                     return '([A-Za-z]+)';
                 case 'd':
-                    return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
+                    return token.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
                 case 'H':
                 case 'h':
-                    return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
+                    return token.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
                 case 'm':
                 case 's':
-                    return match.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
+                    return token.length === 1 ? '(\\d{1,2})' : '(\\d{2})';
                 case 'S':
-                    return `(\\d{${match.length}})`;
+                    return `(\\d{${token.length}})`;
                 case 'a':
                     return '([aApP][mM])';
                 case 'D':
-                    if (match.length === 1)
+                    if (token.length === 1)
                         return '([A-Za-z])';
-                    if (match.length === 2)
+                    if (token.length === 2)
                         return '([A-Za-z]{3})';
                     return '([A-Za-z]+)';
                 case 'G':
-                    if (match.length === 1)
+                    if (token.length === 1)
                         return '([A-Za-z])';
-                    if (match.length === 2)
+                    if (token.length === 2)
                         return '([A-Za-z]{2})';
                     return '([A-Za-z\\s]+)';
                 case 'Z':
-                    return match.length === 1 ? '([A-Za-z0-9+\\-:]+)' : '([A-Za-z\\s]+)';
+                    return token.length === 1 ? '([A-Za-z0-9+\\-:]+)' : '([A-Za-z\\s]+)';
                 case 'P':
                     return '([A-Za-z\\s]+)';
                 default:
-                    return match;
+                    return token;
             }
-        });
+        }).join('');
     }).join('');
     const regex = new RegExp('^' + regexPattern + '$');
     const matches = dateString.match(regex);