@bbn/bbn 2.0.34 → 2.0.36

package/dist/dt/functions/buildLocaleFromIntl.d.ts

@@ -16,15 +16,19 @@ type CommonFormats = {
     }>;
 };
 /**
- * Enumerate common date, time and datetime formats for a locale, by iterating
- * over combinations of:
- *   - weekday / year / month / day
- *   - hour / minute / second / timeZoneName
+ * Get a curated set of *common* date, time and datetime formats
+ * for the given locale, without exploding into thousands of combos.
  *
- * Constraints:
- *   - no minutes/seconds if you don't have hours
- *   - no seconds if you don't have minutes
- *   - no timezone if you don't have time
+ * Rules:
+ *  - Date: only sensible combos (Y-M-D ± weekday, Y-M, M-D).
+ *  - Time: hour / hour:minute / hour:minute:second (+ optional TZ).
+ *  - Datetime: only full dates (Y-M-D ± weekday) combined with time.
+ *
+ * Fully numeric date forms (like "1/1/1970") are explicitly included via:
+ *   { year: 'numeric', month: 'numeric', day: 'numeric' }
+ *   { year: '2-digit', month: 'numeric', day: 'numeric' }
+ *   { year: 'numeric', month: '2-digit', day: '2-digit' }
+ *   { year: '2-digit', month: '2-digit', day: '2-digit' }
  */
 export declare function getCommonFormatsForLocale(lng: string | string[]): CommonFormats;
 export default function buildLocaleFromIntl(): void;

package/dist/dt/functions/buildLocaleFromIntl.js

@@ -2,8 +2,11 @@ import extend from "../../fn/object/extend.js";
 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.
+ * All literal chunks are wrapped in square brackets so they can't be mistaken
+ * for tokens by the parser.
  */
