@bbn/bbn 2.0.30 → 2.0.32

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

@@ -5,22 +5,18 @@ import numProperties from "../../fn/object/numProperties.js";
  */
 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;
@@ -28,16 +24,13 @@ function partsToPattern(parts, hourCycle) {
                 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;
@@ -48,11 +41,9 @@ 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':
@@ -64,70 +55,110 @@ 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 common date / time / datetime formats for a locale, including
+ * all reasonable combinations of weekday, year, month and day.
  */
-export function getCommonFormatsForLocale(lng) {
-    const dateStyles = ['full', 'long', 'medium', 'short'];
+const getCommonFormatsForLocale = function (lng) {
     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));
+    // 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 = [];
-    // --- 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
-        });
+    // To avoid duplicates
+    const seenDatePatterns = new Set();
+    const seenTimePatterns = new Set();
+    const seenDateTimePatterns = new Set();
+    // --- 1) DATE formats via 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 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;
+                    // Build formatter and pattern
+                    const fmt = new Intl.DateTimeFormat(lng, options);
+                    const parts = fmt.formatToParts(sample);
+                    const resolved = fmt.resolvedOptions();
+                    const pattern = partsToPattern(parts, resolved.hourCycle);
+                    if (!seenDatePatterns.has(pattern)) {
+                        seenDatePatterns.add(pattern);
+                        dateOptionsList.push(options); // keep for datetime combos later
+                        date.push({
+                            pattern,
+                            sample: fmt.format(sample),
+                            options
+                        });
+                    }
+                }
+            }
+        }
     }
-    // --- Time-only formats ---
+    // --- 2) TIME formats via timeStyle 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({
-            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,
+        const parts = fmt.formatToParts(sample);
+        const resolved = fmt.resolvedOptions();
+        const pattern = partsToPattern(parts, resolved.hourCycle);
+        if (!seenTimePatterns.has(pattern)) {
+            seenTimePatterns.add(pattern);
+            time.push({
+                style: ts,
                 pattern,
-                sample: fmt.format(sampleDate),
+                sample: fmt.format(sample),
                 options
             });
         }
     }
+    // --- 3) DATETIME formats: each date option × each timeStyle ---
+    for (const dateOpts of dateOptionsList) {
+        for (const ts of timeStyles) {
+            const options = Object.assign(Object.assign({}, dateOpts), { timeStyle: ts });
+            const fmt = new Intl.DateTimeFormat(lng, options);
+            const parts = fmt.formatToParts(sample);
+            const resolved = fmt.resolvedOptions();
+            const pattern = partsToPattern(parts, resolved.hourCycle);
+            if (!seenDateTimePatterns.has(pattern)) {
+                seenDateTimePatterns.add(pattern);
+                datetime.push({
+                    pattern,
+                    sample: fmt.format(sample),
+                    options
+                });
+            }
+        }
+    }
     return { date, time, datetime };
-}
+};
 export default function buildLocaleFromIntl() {
     if (numProperties(bbn.dt.locales)) {
         return;

package/package.json

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