@bbn/bbn 2.0.29 → 2.0.31

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

@@ -1,34 +1 @@
-type Style = 'full' | 'long' | 'medium' | 'short';
-type CommonFormats = {
-    date: Array<{
-        style: Style;
-        pattern: string;
-        sample: string;
-        options: Intl.DateTimeFormatOptions;
-    }>;
-    time: Array<{
-        style: Style;
-        pattern: string;
-        sample: string;
-        options: Intl.DateTimeFormatOptions;
-    }>;
-    datetime: Array<{
-        dateStyle: Style;
-        timeStyle: Style;
-        pattern: string;
-        sample: string;
-        options: Intl.DateTimeFormatOptions;
-    }>;
-};
-/**
- * Get all common date/time/datetime formats for a given locale using Intl.DateTimeFormat.
- *
- * - Date formats: dateStyle only (full/long/medium/short)
- * - Time formats: timeStyle only
- * - Datetime formats: all combinations of dateStyle × timeStyle
- *
- * Returns tokens using your convention: YYYY, MM, DD, HH, II, SS, A, etc.
- */
-export declare function getCommonFormatsForLocale(lng: string | string[]): CommonFormats;
 export default function buildLocaleFromIntl(): void;
-export {};

package/dist/dt/functions/buildLocaleFromIntl.js

@@ -1,45 +1,28 @@
 import extend from "../../fn/object/extend.js";
 import numProperties from "../../fn/object/numProperties.js";
