@bbn/bbn 2.0.170 → 2.0.172

package/dist/dt/functions/intl-weekinfo-polyfill.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Polyfill for:
+ * - Intl.Locale (minimal)
+ * - Intl.Locale.prototype.getWeekInfo()
+ * - Intl.Locale.prototype.weekInfo
+ *
+ * It does NOT touch DateTimeFormat / RelativeTimeFormat.
+ * Those will be handled by FormatJS in setup-intl.ts.
+ */
+export interface WeekInfo {
+    /** 1 = Monday, 7 = Sunday */
+    firstDay: number;
+    /** Weekend days as 1–7 (1 = Monday, 7 = Sunday) */
+    weekend: number[];
+    /** Minimal days required in the first week of the year */
+    minimalDays: number;
+}
+/**
+ * Call this once after loading any Intl polyfills (FormatJS, etc.).
+ */
+export declare function ensureIntlWeekInfoPolyfill(): void;

package/dist/dt/functions/intl-weekinfo-polyfill.js

@@ -0,0 +1,116 @@
+/**
+ * Polyfill for:
+ * - Intl.Locale (minimal)
+ * - Intl.Locale.prototype.getWeekInfo()
+ * - Intl.Locale.prototype.weekInfo
+ *
+ * It does NOT touch DateTimeFormat / RelativeTimeFormat.
+ * Those will be handled by FormatJS in setup-intl.ts.
+ */
+/* -------------------------------------------------------------------------- */
+/*  Helpers                                                                   */
+/* -------------------------------------------------------------------------- */
+function parseLocaleTag(tag) {
+    const str = String(tag !== null && tag !== void 0 ? tag : '');
+    const parts = str.split('-').filter(Boolean);
+    if (!parts.length) {
+        return { language: 'und' };
+    }
+    let language = parts[0].toLowerCase();
+    let script;
+    let region;
+    for (let i = 1; i < parts.length; i++) {
+        const part = parts[i];
+        if (!script && part.length === 4) {
+            script = part[0].toUpperCase() + part.slice(1).toLowerCase();
+        }
+        else if (!region && (part.length === 2 || part.length === 3)) {
+            region = part.toUpperCase();
+        }
+    }
+    return { language, script, region };
+}
+const REGION_WEEK_INFO = import('../data/weekinfo-overrides.js');
+function computeWeekInfo(localeInstance) {
+    var _a, _b, _c;
+    const tag = (_c = (_a = localeInstance.baseName) !== null && _a !== void 0 ? _a : (_b = localeInstance.toString) === null || _b === void 0 ? void 0 : _b.call(localeInstance)) !== null && _c !== void 0 ? _c : 'und';
+    const { region } = parseLocaleTag(tag);
+    const info = (region && REGION_WEEK_INFO[region]) || {
+        firstDay: 1,
+        weekend: [6, 7],
+        minimalDays: 4,
+    };
+    return {
+        firstDay: info.firstDay,
+        weekend: info.weekend.slice(),
+        minimalDays: info.minimalDays,
+    };
+}
+/* -------------------------------------------------------------------------- */
+/*  Polyfill entry                                                            */
+/* -------------------------------------------------------------------------- */
+function ensureIntlLocalePolyfill() {
+    if (typeof Intl === 'undefined') {
+        return;
+    }
+    const hasNativeLocale = typeof Intl.Locale === 'function';
+    if (!hasNativeLocale) {
+        class PolyfilledLocale {
+            constructor(tag) {
+                const t = Array.isArray(tag) ? tag[0] : tag;
+                const str = String(t !== null && t !== void 0 ? t : 'und');
+                const parsed = parseLocaleTag(str);
+                this._tag = str;
+                this._language = parsed.language;
+                this._script = parsed.script;
+                this._region = parsed.region;
+            }
+            toString() {
+                return this._tag;
+            }
+            get baseName() {
+                return this._tag;
+            }
+            get language() {
+                return this._language;
+            }
+            get script() {
+                return this._script;
+            }
+            get region() {
+                return this._region;
+            }
+            getWeekInfo() {
+                return computeWeekInfo(this);
+            }
+            get weekInfo() {
+                return computeWeekInfo(this);
+            }
+        }
+        Intl.Locale = PolyfilledLocale;
+    }
+    const proto = Intl.Locale.prototype;
+    if (typeof proto.getWeekInfo !== 'function') {
+        proto.getWeekInfo = function getWeekInfo() {
+            return computeWeekInfo(this);
+        };
+    }
+    if (!Object.getOwnPropertyDescriptor(proto, 'weekInfo')) {
+        Object.defineProperty(proto, 'weekInfo', {
+            configurable: true,
+            enumerable: true,
+            get() {
+                if (typeof this.getWeekInfo === 'function') {
+                    return this.getWeekInfo();
+                }
+                return computeWeekInfo(this);
+            },
+        });
+    }
+}
+/**
+ * Call this once after loading any Intl polyfills (FormatJS, etc.).
+ */
+export function ensureIntlWeekInfoPolyfill() {
+    ensureIntlLocalePolyfill();
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Call this once at startup *before* your app uses Intl.
+ *
+ * Example:
+ *   import { setupIntl } from './setup-intl';
+ *   await setupIntl();
+ */
+export default function setupIntl(): Promise<void>;

package/dist/dt/functions/setupIntl.js

@@ -0,0 +1,81 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// setup-intl.ts
+import { ensureIntlWeekInfoPolyfill } from './intl-weekinfo-polyfill.js';
+// ------------------------------
+// Feature detection
+// ------------------------------
+function needsRelativeTimeFormatPolyfill() {
+    return typeof Intl === 'undefined' || typeof Intl.RelativeTimeFormat !== 'function';
+}
+/**
+ * We ONLY care about style formats (dateStyle/timeStyle).
+ * If creating a DateTimeFormat with dateStyle throws, we polyfill.
+ */
+function needsDateTimeStylePolyfill() {
+    if (typeof Intl === 'undefined' || typeof Intl.DateTimeFormat !== 'function') {
+        return true;
+    }
+    try {
+        // If this works, the engine supports style formats well enough.
+        // Chrome / modern Firefox / modern Safari pass this.
+        new Intl.DateTimeFormat('en', { dateStyle: 'medium' });
+        return false;
+    }
+    catch (_a) {
+        // Old Safari, old Firefox, old Chrome, etc.
+        return true;
+    }
+}
+// ------------------------------
+// Conditional polyfill loader
+// ------------------------------
+/**
+ * Call this once at startup *before* your app uses Intl.
+ *
+ * Example:
+ *   import { setupIntl } from './setup-intl';
+ *   await setupIntl();
+ */
+export default function setupIntl() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tasks = [];
+        // Polyfill RelativeTimeFormat only if missing (old Safari, old Firefox, etc.)
+        if (needsRelativeTimeFormatPolyfill()) {
+            tasks.push((() => __awaiter(this, void 0, void 0, function* () {
+                const rtModule = yield import('@formatjs/intl-relativetimeformat/polyfill.js');
+                // Ensure module is evaluated (rtModule is unused but import side-effect matters)
+                void rtModule;
+                // Add the locales you actually use:
+                yield import('@formatjs/intl-relativetimeformat/locale-data/en.js');
+                // await import('@formatjs/intl-relativetimeformat/locale-data/it');
+                // ...more locales if needed
+            }))());
+        }
+        // Polyfill DateTimeFormat only when style formats are not supported
+        if (needsDateTimeStylePolyfill()) {
+            tasks.push((() => __awaiter(this, void 0, void 0, function* () {
+                const dtModule = yield import('@formatjs/intl-datetimeformat/polyfill.js');
+                void dtModule;
+                // Optional but common: locale data
+                yield import('@formatjs/intl-datetimeformat/locale-data/en.js');
+                // await import('@formatjs/intl-datetimeformat/locale-data/it');
+                // If you need full timezone data (heavy!):
+                // await import('@formatjs/intl-datetimeformat/add-all-tz');
+            }))());
+        }
+        // Wait for all FormatJS polyfills that are actually needed
+        if (tasks.length > 0) {
+            yield Promise.all(tasks);
+        }
+        // Finally, always patch weekInfo (Intl.Locale) – Firefox, Chrome, etc.
+        ensureIntlWeekInfoPolyfill();
+    });
+}

package/dist/dt.js

@@ -178,6 +178,7 @@ const dt = (value, inputFormat = null, cls = 'auto') => {
     if (!value) {
         const d = new bbnDtDateTime();
         d.setValid(false);
+        return d;
     }
     if (typeof value === 'string') {
         if (inputFormat) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbn/bbn",
-  "version": "2.0.170",
+  "version": "2.0.172",
   "description": "Javascript toolkit",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -61,6 +61,8 @@
   },
   "dependencies": {
     "@formatjs/intl-datetimeformat": "^6.18.2",
+    "@formatjs/intl-pluralrules": "^5.4.6",
+    "@formatjs/intl-relativetimeformat": "^11.4.13",
     "cldr-core": "^48.0.0",
     "temporal-polyfill": "^0.3.0"
   }