-function partsToPattern(parts, hourCycle) {
+function partsToPattern(parts, hourCycle, opts) {
     let pattern = '';
     const hasDayPeriod = parts.some(p => p.type === 'dayPeriod');
     const is12h = hasDayPeriod || hourCycle === 'h12' || hourCycle === 'h11';
@@ -13,18 +16,39 @@ function partsToPattern(parts, hourCycle) {
                 pattern += 'YYYY';
                 break;
             case 'month':
-                if (/^\d+$/.test(p.value)) {
-                    pattern += p.value.length === 2 ? 'MM' : 'M';
+                if (opts.month === 'short') {
+                    pattern += 'MMM';
+                }
+                else if (opts.month === 'long') {
+                    pattern += 'MMMM';
+                }
+                else if (opts.month === 'numeric' || opts.month === '2-digit') {
+                    // numeric month
+                    pattern += /^\d{2}$/.test(p.value) ? 'MM' : 'M';
                 }
                 else {
-                    pattern += p.value.length > 3 ? 'MMMM' : 'MMM';
+                    // Fallback: infer from value
+                    if (/^\d+$/.test(p.value)) {
+                        pattern += p.value.length === 2 ? 'MM' : 'M';
+                    }
+                    else {
+                        pattern += p.value.length > 3 ? 'MMMM' : 'MMM';
+                    }
                 }
                 break;
             case 'day':
                 pattern += p.value.length === 2 ? 'DD' : 'D';
                 break;
             case 'weekday':
-                pattern += p.value.length > 3 ? 'dddd' : 'ddd';
+                if (opts.weekday === 'short' || opts.weekday === 'narrow') {
+                    pattern += 'ddd';
+                }
+                else if (opts.weekday === 'long') {
+                    pattern += 'dddd';
+                }
+                else {
+                    pattern += p.value.length > 3 ? 'dddd' : 'ddd';
+                }
                 break;
             case 'hour':
                 if (is12h) {
@@ -46,8 +70,16 @@ function partsToPattern(parts, hourCycle) {
             case 'timeZoneName':
                 pattern += 'z';
                 break;
-            case 'literal':
+            case 'literal': {
+                // Wrap ALL literals into [ ... ] to avoid confusion with tokens
+                if (p.value.length) {
+                    const v = p.value.replace(/]/g, '\\]');
+                    pattern += `[${v}]`;
+                }
+                break;
+            }
             default:
+                // Fallback, should be rare
                 pattern += p.value;
                 break;
         }
@@ -55,152 +87,111 @@ function partsToPattern(parts, hourCycle) {
     return pattern;
 }
 /**
- * Enumerate common date, time and datetime formats for a locale, by iterating
- * over combinations of:
- *   - weekday / year / month / day
- *   - hour / minute / second / timeZoneName
+ * Get a curated set of *common* date, time and datetime formats
+ * for the given locale, without exploding into thousands of combos.
+ *
+ * Rules:
+ *  - Date: only sensible combos (Y-M-D ± weekday, Y-M, M-D).
+ *  - Time: hour / hour:minute / hour:minute:second (+ optional TZ).
+ *  - Datetime: only full dates (Y-M-D ± weekday) combined with time.
  *
- * Constraints:
- *   - no minutes/seconds if you don't have hours
- *   - no seconds if you don't have minutes
- *   - no timezone if you don't have time
+ * Fully numeric date forms (like "1/1/1970") are explicitly included via:
+ *   { year: 'numeric', month: 'numeric', day: 'numeric' }
+ *   { year: '2-digit', month: 'numeric', day: 'numeric' }
+ *   { year: 'numeric', month: '2-digit', day: '2-digit' }
+ *   { year: '2-digit', month: '2-digit', day: '2-digit' }
  */
 export function getCommonFormatsForLocale(lng) {
-    // Fixed sample: 2 Jan 2000, 13:45:30 UTC
     const sample = new Date(Date.UTC(2000, 0, 2, 13, 45, 30));
     const date = [];
     const time = [];
     const datetime = [];
-    // Dedupe by options (not just pattern), so we don't lose combinations like
-    // { day: "numeric", month: "short", year: "numeric" }.
-    const seenDateOptions = new Set();
-    const seenTimeOptions = new Set();
-    const seenDateTimeOptions = new Set();
-    // ---- 1) DATE formats: combinations of weekday/year/month/day ----
-    const weekdayOptions = [
-        undefined,
-        'short',
-        'long'
-    ];
-    const yearOptions = [
-        undefined,
-        'numeric',
-        '2-digit'
-    ];
-    const monthOptions = [undefined, 'numeric', '2-digit', 'short', 'long'];
-    const dayOptions = [
-        undefined,
-        'numeric',
-        '2-digit'
+    const seenDatePatterns = new Set();
+    const seenTimePatterns = new Set();
+    const seenDateTimePatterns = new Set();
+    // ---- 1) DATE: curated list of useful patterns ----
+    // Numeric full dates (this covers "1/1/1970"-style formats as masks like D/M/YYYY or DD/MM/YYYY).
+    const dateOptionsList = [
+        // Fully numeric YYYY-M-D variants
+        { year: 'numeric', month: 'numeric', day: 'numeric' },
+        { year: 'numeric', month: '2-digit', day: '2-digit' },
+        { year: '2-digit', month: 'numeric', day: 'numeric' },
+        { year: '2-digit', month: '2-digit', day: '2-digit' },
+        // Full dates with textual month
+        { year: 'numeric', month: 'short', day: 'numeric' },
+        { year: 'numeric', month: 'long', day: 'numeric' },
+        // Full dates with weekday
+        { weekday: 'short', year: 'numeric', month: 'short', day: 'numeric' },
+        { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' },
+        // Year–month
+        { year: 'numeric', month: 'numeric' },
+        { year: 'numeric', month: '2-digit' },
+        { year: 'numeric', month: 'short' },
+        { year: 'numeric', month: 'long' },
+        // Month–day (no year)
+        { month: 'numeric', day: 'numeric' },
+        { month: '2-digit', day: '2-digit' },
+        { month: 'short', day: 'numeric' },
+        { month: 'long', day: 'numeric' }
     ];
-    const dateOptionsList = [];
-    for (const weekday of weekdayOptions) {
-        for (const year of yearOptions) {
-            for (const month of monthOptions) {
-                for (const day of dayOptions) {
-                    // Skip combos with no actual date fields
-                    if (!year && !month && !day) {
-                        continue;
-                    }
-                    const options = {};
-                    if (weekday)
-                        options.weekday = weekday;
-                    if (year)
-                        options.year = year;
-                    if (month)
-                        options.month = month;
-                    if (day)
-                        options.day = day;
-                    const key = JSON.stringify(options);
-                    if (seenDateOptions.has(key)) {
-                        continue;
-                    }
-                    seenDateOptions.add(key);
-                    const fmt = new Intl.DateTimeFormat(lng, options);
-                    const parts = fmt.formatToParts(sample);
-                    const resolved = fmt.resolvedOptions();
-                    const pattern = partsToPattern(parts, resolved.hourCycle);
-                    dateOptionsList.push(options);
-                    date.push({
-                        pattern,
-                        sample: fmt.format(sample),
-                        options
-                    });
-                }
-            }
+    const fullDateOptions = []; // Y+M+D (± weekday)
+    for (const opts of dateOptionsList) {
+        const fmt = new Intl.DateTimeFormat(lng, opts);
+        const parts = fmt.formatToParts(sample);
+        const resolved = fmt.resolvedOptions();
+        const pattern = partsToPattern(parts, resolved.hourCycle, opts);
+        if (!seenDatePatterns.has(pattern)) {
+            seenDatePatterns.add(pattern);
+            date.push({
+                pattern,
+                sample: fmt.format(sample),
+                options: opts
+            });
+        }
+        // keep track of "full dates" (year+month+day) for datetime
+        if (opts.year && opts.month && opts.day) {
+            fullDateOptions.push(opts);
         }
     }
-    const hourOptions = ['numeric', '2-digit'];
-    const minuteOptions = [
-        undefined,
-        'numeric',
-        '2-digit'
-    ];
-    const secondOptions = [
-        undefined,
-        'numeric',
-        '2-digit'
+    // ---- 2) TIME: curated, valid combos (always have hour, then minute/second) ----
+    const timeOptionsList = [
+        { hour: 'numeric' },
+        { hour: '2-digit', minute: '2-digit' },
+        { hour: '2-digit', minute: '2-digit', second: '2-digit' },
+        { hour: '2-digit', minute: '2-digit', timeZoneName: 'short' },
+        { hour: '2-digit', minute: '2-digit', second: '2-digit', timeZoneName: 'short' },
+        { hour: '2-digit', minute: '2-digit', timeZoneName: 'long' }
     ];
-    const tzNameOptions = [
-        undefined,
-        'short',
-        'long'
-    ];
-    const timeOptionsList = [];
-    for (const hour of hourOptions) {
-        for (const minute of minuteOptions) {
-            for (const second of secondOptions) {
-                for (const tzName of tzNameOptions) {
-                    // Constraints:
-                    // - we always have hour (by design)
-                    // - if we have second, we must have minute
-                    if (second && !minute) {
-                        continue;
-                    }
-                    const options = { hour };
-                    if (minute)
-                        options.minute = minute;
-                    if (second)
-                        options.second = second;
-                    if (tzName)
-                        options.timeZoneName = tzName;
-                    const key = JSON.stringify(options);
-                    if (seenTimeOptions.has(key)) {
-                        continue;
-                    }
-                    seenTimeOptions.add(key);
-                    const fmt = new Intl.DateTimeFormat(lng, options);
-                    const parts = fmt.formatToParts(sample);
-                    const resolved = fmt.resolvedOptions();
-                    const pattern = partsToPattern(parts, resolved.hourCycle);
-                    timeOptionsList.push(options);
-                    time.push({
-                        pattern,
-                        sample: fmt.format(sample),
-                        options
-                    });
-                }
-            }
+    for (const opts of timeOptionsList) {
+        const fmt = new Intl.DateTimeFormat(lng, opts);
+        const parts = fmt.formatToParts(sample);
+        const resolved = fmt.resolvedOptions();
+        const pattern = partsToPattern(parts, resolved.hourCycle, opts);
+        if (!seenTimePatterns.has(pattern)) {
+            seenTimePatterns.add(pattern);
+            time.push({
+                pattern,
+                sample: fmt.format(sample),
+                options: opts
+            });
         }
     }
-    // ---- 3) DATETIME formats: each dateOption × each timeOption ----
-    for (const dateOpts of dateOptionsList) {
-        for (const timeOpts of timeOptionsList) {
-            const options = Object.assign(Object.assign({}, dateOpts), timeOpts);
-            const key = JSON.stringify(options);
-            if (seenDateTimeOptions.has(key)) {
-                continue;
-            }
-            seenDateTimeOptions.add(key);
-            const fmt = new Intl.DateTimeFormat(lng, options);
+    // ---- 3) DATETIME: only full dates (Y-M-D ± weekday) × time ----
+    for (const dOpts of fullDateOptions) {
+        for (const tOpts of timeOptionsList) {
+            const opts = Object.assign(Object.assign({}, dOpts), tOpts);
+            const fmt = new Intl.DateTimeFormat(lng, opts);
             const parts = fmt.formatToParts(sample);
             const resolved = fmt.resolvedOptions();
-            const pattern = partsToPattern(parts, resolved.hourCycle);
-            datetime.push({
-                pattern,
-                sample: fmt.format(sample),
-                options
-            });
+            const pattern = partsToPattern(parts, resolved.hourCycle, opts);
+            if (!seenDateTimePatterns.has(pattern)) {
+                seenDateTimePatterns.add(pattern);
+                datetime.push({
+                    pattern,
+                    sample: fmt.format(sample),
+                    options: opts
+                });
+            }
         }
     }
     return { date, time, datetime };

package/dist/dt/functions/guessFormat.d.ts

@@ -1,12 +1 @@
-/**
- * Guess a date format string for the given input.
- *
- * - If `formats` is provided, it will try those formats in order and return
- *   the first one that successfully parses.
- * - If `formats` is not provided, it will try a set of built-in common formats
- *   (MySQL, ISO/JS, EU/US, full-text using bbn.dt.locales).
- * - Returns `null` if no format matches.
- *
- * NOTE: It relies on `this.parse(input, format)` NOT throwing when the format is correct.
- */
-export default function guessFormat(input: string, formats?: string[] | string): string | null;
+export default function guessFormat(input: string, formats?: string | string[], lng?: string): string | null;

package/dist/dt/functions/guessFormat.js

@@ -1,120 +1,45 @@
-import buildLocaleFromIntl from './buildLocaleFromIntl.js';
 import parse from './parse.js';
-/**
- * Guess a date format string for the given input.
- *
- * - If `formats` is provided, it will try those formats in order and return
- *   the first one that successfully parses.
- * - If `formats` is not provided, it will try a set of built-in common formats
- *   (MySQL, ISO/JS, EU/US, full-text using bbn.dt.locales).
- * - Returns `null` if no format matches.
- *
- * NOTE: It relies on `this.parse(input, format)` NOT throwing when the format is correct.
- */
-export default function guessFormat(input, formats) {
-    var _a;
+import { getCommonFormatsForLocale } from './buildLocaleFromIntl.js';
+export default function guessFormat(input, formats, lng) {
     const str = input.trim();
     if (!str) {
         return null;
     }
-    const tryFormats = (formatsToTry) => {
-        for (const fmt of formatsToTry) {
+    // helper: try a list of formats with your parse()
+    const tryFormats = (fmts) => {
+        for (const fmt of fmts) {
             try {
-                // We only care that it parses without throwing
-                parse(str, fmt);
+                parse(str, fmt); // will throw if not matching
                 return fmt;
             }
             catch (_a) {
-                // ignore
+                // ignore and continue
             }
         }
         return null;
     };
-    // If user provided formats, restrict to those only
+    // if user provided formats, restrict to those
     if (formats) {
         const list = Array.isArray(formats) ? formats : [formats];
         return tryFormats(list);
     }
-    // -------- Autodetection mode (no user-provided formats) --------
-    const lower = str.toLowerCase();
-    // Access locales for full-text formats (months / weekdays)
-    buildLocaleFromIntl();
-    const loc = ((_a = bbn === null || bbn === void 0 ? void 0 : bbn.dt) === null || _a === void 0 ? void 0 : _a.locales) || {};
-    const monthsLong = loc.monthsLong || [];
-    const monthsShort = loc.monthsShort || [];
-    const weekdaysLong = loc.weekdaysLong || [];
-    const weekdaysShort = loc.weekdaysShort || [];
-    const timeFormats = loc.time || [];
-    const dateFormats = loc.date || [];
-    const datetimeFormats = loc.datetime || [];
-    const hasMonthName = monthsLong.some(m => lower.includes(m.toLowerCase())) ||
-        monthsShort.some(m => lower.includes(m.toLowerCase()));
-    const hasWeekdayName = weekdaysLong.some(w => lower.includes(w.toLowerCase())) ||
-        weekdaysShort.some(w => lower.includes(w.toLowerCase()));
-    const hasLetterTZ = /gmt|utc|[+-]\d{2}:?\d{2}|z$/i.test(str);
-    const looksISO = /^\d{4}-\d{2}-\d{2}t\d{2}:\d{2}:\d{2}(\.\d+)?(z|[+\-]\d{2}:?\d{2})?$/i.test(str);
-    const looksMySQLDateTime = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}(:\d{2}(\.\d+)?)?$/i.test(str);
-    const looksMySQLDate = /^\d{4}-\d{2}-\d{2}$/.test(str);
-    const looksTimeOnly = /^\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/.test(str);
-    // Start building candidate formats (most specific first)
-    const candidates = [
-        ...datetimeFormats.map(f => f.pattern),
-    ];
-    // --- Full-text / locale-based formats ---
-    if (hasMonthName || hasWeekdayName) {
-        // e.g. "Monday 15 January 2024"
-        candidates.push('dddd, DD MMMM YYYY HH:II:SSZ', 'dddd, DD MMMM YYYY HH:II:SS', 'dddd, DD MMMM YYYY', 'DD MMMM YYYY HH:II:SSZ', 'DD MMMM YYYY HH:II:SS', 'DD MMMM YYYY', 'ddd, DD MMM YYYY HH:II:SSZ', 'ddd, DD MMM YYYY HH:II:SS', 'ddd, DD MMM YYYY');
-        // JS Date.toString() / toUTCString()-like
-        // "Tue Oct 29 2024 14:30:00 GMT+0200"
-        candidates.push('ddd MMM DD YYYY HH:II:SSZ', 'ddd, DD MMM YYYY HH:II:SS z');
-    }
-    // --- ISO / JS-like default formats ---
-    if (looksISO || str.includes('T')) {
-        candidates.push('YYYY-MM-DDTHH:II:SS.msZ', 'YYYY-MM-DDTHH:II:SSZ', 'YYYY-MM-DDTHH:II:SS.ms', 'YYYY-MM-DDTHH:II:SS', 'YYYY-MM-DDTHH:II:Z', 'YYYY-MM-DDTHH:II');
-    }
-    // --- MySQL classic formats ---
-    if (looksMySQLDateTime) {
-        candidates.push('YYYY-MM-DD HH:II:SS.msZ', 'YYYY-MM-DD HH:II:SSZ', 'YYYY-MM-DD HH:II:SS.ms', 'YYYY-MM-DD HH:II:SS', 'YYYY-MM-DD HH:II');
-    }
-    if (looksMySQLDate) {
-        candidates.push('YYYY-MM-DD');
-    }
-    // --- Time-only strings ---
-    if (looksTimeOnly) {
-        candidates.push(...timeFormats.map(f => f.pattern), 'HH:II:SS.msZ', 'HH:II:SS.ms', 'HH:II:SS', 'HH:II');
-    }
-    // --- Common EU / US formats ---
-    candidates.push(...dateFormats.map(f => f.pattern), 
-    // European style
-    'DD/MM/YYYY HH:II:SSZ', 'DD/MM/YYYY HH:II:SS', 'DD/MM/YYYY HH:II', 'DD/MM/YYYY', 'DD-MM-YYYY HH:II:SSZ', 'DD-MM-YYYY HH:II:SS', 'DD-MM-YYYY HH:II', 'DD-MM-YYYY', 
-    // US style
-    'MM/DD/YYYY HH:II:SSZ', 'MM/DD/YYYY HH:II:SS', 'MM/DD/YYYY HH:II', 'MM/DD/YYYY', 
-    // Dot-separated
-    'YYYY.MM.DD HH:II:SSZ', 'YYYY.MM.DD HH:II:SS', 'YYYY.MM.DD', 
-    // MySQL-ish (if we haven't already pushed them by detection)
-    'YYYY-MM-DD HH:II:SSZ', 'YYYY-MM-DD HH:II:SS', 'YYYY-MM-DD HH:II', 'YYYY-MM-DD');
-    // If we see clear timezone indicators, prioritize formats with Z / z
-    if (hasLetterTZ) {
-        const withTZ = candidates.filter(f => f.includes('Z') || f.includes('z'));
-        const withoutTZ = candidates.filter(f => !f.includes('Z') && !f.includes('z'));
-        const reordered = [...withTZ, ...withoutTZ];
-        const fmt = tryFormats(reordered);
-        if (fmt) {
-            return fmt;
-        }
-    }
-    else {
-        const fmt = tryFormats(candidates);
-        if (fmt) {
-            return fmt;
-        }
-    }
-    // --- Last resort: native JS parsing ---
-    const jsDate = new Date(str);
-    if (!isNaN(jsDate.getTime())) {
-        // You can treat "native" as a special keyword meaning:
-        // "use Date/Temporal to parse directly".
-        return 'native';
-    }
+    // autodetect via Intl-derived formats
+    const resolvedLocale = lng ||
+        (typeof navigator !== 'undefined'
+            ? navigator.language
+            : Intl.DateTimeFormat().resolvedOptions().locale);
+    const common = getCommonFormatsForLocale(resolvedLocale);
+    const candidates = [];
+    // prioritize datetime patterns first, then date, then time
+    candidates.push(...common.datetime.map(f => f.pattern), ...common.date.map(f => f.pattern), ...common.time.map(f => f.pattern));
+    const fmt = tryFormats(candidates);
+    if (fmt) {
+        return fmt;
+    }
+    // last resort: if you *really* want a "native" fallback, do it here
+    // const d = new Date(str);
+    // if (!Number.isNaN(d.getTime())) {
+    //   return 'native';
+    // }
     return null;
 }

package/package.json

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