-/**
- * Build a token pattern like "DD/MM/YYYY HH:II:SS" from Intl.DateTimeFormat parts.
- */
 function partsToPattern(parts, hourCycle) {
     let pattern = '';
-    // If we see a dayPeriod in parts, it's definitely 12-hour clock
     const hasDayPeriod = parts.some(p => p.type === 'dayPeriod');
     const is12h = hasDayPeriod || hourCycle === 'h12' || hourCycle === 'h11';
     for (const p of parts) {
         switch (p.type) {
             case 'year':
-                // Usually "2000" → "YYYY"
                 pattern += 'YYYY';
                 break;
             case 'month':
-                if (/^\d+$/.test(p.value)) {
-                    // numeric month
+                if (/^\d+$/.test(p.value))
                     pattern += p.value.length === 2 ? 'MM' : 'M';
-                }
-                else {
-                    // textual month
+                else
                     pattern += p.value.length > 3 ? 'MMMM' : 'MMM';
-                }
                 break;
             case 'day':
                 pattern += p.value.length === 2 ? 'DD' : 'D';
                 break;
             case 'weekday':
-                // You can refine this if you care about full vs short
                 pattern += p.value.length > 3 ? 'dddd' : 'ddd';
                 break;
             case 'hour':
-                if (is12h) {
-                    // 12-hour clock
-                    pattern += p.value.length === 2 ? 'hh' : 'h';
-                }
-                else {
-                    // 24-hour clock
-                    pattern += p.value.length === 2 ? 'HH' : 'H';
-                }
+                pattern += is12h ? (p.value.length === 2 ? 'hh' : 'h') : (p.value.length === 2 ? 'HH' : 'H');
                 break;
             case 'minute':
                 pattern += 'II';
@@ -48,14 +31,14 @@ function partsToPattern(parts, hourCycle) {
                 pattern += 'SS';
                 break;
             case 'dayPeriod':
-                // AM/PM
                 pattern += 'A';
                 break;
             case 'timeZoneName':
-                // You may want 'z' or 'Z' depending on your conventions
                 pattern += 'z';
                 break;
             case 'literal':
+                pattern += p.value;
+                break;
             default:
                 pattern += p.value;
                 break;
@@ -64,69 +47,92 @@ function partsToPattern(parts, hourCycle) {
     return pattern;
 }
 /**
- * Get all common date/time/datetime formats for a given locale using Intl.DateTimeFormat.
- *
- * - Date formats: dateStyle only (full/long/medium/short)
- * - Time formats: timeStyle only
- * - Datetime formats: all combinations of dateStyle × timeStyle
- *
- * Returns tokens using your convention: YYYY, MM, DD, HH, II, SS, A, etc.
+ * Returns all common date/time/datetime formats + weekday formats for a given locale.
  */
-export function getCommonFormatsForLocale(lng) {
+function getCommonFormatsForLocale(lng) {
     const dateStyles = ['full', 'long', 'medium', 'short'];
     const timeStyles = ['full', 'long', 'medium', 'short'];
-    // A fixed sample date to generate patterns.
-    // 2 Jan 2000, 13:45:30 — avoids 01/01 ambiguity and crosses 12h/24h boundaries.
-    const sampleDate = new Date(Date.UTC(2000, 0, 2, 13, 45, 30));
-    const date = [];
-    const time = [];
-    const datetime = [];
-    // --- Date-only formats ---
+    const sample = new Date(Date.UTC(2000, 0, 2, 13, 45, 30));
+    const result = {
+        date: [],
+        time: [],
+        datetime: [],
+        dateWithWeekday: [],
+        datetimeWithWeekday: []
+    };
+    // --- Date only ---
     for (const ds of dateStyles) {
         const options = { dateStyle: ds };
         const fmt = new Intl.DateTimeFormat(lng, options);
-        const parts = fmt.formatToParts(sampleDate);
-        const pattern = partsToPattern(parts, fmt.resolvedOptions().hourCycle);
-        date.push({
+        const parts = fmt.formatToParts(sample);
+        result.date.push({
             style: ds,
-            pattern,
-            sample: fmt.format(sampleDate),
+            pattern: partsToPattern(parts, fmt.resolvedOptions().hourCycle),
+            sample: fmt.format(sample),
             options
         });
     }
-    // --- Time-only formats ---
+    // --- Time only ---
     for (const ts of timeStyles) {
         const options = { timeStyle: ts };
         const fmt = new Intl.DateTimeFormat(lng, options);
-        const parts = fmt.formatToParts(sampleDate);
-        const pattern = partsToPattern(parts, fmt.resolvedOptions().hourCycle);
-        time.push({
+        const parts = fmt.formatToParts(sample);
+        result.time.push({
             style: ts,
-            pattern,
-            sample: fmt.format(sampleDate),
+            pattern: partsToPattern(parts, fmt.resolvedOptions().hourCycle),
+            sample: fmt.format(sample),
             options
         });
     }
-    // --- Date + time formats (all combinations) ---
+    // --- Date + Time ---
     for (const ds of dateStyles) {
         for (const ts of timeStyles) {
-            const options = {
-                dateStyle: ds,
-                timeStyle: ts
-            };
+            const options = { dateStyle: ds, timeStyle: ts };
             const fmt = new Intl.DateTimeFormat(lng, options);
-            const parts = fmt.formatToParts(sampleDate);
-            const pattern = partsToPattern(parts, fmt.resolvedOptions().hourCycle);
-            datetime.push({
+            const parts = fmt.formatToParts(sample);
+            result.datetime.push({
                 dateStyle: ds,
                 timeStyle: ts,
-                pattern,
-                sample: fmt.format(sampleDate),
+                pattern: partsToPattern(parts, fmt.resolvedOptions().hourCycle),
+                sample: fmt.format(sample),
                 options
             });
         }
     }
-    return { date, time, datetime };
+    // --- Date with Weekday (long + short) ---
+    for (const ds of dateStyles) {
+        for (const w of ["long", "short"]) {
+            const options = { dateStyle: ds, weekday: w };
+            const fmt = new Intl.DateTimeFormat(lng, options);
+            const parts = fmt.formatToParts(sample);
+            result.dateWithWeekday.push({
+                style: ds,
+                weekday: w,
+                pattern: partsToPattern(parts, fmt.resolvedOptions().hourCycle),
+                sample: fmt.format(sample),
+                options
+            });
+        }
+    }
+    // --- Date + Time + Weekday ---
+    for (const ds of dateStyles) {
+        for (const ts of timeStyles) {
+            for (const w of ["long", "short"]) {
+                const options = { dateStyle: ds, timeStyle: ts, weekday: w };
+                const fmt = new Intl.DateTimeFormat(lng, options);
+                const parts = fmt.formatToParts(sample);
+                result.datetimeWithWeekday.push({
+                    dateStyle: ds,
+                    timeStyle: ts,
+                    weekday: w,
+                    pattern: partsToPattern(parts, fmt.resolvedOptions().hourCycle),
+                    sample: fmt.format(sample),
+                    options
+                });
+            }
+        }
+    }
+    return result;
 }
 export default function buildLocaleFromIntl() {
     if (numProperties(bbn.dt.locales)) {

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

@@ -0,0 +1,12 @@
+/**
+ * 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;

package/dist/dt/functions/guessFormat.js

@@ -0,0 +1,120 @@
+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;
+    const str = input.trim();
+    if (!str) {
+        return null;
+    }
+    const tryFormats = (formatsToTry) => {
+        for (const fmt of formatsToTry) {
+            try {
+                // We only care that it parses without throwing
+                parse(str, fmt);
+                return fmt;
+            }
+            catch (_a) {
+                // ignore
+            }
+        }
+        return null;
+    };
+    // If user provided formats, restrict to those only
+    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';
+    }
+    return null;
+}

package/dist/dt.d.ts

@@ -1,8 +1,10 @@
 import parse from './dt/functions/parse.js';
+import guessFormat from './dt/functions/guessFormat.js';
 declare const dt: {
     (value: any, inputFormat?: null | String): void;
     locales: any;
     parse: typeof parse;
+    guessFormat: typeof guessFormat;
     time(): void;
     date(): void;
     dateTime(): void;

package/dist/dt.js

@@ -1,4 +1,5 @@
 import parse from './dt/functions/parse.js';
+import guessFormat from './dt/functions/guessFormat.js';
 const patterns = [
     // MariaDB DATETIME "YYYY-MM-DD HH:MM:SS"
     {
@@ -191,6 +192,7 @@ const dt = (value, inputFormat = null) => {
 };
 dt.locales = Object.create(null);
 dt.parse = parse;
+dt.guessFormat = guessFormat;
 dt.time = () => { };
 dt.date = () => { };
 dt.dateTime = () => { };

package/package.json

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