@bbn/bbn 2.0.39 → 2.0.41

package/dist/dt/functions/buildLocaleFromIntl.js

@@ -4,78 +4,70 @@ import numProperties from "../../fn/object/numProperties.js";
  * Build a token pattern (YYYY, MM, DD, dddd, HH, II, SS, A, z) from Intl parts.
  * Uses Intl options to distinguish MMM vs MMMM, ddd vs dddd, etc.
  */
-function partsToPattern(parts, hourCycle, opts) {
+function partsToPattern(parts, resolved, requestedOpts) {
     let pattern = '';
+    const hourCycle = resolved.hourCycle;
     const hasDayPeriod = parts.some(p => p.type === 'dayPeriod');
     const is12h = hasDayPeriod || hourCycle === 'h12' || hourCycle === 'h11';
-    // ---- detect "all numeric date" ----
-    const yearIsNumeric = opts.year === 'numeric' || opts.year === '2-digit';
-    const monthIsNumeric = opts.month === 'numeric' || opts.month === '2-digit';
-    const dayIsNumeric = opts.day === 'numeric' || opts.day === '2-digit';
-    const hasYear = !!opts.year;
-    const hasMonth = !!opts.month;
-    const hasDay = !!opts.day;
-    const hasWeekday = !!opts.weekday;
-    const hasTextMonth = opts.month === 'short' || opts.month === 'long';
-    const isAllNumericDate = hasYear && hasMonth && hasDay &&
-        yearIsNumeric && monthIsNumeric && dayIsNumeric &&
-        !hasWeekday && !hasTextMonth;
+    // ALL NUMERIC (not 2-digit): year, month and day resolved as "numeric"
+    const allNumericNonPadded = resolved.year === 'numeric' &&
+        resolved.month === 'numeric' &&
+        resolved.day === 'numeric';
     for (const p of parts) {
         switch (p.type) {
-            case 'year':
-                if (opts.year === '2-digit') {
+            case 'year': {
+                // Use YY only if locale actually resolved 2-digit
+                if (resolved.year === '2-digit') {
                     pattern += 'YY';
                 }
                 else {
                     pattern += 'YYYY';
                 }
                 break;
-            case 'month':
-                if (isAllNumericDate) {
-                    // normalize to single M when date is fully numeric
-                    pattern += 'M';
-                }
-                else if (opts.month === 'short') {
-                    pattern += 'MMM';
+            }
+            case 'month': {
+                // textual month
+                if (requestedOpts.month === 'short' || requestedOpts.month === 'long') {
+                    pattern += requestedOpts.month === 'long' ? 'MMMM' : 'MMM';
+                    break;
                 }
-                else if (opts.month === 'long') {
-                    pattern += 'MMMM';
+                // ALL NUMERIC and non-padded → always use M
+                if (allNumericNonPadded) {
+                    pattern += 'M';
+                    break;
                 }
-                else if (opts.month === 'numeric' || opts.month === '2-digit') {
-                    // non "all numeric" case (e.g., month+year or month+day only)
-                    pattern += /^\d{2}$/.test(p.value) ? 'MM' : 'M';
+                // numeric / 2-digit generic case
+                if (/^\d+$/.test(p.value)) {
+                    pattern += p.value.length === 2 ? 'MM' : 'M';
                 }
                 else {
-                    // Fallback
-                    if (/^\d+$/.test(p.value)) {
-                        pattern += p.value.length === 2 ? 'MM' : 'M';
-                    }
-                    else {
-                        pattern += p.value.length > 3 ? 'MMMM' : 'MMM';
-                    }
+                    // fallback (shouldn't really happen without text month)
+                    pattern += p.value.length > 3 ? 'MMMM' : 'MMM';
                 }
                 break;
-            case 'day':
-                if (isAllNumericDate) {
-                    // normalize to single D when date is fully numeric
+            }
+            case 'day': {
+                // ALL NUMERIC and non-padded → always use D
+                if (allNumericNonPadded) {
                     pattern += 'D';
+                    break;
                 }
-                else {
-                    pattern += p.value.length === 2 ? 'DD' : 'D';
-                }
+                pattern += p.value.length === 2 ? 'DD' : 'D';
                 break;
-            case 'weekday':
-                if (opts.weekday === 'short' || opts.weekday === 'narrow') {
+            }
+            case 'weekday': {
+                if (requestedOpts.weekday === 'short' || requestedOpts.weekday === 'narrow') {
                     pattern += 'ddd';
                 }
-                else if (opts.weekday === 'long') {
+                else if (requestedOpts.weekday === 'long') {
                     pattern += 'dddd';
                 }
                 else {
                     pattern += p.value.length > 3 ? 'dddd' : 'ddd';
                 }
                 break;
-            case 'hour':
+            }
+            case 'hour': {
                 if (is12h) {
                     pattern += p.value.length === 2 ? 'hh' : 'h';
                 }
@@ -83,6 +75,7 @@ function partsToPattern(parts, hourCycle, opts) {
                     pattern += p.value.length === 2 ? 'HH' : 'H';
                 }
                 break;
+            }
             case 'minute':
                 pattern += 'II';
                 break;
@@ -96,8 +89,8 @@ function partsToPattern(parts, hourCycle, opts) {
                 pattern += 'z';
                 break;
             case 'literal': {
-                // Wrap literals in [ ... ] so your parser doesn't confuse them
-                if (p.value.length && ![' ', ',', '/', '-', ':', '.'].includes(p.value)) {
+                // Wrap literals in [ ... ] so your parser won't confuse them with tokens
+                if (p.value.length) {
                     const v = p.value.replace(/]/g, '\\]');
                     pattern += `[${v}]`;
                 }
@@ -154,7 +147,7 @@ export function getCommonFormatsForLocale(lng) {
         const fmt = new Intl.DateTimeFormat(lng, opts);
         const parts = fmt.formatToParts(sample);
         const resolved = fmt.resolvedOptions();
-        const pattern = partsToPattern(parts, resolved.hourCycle, opts);
+        const pattern = partsToPattern(parts, resolved, opts);
         if (!seenDatePatterns.has(pattern)) {
             seenDatePatterns.add(pattern);
             date.push({
@@ -181,7 +174,7 @@ export function getCommonFormatsForLocale(lng) {
         const fmt = new Intl.DateTimeFormat(lng, opts);
         const parts = fmt.formatToParts(sample);
         const resolved = fmt.resolvedOptions();
-        const pattern = partsToPattern(parts, resolved.hourCycle, opts);
+        const pattern = partsToPattern(parts, resolved, opts);
         if (!seenTimePatterns.has(pattern)) {
             seenTimePatterns.add(pattern);
             time.push({
@@ -198,7 +191,7 @@ export function getCommonFormatsForLocale(lng) {
             const fmt = new Intl.DateTimeFormat(lng, opts);
             const parts = fmt.formatToParts(sample);
             const resolved = fmt.resolvedOptions();
-            const pattern = partsToPattern(parts, resolved.hourCycle, opts);
+            const pattern = partsToPattern(parts, resolved, opts);
             if (!seenDateTimePatterns.has(pattern)) {
                 seenDateTimePatterns.add(pattern);
                 datetime.push({

package/dist/dt/functions/parse.js

@@ -452,6 +452,26 @@ export default function parse(input, format, locale) {
         const applyFns = [];
         let i = 0;
         while (i < fmt.length) {
+            // 1) Handle [literal] blocks first
+            if (fmt[i] === '[') {
+                let j = i + 1;
+                let rawLiteral = '';
+                while (j < fmt.length && fmt[j] !== ']') {
+                    rawLiteral += fmt[j];
+                    j++;
+                }
+                if (j < fmt.length && fmt[j] === ']') {
+                    // We found a closing bracket: treat content as literal
+                    // Undo our earlier escaping of ']' (we used '\]' when building)
+                    const literal = rawLiteral.replace(/\\]/g, ']');
+                    pattern += escapeRegex(literal);
+                    // No capturing group & no applyFn, we just match this text
+                    i = j + 1;
+                    continue;
+                }
+                // If there's no closing ']', fall through and treat '[' as normal char
+            }
+            // 2) Try to match a token at this position
             let matchedToken = null;
             for (const spec of tokensByLength) {
                 if (fmt.startsWith(spec.token, i)) {
@@ -470,6 +490,7 @@ export default function parse(input, format, locale) {
                 i += matchedToken.token.length;
             }
             else {
+                // 3) Plain literal character
                 pattern += escapeRegex(fmt[i]);
                 i += 1;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbn/bbn",
-  "version": "2.0.39",
+  "version": "2.0.41",
   "description": "Javascript toolkit",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",