@mezzanine-ui/core 1.0.4 → 1.1.0

package/calendar/calendar.d.ts

@@ -76,9 +76,24 @@ export declare const calendarHalfYearYearsCount = 5;
 export declare function getYearRange(year: number, mod: number): number[];
 export declare function getCalendarYearRange(year: number): number[];
 /**
- * Locales that use ISO week (Monday as first day of week).
- * These are primarily European and Middle Eastern locales.
- * Includes both full locale codes (e.g., 'de-de') and short codes (e.g., 'de').
+ * Locales that follow ISO 8601 week rules — Monday is the first day of week
+ * AND week 1 contains at least 4 days of the new year (`minimalDays = 4`).
+ *
+ * Audited against `Intl.Locale#weekInfo` (CLDR). Entries previously listed
+ * here that disagree with CLDR were removed:
+ *  - `pt-pt`, `pt`  → Sunday-first per CLDR (was emitting wrong week
+ *    boundaries for Portuguese)
+ *  - `he-il`, `he`  → Sunday-first per CLDR
+ *  - `ar-sa`, `ar`  → Sunday-first / Saturday-first per CLDR
+ *  - `en-au`, `en-nz` → Monday-first BUT minimalDays=1, NOT ISO
+ *  - `ro-ro`, `ro`, `sl-si`, `sl`, `hr-hr`, `hr`, `tr-tr`, `tr`,
+ *    `uk-ua`, `uk`, `lv-lv`, `lv` → Monday-first BUT minimalDays=1
+ *
+ * The Temporal adapter consumes `Intl.Locale#weekInfo` directly (see
+ * `usesISOWeekRules` in calendarMethodsTemporal). The dayjs/moment
+ * adapters still use this static set; the removals above also fix
+ * silent format/getWeek divergences in those adapters for the affected
+ * locales when CLDR data is the desired source of truth.
  */
 export declare const ISO_WEEK_LOCALES: Set<string>;
 /**

package/calendar/calendar.js

@@ -82,9 +82,24 @@ function getCalendarYearRange(year) {
     return [start, end];
 }
 /**
- * Locales that use ISO week (Monday as first day of week).
- * These are primarily European and Middle Eastern locales.
- * Includes both full locale codes (e.g., 'de-de') and short codes (e.g., 'de').
+ * Locales that follow ISO 8601 week rules — Monday is the first day of week
+ * AND week 1 contains at least 4 days of the new year (`minimalDays = 4`).
+ *
+ * Audited against `Intl.Locale#weekInfo` (CLDR). Entries previously listed
+ * here that disagree with CLDR were removed:
+ *  - `pt-pt`, `pt`  → Sunday-first per CLDR (was emitting wrong week
+ *    boundaries for Portuguese)
+ *  - `he-il`, `he`  → Sunday-first per CLDR
+ *  - `ar-sa`, `ar`  → Sunday-first / Saturday-first per CLDR
+ *  - `en-au`, `en-nz` → Monday-first BUT minimalDays=1, NOT ISO
+ *  - `ro-ro`, `ro`, `sl-si`, `sl`, `hr-hr`, `hr`, `tr-tr`, `tr`,
+ *    `uk-ua`, `uk`, `lv-lv`, `lv` → Monday-first BUT minimalDays=1
+ *
+ * The Temporal adapter consumes `Intl.Locale#weekInfo` directly (see
+ * `usesISOWeekRules` in calendarMethodsTemporal). The dayjs/moment
+ * adapters still use this static set; the removals above also fix
+ * silent format/getWeek divergences in those adapters for the affected
+ * locales when CLDR data is the desired source of truth.
  */
 const ISO_WEEK_LOCALES = new Set([
     'de-de',
@@ -99,8 +114,6 @@ const ISO_WEEK_LOCALES = new Set([
     'nl',
     'pl-pl',
     'pl',
-    'pt-pt',
-    'pt',
     'ru-ru',
     'ru',
     'sv-se',
@@ -115,35 +128,17 @@ const ISO_WEEK_LOCALES = new Set([
     'cs',
     'hu-hu',
     'hu',
-    'ro-ro',
-    'ro',
     'sk-sk',
     'sk',
-    'sl-si',
-    'sl',
-    'hr-hr',
-    'hr',
     'bg-bg',
     'bg',
     'el-gr',
     'el',
-    'tr-tr',
-    'tr',
-    'uk-ua',
-    'uk',
-    'he-il',
-    'he',
-    'ar-sa',
-    'ar',
     'et-ee',
     'et',
-    'lv-lv',
-    'lv',
     'lt-lt',
     'lt',
     'en-gb',
-    'en-au',
-    'en-nz',
 ]);
 /**
  * Check if a locale uses ISO week (Monday as first day of week)

package/calendarMethodsDayjs/index.js

@@ -150,6 +150,17 @@ const getActualFirstDayOfWeek = (locale) => {
 const isMondayFirst = (locale) => {
     return getActualFirstDayOfWeek(locale) === 1;
 };
+/**
+ * Whether the locale should be week-numbered using the ISO 8601 algorithm.
+ * Requires BOTH Monday-first AND `isISOWeekLocale` (i.e. minimalDays=4 per
+ * CLDR). For Monday-first locales whose CLDR `minimalDays` is 1 (en-AU,
+ * en-NZ, ro-RO, tr-TR, sl-SI, hr-HR, uk-UA, lv-LV …) this returns false so
+ * `getWeek`/`getWeekYear`/format `gggg/ww` use locale week numbering and
+ * stay consistent with `getDefaultModeFormat`.
+ */
+const usesISOWeekRules = (locale) => {
+    return isMondayFirst(locale) && isISOWeekLocale(locale);
+};
 const CalendarMethodsDayjs = {
     /** Locale helpers */
     getFirstDayOfWeek: (locale) => getActualFirstDayOfWeek(locale),
@@ -161,16 +172,36 @@ const CalendarMethodsDayjs = {
     getHour: (date) => dayjs(date).hour(),
     getDate: (date) => dayjs(date).date(),
     getWeek: (date, locale) => {
-        if (isMondayFirst(locale)) {
+        if (usesISOWeekRules(locale)) {
             return dayjs(date).isoWeek();
         }
-        return dayjs(date).week();
+        // `.week()` reads the dayjs instance's locale (firstDayOfWeek + doy).
+        // Apply the requested locale explicitly — otherwise the global default
+        // (usually `en` Sunday-first) would be used, breaking Monday-first
+        // non-ISO locales such as en-AU / ro-RO.
+        return dayjs(date).locale(localeMapping(locale)).week();
     },
     getWeekYear: (date, locale) => {
-        if (isMondayFirst(locale)) {
+        if (usesISOWeekRules(locale)) {
             return dayjs(date).isoWeekYear();
         }
-        return dayjs(date).year(); // dayjs doesn't have weekYear, use year as approximation
+        // dayjs has no native locale `.weekYear()`. Use the same heuristic as
+        // moment.js: when the date sits on a year boundary that crosses week
+        // boundaries, the weekYear differs from the calendar year.
+        //   • early-January (month=0) with week >= 52 → previous calendar's
+        //     final week. weekYear = year - 1.
+        //   • late-December (month=11) with week === 1 → next calendar's first
+        //     week. weekYear = year + 1.
+        //   • otherwise weekYear = year.
+        const d = dayjs(date).locale(localeMapping(locale));
+        const week = d.week();
+        const month = d.month();
+        const year = d.year();
+        if (month === 0 && week >= 52)
+            return year - 1;
+        if (month === 11 && week === 1)
+            return year + 1;
+        return year;
     },
     getWeekDay: (date) => {
         const clone = dayjs(date).locale('en');
@@ -223,7 +254,7 @@ const CalendarMethodsDayjs = {
     setDate: (date, target) => dayjs(date).date(target).toISOString(),
     startOf: (target, granularity) => dayjs(target).startOf(granularity).toISOString(),
     getCurrentWeekFirstDate: (value, locale) => {
-        if (isMondayFirst(locale)) {
+        if (usesISOWeekRules(locale)) {
             return dayjs(value)
                 .startOf('isoWeek')
                 .hour(0)
@@ -232,7 +263,10 @@ const CalendarMethodsDayjs = {
                 .millisecond(0)
                 .toISOString();
         }
+        // `.startOf('week')` honors the instance locale's firstDayOfWeek, so
+        // apply the requested locale before truncating.
         return dayjs(value)
+            .locale(localeMapping(locale))
             .startOf('week')
             .hour(0)
             .minute(0)
@@ -314,18 +348,23 @@ const CalendarMethodsDayjs = {
     isBetween: (value, target1, target2, granularity) => dayjs(value).isBetween(target1, target2, granularity),
     isSameDate: (dateOne, dateTwo) => dayjs(dateOne).isSame(dayjs(dateTwo), 'date'),
     isSameWeek: (dateOne, dateTwo, locale) => {
-        if (isMondayFirst(locale)) {
+        if (usesISOWeekRules(locale)) {
             return dayjs(dateOne).isSame(dayjs(dateTwo), 'isoWeek');
         }
-        return dayjs(dateOne).isSame(dayjs(dateTwo), 'week');
+        // `'week'` granularity uses the calling instance's locale — set locale
+        // on the comparator so non-ISO Monday-first locales align correctly.
+        return dayjs(dateOne)
+            .locale(localeMapping(locale))
+            .isSame(dayjs(dateTwo), 'week');
     },
     isInMonth: (target, month) => dayjs(target).month() === month,
     isDateIncluded: (date, targets) => targets.some((target) => dayjs(date).isSame(dayjs(target), 'day')),
     isWeekIncluded: (firstDateOfWeek, targets, locale) => {
-        if (isMondayFirst(locale)) {
+        if (usesISOWeekRules(locale)) {
             return targets.some((target) => dayjs(firstDateOfWeek).isSame(dayjs(target), 'isoWeek'));
         }
-        return targets.some((target) => dayjs(firstDateOfWeek).isSame(dayjs(target), 'week'));
+        const mappedLocale = localeMapping(locale);
+        return targets.some((target) => dayjs(firstDateOfWeek).locale(mappedLocale).isSame(dayjs(target), 'week'));
     },
     isMonthIncluded: (date, targets) => targets.some((target) => dayjs(date).isSame(dayjs(target), 'month')),
     isYearIncluded: (date, targets) => targets.some((target) => dayjs(date).isSame(dayjs(target), 'year')),
@@ -353,9 +392,12 @@ const CalendarMethodsDayjs = {
         //   ISO values because dayjs does not expose a locale `weekYear()`).
         // - GGGG / WW: ISO-8601 week year / number regardless of locale.
         if (format.includes('gggg') || format.includes('GGGG')) {
-            const isMon = isMondayFirst(locale);
-            const localeYear = isMon ? result.isoWeekYear() : result.year();
-            const localeWeek = isMon ? result.isoWeek() : result.week();
+            // Use ISO values for `gggg`/`ww` only when the locale truly uses
+            // ISO 8601 week rules. Monday-first non-ISO locales (e.g. en-AU,
+            // ro-RO) must emit locale-week values so format and getWeek agree.
+            const useISO = usesISOWeekRules(locale);
+            const localeYear = useISO ? result.isoWeekYear() : result.year();
+            const localeWeek = useISO ? result.isoWeek() : result.week();
             const isoYear = result.isoWeekYear();
             const isoWeek = result.isoWeek();
             return format

package/calendarMethodsMoment/index.js

@@ -17,6 +17,17 @@ const getActualFirstDayOfWeek = (locale) => {
 const isMondayFirst = (locale) => {
     return getActualFirstDayOfWeek(locale) === 1;
 };
+/**
+ * Whether the locale should be week-numbered using the ISO 8601 algorithm.
+ * Requires BOTH Monday-first AND `isISOWeekLocale` (i.e. minimalDays=4 per
+ * CLDR). For Monday-first locales whose CLDR `minimalDays` is 1 (en-AU,
+ * en-NZ, ro-RO, tr-TR, sl-SI, hr-HR, uk-UA, lv-LV …) this returns false so
+ * `getWeek`/`getWeekYear` use locale week numbering and stay consistent
+ * with `getDefaultModeFormat`.
+ */
+const usesISOWeekRules = (locale) => {
+    return isMondayFirst(locale) && isISOWeekLocale(locale);
+};
 const CalendarMethodsMoment = {
     /** Get date infos */
     getNow: () => moment().toISOString(),
@@ -25,16 +36,20 @@ const CalendarMethodsMoment = {
     getHour: (date) => moment(date).hour(),
     getDate: (date) => moment(date).date(),
     getWeek: (date, locale) => {
-        if (isMondayFirst(locale)) {
+        if (usesISOWeekRules(locale)) {
             return moment(date).isoWeek();
         }
-        return moment(date).week();
+        // `.week()` reads the moment instance's locale (firstDayOfWeek + doy).
+        // Apply the requested locale explicitly — otherwise the global default
+        // (usually `en-US` Sunday-first) would be used, breaking Monday-first
+        // non-ISO locales such as ro-RO / tr-TR.
+        return moment(date).locale(locale).week();
     },
     getWeekYear: (date, locale) => {
-        if (isMondayFirst(locale)) {
+        if (usesISOWeekRules(locale)) {
             return moment(date).isoWeekYear();
         }
-        return moment(date).weekYear();
+        return moment(date).locale(locale).weekYear();
     },
     getWeekDay: (date) => {
         const clone = moment(date).locale('en_US');
@@ -127,10 +142,9 @@ const CalendarMethodsMoment = {
     },
     startOf: (target, granularity) => moment(target).startOf(granularity).toISOString(),
     getCurrentWeekFirstDate: (value, locale) => {
-        const m = moment(value);
-        if (isMondayFirst(locale)) {
-            // Monday-first: starts on Monday
-            return m
+        if (usesISOWeekRules(locale)) {
+            // Monday-first AND ISO: starts on Monday using ISO week.
+            return moment(value)
                 .startOf('isoWeek')
                 .hour(0)
                 .minute(0)
@@ -138,8 +152,10 @@ const CalendarMethodsMoment = {
                 .millisecond(0)
                 .toISOString();
         }
-        // Locale week: starts on Sunday (for en-us, zh-tw, etc.)
-        return m
+        // Otherwise: locale-week start. `.startOf('week')` uses the instance
+        // locale's firstDayOfWeek, so apply the requested locale first.
+        return moment(value)
+            .locale(locale)
             .startOf('week')
             .hour(0)
             .minute(0)
@@ -220,18 +236,19 @@ const CalendarMethodsMoment = {
     isBetween: (value, target1, target2, granularity) => moment(value).isBetween(target1, target2, granularity),
     isSameDate: (dateOne, dateTwo) => moment(dateOne).isSame(moment(dateTwo), 'date'),
     isSameWeek: (dateOne, dateTwo, locale = 'en-us') => {
-        if (isMondayFirst(locale)) {
+        if (usesISOWeekRules(locale)) {
             return moment(dateOne).isSame(moment(dateTwo), 'isoWeek');
         }
-        return moment(dateOne).isSame(moment(dateTwo), 'week');
+        // `'week'` granularity uses the calling instance's locale.
+        return moment(dateOne).locale(locale).isSame(moment(dateTwo), 'week');
     },
     isInMonth: (target, month) => moment(target).month() === month,
     isDateIncluded: (date, targets) => targets.some((target) => moment(date).isSame(moment(target), 'day')),
     isWeekIncluded: (firstDateOfWeek, targets, locale = 'en-us') => {
-        if (isMondayFirst(locale)) {
+        if (usesISOWeekRules(locale)) {
             return targets.some((target) => moment(firstDateOfWeek).isSame(moment(target), 'isoWeek'));
         }
-        return targets.some((target) => moment(firstDateOfWeek).isSame(moment(target), 'week'));
+        return targets.some((target) => moment(firstDateOfWeek).locale(locale).isSame(moment(target), 'week'));
     },
     isMonthIncluded: (date, targets) => targets.some((target) => moment(date).isSame(moment(target), 'month')),
     isYearIncluded: (date, targets) => targets.some((target) => moment(date).isSame(moment(target), 'year')),

package/calendarMethodsTemporal/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * CalendarMethodsTemporal — JS-native Temporal implementation of CalendarMethods.
+ *
+ * Wire format: ISO 8601 string (matches the moment/dayjs adapters, NOT the
+ * `Temporal.PlainDateTime#toString()` form). The internal representation is
+ * `Temporal.ZonedDateTime` in the system time zone, mirroring how dayjs/moment
+ * default to local time when reading/writing ISO strings.
+ *
+ * Locale week support: uses `Intl.Locale(locale).weekInfo` (Stage 3 / widely
+ * available) to determine the first day of week and minimal days in week 1.
+ * Falls back to the static ISO_WEEK_LOCALES set when `weekInfo` is missing
+ * from the runtime.
+ *
+ * Polyfill: this module relies on `globalThis.Temporal`. Apps that need to
+ * support Safari or Node SSR must install `@js-temporal/polyfill` and
+ * register it on `globalThis` from a Client Component (or equivalent client
+ * entry point) BEFORE this module is imported:
+ *
+ *   import { Temporal } from '@js-temporal/polyfill';
+ *   (globalThis as { Temporal?: unknown }).Temporal = Temporal;
+ *
+ * If Temporal is not present at the time any method is invoked, the call
+ * throws with the same installation guide.
+ */
+import { CalendarMethods as CalendarMethodsType } from '../calendar/typings';
+declare const CalendarMethodsTemporal: CalendarMethodsType;
+export default CalendarMethodsTemporal;