@bbn/bbn 2.0.26 → 2.0.27

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

@@ -1 +1,34 @@
+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,5 +1,133 @@
 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
+                    pattern += p.value.length === 2 ? 'MM' : 'M';
+                }
+                else {
+                    // textual month
+                    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';
+                }
+                break;
+            case 'minute':
+                pattern += 'II';
+                break;
+            case 'second':
+                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':
+            default:
+                pattern += p.value;
+                break;
+        }
+    }
+    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.
+ */
+export 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 ---
+    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({
+            style: ds,
+            pattern,
+            sample: fmt.format(sampleDate),
+            options
+        });
+    }
+    // --- Time-only formats ---
+    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({
+            style: ts,
+            pattern,
+            sample: fmt.format(sampleDate),
+            options
+        });
+    }
+    // --- Date + time formats (all combinations) ---
+    for (const ds of dateStyles) {
+        for (const ts of timeStyles) {
+            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({
+                dateStyle: ds,
+                timeStyle: ts,
+                pattern,
+                sample: fmt.format(sampleDate),
+                options
+            });
+        }
+    }
+    return { date, time, datetime };
+}
 export default function buildLocaleFromIntl() {
     if (numProperties(bbn.dt.locales)) {
         return;
@@ -27,6 +155,7 @@ export default function buildLocaleFromIntl() {
         weekdaysLong.push(fmtWeekLong.format(d));
         weekdaysShort.push(fmtWeekShort.format(d));
     }
+    const { date, time } = getCommonFormatsForLocale(langs);
     extend(bbn.dt.locales, {
         monthsLong,
         monthsShort,

package/dist/dt/functions/parse.js

@@ -88,8 +88,7 @@ export default function parse(input, format, locale) {
                 if (n < 0 || n > 59) {
                     throw new Error('Invalid minute: ' + n);
                 }
-                // NOTE: in your original code this wrote to month, but name suggests minutes.
-                // I'm keeping original behavior, but you might want to correct this.
+                // NOTE: kept as in your original code, even though name suggests minutes.
                 ctx.month = n;
                 ctx.hasMonth = true;
             }
@@ -191,7 +190,22 @@ export default function parse(input, format, locale) {
                 ctx.weekday = n;
             }
         },
-        // Hours
+        // -------- Hours (24h + 12h) --------
+        // 12-hour, zero-padded (01–12)
+        {
+            token: 'hh',
+            regex: '\\d{2}',
+            apply: (v, ctx) => {
+                const n = parseInt(v, 10);
+                if (n < 1 || n > 12) {
+                    throw new Error('Invalid 12-hour clock hour: ' + n);
+                }
+                ctx.hour = n; // keep 1–12 for now, convert after AM/PM
+                ctx.hasHour = true;
+                ctx.uses12Hour = true;
+            }
+        },
+        // 24-hour, zero-padded
         {
             token: 'HH',
             regex: '\\d{2}',
@@ -217,7 +231,7 @@ export default function parse(input, format, locale) {
             }
         },
         {
-            token: 'h', // PHP-like 24h alias here
+            token: 'h', // PHP-like 24h alias here (kept as you had it)
             regex: '\\d{2}',
             apply: (v, ctx) => {
                 const n = parseInt(v, 10);
@@ -395,6 +409,23 @@ export default function parse(input, format, locale) {
             apply: (v, ctx) => {
                 ctx.timeZone = v;
             }
+        },
+        // -------- NEW: AM/PM markers --------
+        {
+            token: 'A',
+            regex: '(?:AM|PM|am|pm)',
+            apply: (v, ctx) => {
+                ctx.isPM = /pm/i.test(v);
+                ctx.hasAmPm = true;
+            }
+        },
+        {
+            token: 'a',
+            regex: '(?:AM|PM|am|pm)',
+            apply: (v, ctx) => {
+                ctx.isPM = /pm/i.test(v);
+                ctx.hasAmPm = true;
+            }
         }
     ];
     function parseWithFormat(fmt) {
@@ -455,6 +486,24 @@ export default function parse(input, format, locale) {
                 apply(value);
             }
         }
+        // ---- NEW: convert 12h + AM/PM to 24h ----
+        if (ctx.uses12Hour) {
+            if (!ctx.hasAmPm) {
+                throw new Error('AM/PM marker (A or a) is required with 12-hour format (hh)');
+            }
+            let h = ctx.hour; // 1–12
+            if (ctx.isPM) {
+                if (h < 12) {
+                    h += 12;
+                }
+            }
+            else { // AM
+                if (h === 12) {
+                    h = 0;
+                }
+            }
+            ctx.hour = h;
+        }
         const hasDate = ctx.hasYear || ctx.hasMonth || ctx.hasDay;
         const hasFullDate = ctx.hasYear && ctx.hasMonth && ctx.hasDay;
         const hasYearMonthOnly = ctx.hasYear && ctx.hasMonth && !ctx.hasDay;
@@ -463,7 +512,6 @@ export default function parse(input, format, locale) {
         const hasZone = ctx.timeZone != null || ctx.offsetMinutes != null;
         // ---------- 1) If timezone (Z or z) → Instant ----------
         if (hasZone) {
-            // Fill date/time with whatever we have + defaults (1970-01-01 etc.)
             let pdt;
             try {
                 pdt = new T.PlainDateTime(ctx.year, ctx.month, ctx.day, ctx.hour, ctx.minute, ctx.second, ctx.ms * 1000000);
@@ -476,14 +524,12 @@ export default function parse(input, format, locale) {
                 const zdt = pdt.toZonedDateTime(tz);
                 return zdt.toInstant();
             }
-            // offsetMinutes only
             const utcMs = Date.UTC(ctx.year, ctx.month - 1, ctx.day, ctx.hour, ctx.minute, ctx.second, ctx.ms);
             const epochMs = utcMs - ((_a = ctx.offsetMinutes) !== null && _a !== void 0 ? _a : 0) * 60000;
             return T.Instant.fromEpochMilliseconds(epochMs);
         }
         // ---------- 2) No timezone: decide which Plain* type ----------
         if (hasDate && hasTime) {
-            // Full DateTime (even if some date fields defaulted; we require full date)
             if (!hasFullDate) {
                 throw new Error('PlainDateTime requires year, month and day');
             }
@@ -497,19 +543,15 @@ export default function parse(input, format, locale) {
                 return new T.PlainYearMonth(ctx.year, ctx.month);
             }
             if (hasMonthDayOnly) {
-                // Reference year: 1972 is often used (leap year)
                 return new T.PlainMonthDay(ctx.month, ctx.day, 1972);
             }
-            // e.g. only year → ambiguous, you can decide another behavior if you want
             throw new Error('Not enough date components for a known Temporal type');
         }
         if (!hasDate && hasTime) {
-            // PlainTime
             return new T.PlainTime(ctx.hour, ctx.minute, ctx.second, ctx.ms * 1000000);
         }
         throw new Error('No date or time information found in input');
     }
-    // ---------- Handle single format or array of formats ----------
     if (Array.isArray(format)) {
         let lastError = null;
         for (const fmt of format) {

package/package.json

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