@escapenavigator/utils 1.10.106 → 1.10.108

package/dist/date-timezone.d.ts

@@ -0,0 +1,5 @@
+/**
+ * utcToZonedTime / zonedTimeToUtc (семантика date-fns-tz@2, Intl для IANA).
+ */
+export declare function utcToZonedTime(dirtyDate: Date | string | number, timeZone: string): Date;
+export declare function zonedTimeToUtc(dateInput: Date | string | number, timeZone: string): Date;

package/dist/date-timezone.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * utcToZonedTime / zonedTimeToUtc (семантика date-fns-tz@2, Intl для IANA).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utcToZonedTime = utcToZonedTime;
+exports.zonedTimeToUtc = zonedTimeToUtc;
+const MS_HOUR = 3600000;
+const MS_MINUTE = 60000;
+function isValidTimezoneIANA(timeZoneString) {
+    try {
+        Intl.DateTimeFormat(undefined, { timeZone: timeZoneString });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const dtfCache = {};
+function getDateTimeFormat(timeZone) {
+    if (!dtfCache[timeZone]) {
+        const base = {
+            timeZone,
+            year: 'numeric',
+            month: 'numeric',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+        };
+        try {
+            dtfCache[timeZone] = new Intl.DateTimeFormat('en-US', {
+                ...base,
+                hourCycle: 'h23',
+            });
+        }
+        catch {
+            dtfCache[timeZone] = new Intl.DateTimeFormat('en-US', {
+                ...base,
+                hour12: false,
+            });
+        }
+    }
+    return dtfCache[timeZone];
+}
+function tzTokenizeDate(date, timeZone) {
+    const dtf = getDateTimeFormat(timeZone);
+    const formatted = dtf.formatToParts(date);
+    const typeToPos = {
+        year: 0,
+        month: 1,
+        day: 2,
+        hour: 3,
+        minute: 4,
+        second: 5,
+    };
+    const filled = [NaN, NaN, NaN, NaN, NaN, NaN];
+    for (let k = 0; k < formatted.length; k += 1) {
+        const p = formatted[k];
+        const pos = typeToPos[p.type];
+        if (pos !== undefined && pos >= 0) {
+            filled[pos] = parseInt(p.value, 10);
+        }
+    }
+    return filled;
+}
+function utcWallMs(fullYear, monthIndex, day, hours, minutes, seconds, milliseconds) {
+    return Date.UTC(fullYear, monthIndex, day, hours, minutes, seconds, milliseconds);
+}
+function wallCalendarPartsFromString(s) {
+    const t = s.trim();
+    let m = /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?)?/.exec(t);
+    if (!m && t.includes('T')) {
+        m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,3}))?)?/.exec(t);
+    }
+    if (!m)
+        return null;
+    const fracMs = (x) => {
+        if (!x)
+            return 0;
+        return Number(`${x}000`.slice(0, 3));
+    };
+    return {
+        fullYear: Number(m[1]),
+        monthIndex: Number(m[2]) - 1,
+        day: Number(m[3]),
+        hour: m[4] === undefined ? 0 : Number(m[4]),
+        minute: m[5] === undefined ? 0 : Number(m[5]),
+        second: m[6] === undefined ? 0 : Number(m[6]),
+        millisecond: fracMs(m[7]),
+    };
+}
+function toDate(dirtyDate) {
+    if (dirtyDate instanceof Date)
+        return new Date(dirtyDate.getTime());
+    return new Date(dirtyDate);
+}
+function coerceWallCalendarDate(input) {
+    if (typeof input !== 'string')
+        return toDate(input);
+    const t = input.trim();
+    let m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(t);
+    if (m) {
+        return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+    }
+    m = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2})(?::(\d{2}))?/.exec(t.replace('T', ' '));
+    if (m) {
+        return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5]), m[6] ? Number(m[6]) : 0);
+    }
+    return toDate(new Date(t));
+}
+function truncateToWholeSeconds(ms) {
+    const over = ms % 1000;
+    return ms - (over >= 0 ? over : over + 1000);
+}
+function localFieldsAsUtcDate(date) {
+    return new Date(utcWallMs(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+}
+function calcOffset(date, timezoneString) {
+    const tokens = tzTokenizeDate(date, timezoneString);
+    const asUTC = utcWallMs(tokens[0], tokens[1] - 1, tokens[2], tokens[3] % 24, tokens[4], tokens[5], 0);
+    const asTS = truncateToWholeSeconds(date.getTime());
+    return asUTC - asTS;
+}
+function fixOffset(date, offset, timezoneString) {
+    const localTs = date.getTime();
+    let utcGuess = localTs - offset;
+    const o2 = calcOffset(new Date(utcGuess), timezoneString);
+    if (offset === o2)
+        return offset;
+    utcGuess -= o2 - offset;
+    const o3 = calcOffset(new Date(utcGuess), timezoneString);
+    if (o2 === o3)
+        return o2;
+    return Math.max(o2, o3);
+}
+function validateTimezoneHour(hours, minutes) {
+    return (hours >= -23 && hours <= 23 && (minutes === undefined || (minutes >= 0 && minutes <= 59)));
+}
+function tzParseTimezone(timezoneString, date, isUtcDate) {
+    if (!timezoneString)
+        return 0;
+    if (/^Z$/i.test(timezoneString))
+        return 0;
+    const hh = /^([+-]\d{2})$/.exec(timezoneString);
+    if (hh) {
+        const h = parseInt(hh[1], 10);
+        if (!validateTimezoneHour(h))
+            return NaN;
+        return -(h * MS_HOUR);
+    }
+    const hhmm = /^([+-])(\d{2}):?(\d{2})$/.exec(timezoneString);
+    if (hhmm) {
+        const h = parseInt(hhmm[2], 10);
+        const mins = parseInt(hhmm[3], 10);
+        if (!validateTimezoneHour(h, mins))
+            return NaN;
+        const abs = Math.abs(h) * MS_HOUR + mins * MS_MINUTE;
+        return hhmm[1] === '+' ? -abs : abs;
+    }
+    if (isValidTimezoneIANA(timezoneString)) {
+        const utcDate = isUtcDate ? date : localFieldsAsUtcDate(date);
+        const offset = calcOffset(utcDate, timezoneString);
+        return -(isUtcDate ? offset : fixOffset(date, offset, timezoneString));
+    }
+    return NaN;
+}
+function utcToZonedTime(dirtyDate, timeZone) {
+    const date = toDate(dirtyDate);
+    const offsetMilliseconds = tzParseTimezone(timeZone, date, true);
+    const d = new Date(date.getTime() - offsetMilliseconds);
+    const resultDate = new Date(0);
+    resultDate.setFullYear(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+    resultDate.setHours(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
+    return resultDate;
+}
+function zonedTimeToUtc(dateInput, timeZone) {
+    if (typeof dateInput === 'string') {
+        const w = wallCalendarPartsFromString(dateInput);
+        if (w) {
+            const utc = utcWallMs(w.fullYear, w.monthIndex, w.day, w.hour, w.minute, w.second, w.millisecond);
+            const offsetMilliseconds = tzParseTimezone(timeZone, new Date(utc), false);
+            return new Date(utc + offsetMilliseconds);
+        }
+    }
+    const d = coerceWallCalendarDate(dateInput);
+    const utc = utcWallMs(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+    const offsetMilliseconds = tzParseTimezone(timeZone, new Date(utc), false);
+    return new Date(utc + offsetMilliseconds);
+}

package/dist/date.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Единая точка работы с датами в монорепе: локальный разбор, стеночные токены (yyyy-MM-dd…),
+ * таймзоны (utcToZonedTime / zonedTimeToUtc), локализованные шаблоны UI (как @alphakits/ui formatDate).
+ */
+export declare function addHours(date: Date, hours: number): Date;
+/** date-fns isBefore(left, right) — left строго раньше right. */
+export declare function isBefore(left: Date, right: Date): boolean;
+/** date-fns differenceInHours (roundingMethod trunc). */
+export declare function differenceInHours(left: Date, right: Date): number;
+/** Локальная дата + календарные дни (без date-fns). */
+export declare function addCalendarDays(date: Date, amount: number): Date;
+export declare function startOfCalendarDay(d: Date): Date;
+/**
+ * Приводит значение из URL/API/UI к валидному `Date` (локальная полуночная семантика для `yyyy-MM-dd`).
+ * Учитывает Dayjs-подобные объекты (`valueOf`, `toDate`), чтобы не падать на `.getFullYear()`.
+ */
+export declare function coerceToCalendarDate(input: unknown): Date;
+/** Первый день календарного месяца, 00:00 локально (устойчивый аналог date-fns `startOfMonth`). */
+export declare function startOfMonth(input: unknown): Date;
+/** Понедельник ISO-недели, 00:00 локально. */
+export declare function startOfISOWeekCalendar(d: Date): Date;
+/** BCP 47 для i18n languageOnly-кодов (как @alphakits/ui). */
+export declare const DISPLAY_DATE_LOCALE_BY_LANG: Record<string, string>;
+export declare function resolveDisplayLocaleTag(lang?: string): string;
+/**
+ * Разбор фиксированных шаблонов UI (локальное время), как в @alphakits/ui `parse`.
+ */
+export declare function parseCalendarPattern(value: string, pattern: string): Date;
+/**
+ * Локальный разбор `yyyy-MM-dd` / `yyyy-MM-dd HH:mm` (строгое совпадение строки).
+ * Реализация через `parseCalendarPattern`; неподдерживаемый pattern → NaN.
+ */
+export declare function parseDate(value: string, pattern: string): Date;
+export type FormatLocalizedDatePatternOptions = {
+    locale?: string;
+};
+/**
+ * Локализованные токены: yyyy, yy, MM, dd, HH, mm, MMM, MMMM, LLL, LLLL, EEE, EEEE, EEEEEE, iii.
+ */
+export declare function formatLocalizedDatePattern(d: Date, pattern: string, options?: FormatLocalizedDatePatternOptions): string;
+export type FormatDateLocaleOptions = {
+    time?: string;
+    format?: string;
+    lang?: string;
+};
+export { utcToZonedTime, zonedTimeToUtc } from './date-timezone';
+/**
+ * Единая точка форматирования дат.
+ * - `formatDate(date, pattern)` — числовые токены в локальной стенке (`yyyy`, `MM`, `dd`, `HH`, `mm`, `ss`).
+ * - `formatDate(input, { format, lang, time })` — как `formatDate` в @alphakits/ui (локализованные MMMM, слоты и т.д.).
+ */
+export declare function formatDate(date: Date, pattern: string): string;
+export declare function formatDate(date: Date | number | string, options: FormatDateLocaleOptions): string;

package/dist/date.js

@@ -0,0 +1,362 @@
+"use strict";
+/**
+ * Единая точка работы с датами в монорепе: локальный разбор, стеночные токены (yyyy-MM-dd…),
+ * таймзоны (utcToZonedTime / zonedTimeToUtc), локализованные шаблоны UI (как @alphakits/ui formatDate).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zonedTimeToUtc = exports.utcToZonedTime = exports.DISPLAY_DATE_LOCALE_BY_LANG = void 0;
+exports.addHours = addHours;
+exports.isBefore = isBefore;
+exports.differenceInHours = differenceInHours;
+exports.addCalendarDays = addCalendarDays;
+exports.startOfCalendarDay = startOfCalendarDay;
+exports.coerceToCalendarDate = coerceToCalendarDate;
+exports.startOfMonth = startOfMonth;
+exports.startOfISOWeekCalendar = startOfISOWeekCalendar;
+exports.resolveDisplayLocaleTag = resolveDisplayLocaleTag;
+exports.parseCalendarPattern = parseCalendarPattern;
+exports.parseDate = parseDate;
+exports.formatLocalizedDatePattern = formatLocalizedDatePattern;
+exports.formatDate = formatDate;
+const MS_HOUR = 3600000;
+function pad2(n) {
+    return n < 10 ? `0${n}` : `${n}`;
+}
+function addHours(date, hours) {
+    const d = new Date(date);
+    d.setHours(d.getHours() + hours);
+    return d;
+}
+/** date-fns isBefore(left, right) — left строго раньше right. */
+function isBefore(left, right) {
+    return left.getTime() < right.getTime();
+}
+/** date-fns differenceInHours (roundingMethod trunc). */
+function differenceInHours(left, right) {
+    const diff = (left.getTime() - right.getTime()) / MS_HOUR;
+    return diff < 0 ? Math.ceil(diff) : Math.floor(diff);
+}
+/** Локальная дата + календарные дни (без date-fns). */
+function addCalendarDays(date, amount) {
+    const d = new Date(date);
+    d.setDate(d.getDate() + amount);
+    return d;
+}
+function startOfCalendarDay(d) {
+    return new Date(d.getFullYear(), d.getMonth(), d.getDate(), 0, 0, 0, 0);
+}
+/**
+ * Приводит значение из URL/API/UI к валидному `Date` (локальная полуночная семантика для `yyyy-MM-dd`).
+ * Учитывает Dayjs-подобные объекты (`valueOf`, `toDate`), чтобы не падать на `.getFullYear()`.
+ */
+function coerceToCalendarDate(input) {
+    if (input == null || input === '') {
+        return new Date();
+    }
+    if (input instanceof Date) {
+        const t = input.getTime();
+        return Number.isNaN(t) ? new Date() : new Date(t);
+    }
+    if (typeof input === 'number' && Number.isFinite(input)) {
+        const d = new Date(input);
+        return Number.isNaN(d.getTime()) ? new Date() : d;
+    }
+    if (typeof input === 'string') {
+        const trimmed = input.trim();
+        if (!trimmed) {
+            return new Date();
+        }
+        if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+            return parseCalendarPattern(trimmed, 'yyyy-MM-dd');
+        }
+        const d = new Date(trimmed);
+        return Number.isNaN(d.getTime()) ? new Date() : d;
+    }
+    if (typeof input === 'object') {
+        const o = input;
+        if (typeof o.toDate === 'function') {
+            try {
+                const converted = o.toDate();
+                if (converted instanceof Date) {
+                    const t = converted.getTime();
+                    return Number.isNaN(t) ? new Date() : new Date(t);
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        if (typeof o.valueOf === 'function') {
+            const v = Number(o.valueOf());
+            if (Number.isFinite(v)) {
+                const d = new Date(v);
+                return Number.isNaN(d.getTime()) ? new Date() : d;
+            }
+        }
+    }
+    return new Date();
+}
+/** Первый день календарного месяца, 00:00 локально (устойчивый аналог date-fns `startOfMonth`). */
+function startOfMonth(input) {
+    const d = coerceToCalendarDate(input);
+    return new Date(d.getFullYear(), d.getMonth(), 1, 0, 0, 0, 0);
+}
+/** Понедельник ISO-недели, 00:00 локально. */
+function startOfISOWeekCalendar(d) {
+    const day = startOfCalendarDay(d);
+    const dow = day.getDay();
+    const delta = dow === 0 ? -6 : 1 - dow;
+    return addCalendarDays(day, delta);
+}
+/** BCP 47 для i18n languageOnly-кодов (как @alphakits/ui). */
+exports.DISPLAY_DATE_LOCALE_BY_LANG = {
+    ru: 'ru-RU',
+    de: 'de-DE',
+    en: 'en-GB',
+    pl: 'pl-PL',
+    et: 'et-EE',
+    fr: 'fr-FR',
+    it: 'it-IT',
+    pt: 'pt-PT',
+    es: 'es-ES',
+    el: 'el-GR',
+    nl: 'nl-NL',
+    cs: 'cs-CZ',
+    fi: 'fi-FI',
+    da: 'da-DK',
+    sk: 'sk-SK',
+    hu: 'hu-HU',
+    sv: 'sv-SE',
+    lv: 'lv-LV',
+    bg: 'bg-BG',
+    ro: 'ro-RO',
+    lt: 'lt-LT',
+    he: 'he-IL',
+};
+function resolveDisplayLocaleTag(lang) {
+    const key = lang?.split('-')[0]?.toLowerCase() || 'en';
+    return exports.DISPLAY_DATE_LOCALE_BY_LANG[key] ?? 'en-GB';
+}
+function isNumericMonthValue(value) {
+    return /^\d+\.?$/.test(value.trim());
+}
+function intlStandaloneMonth(d, locale, style) {
+    const value = new Intl.DateTimeFormat(locale, { month: style }).format(d);
+    if (style === 'short' && isNumericMonthValue(value)) {
+        return new Intl.DateTimeFormat(locale, { month: 'long' }).format(d);
+    }
+    return value;
+}
+function intlMonthInDateContext(d, locale, style) {
+    const parts = new Intl.DateTimeFormat(locale, { day: 'numeric', month: style }).formatToParts(d);
+    const month = parts.find((p) => p.type === 'month')?.value;
+    if (month && !isNumericMonthValue(month)) {
+        return month;
+    }
+    return intlStandaloneMonth(d, locale, style);
+}
+function intlWeekdayPart(d, locale, style) {
+    const parts = new Intl.DateTimeFormat(locale, { weekday: style }).formatToParts(d);
+    const w = parts.find((p) => p.type === 'weekday')?.value;
+    return w ?? new Intl.DateTimeFormat(locale, { weekday: style }).format(d);
+}
+function intlWeekdayVeryShort(d, locale) {
+    return intlWeekdayPart(d, locale, 'short').slice(0, 2);
+}
+function applyCalendarTime(d, timePart) {
+    if (!timePart)
+        return;
+    const [hh, mm] = timePart.split(':').map((x) => Number(x));
+    d.setHours(Number.isFinite(hh) ? hh : 0, Number.isFinite(mm) ? mm : 0, 0, 0);
+}
+/**
+ * Разбор фиксированных шаблонов UI (локальное время), как в @alphakits/ui `parse`.
+ */
+function parseCalendarPattern(value, pattern) {
+    if (pattern === 'yyyy-MM-dd HH:mm' || pattern === 'dd.MM.yyyy HH:mm') {
+        const [datePart, timePart] = value.trim().split(/\s+/);
+        const dateOnlyPattern = pattern.replace(/\s+HH:mm$/, '');
+        const parsed = parseCalendarPattern(datePart, dateOnlyPattern);
+        applyCalendarTime(parsed, timePart);
+        return parsed;
+    }
+    if (pattern === 'yyyy-MM-dd') {
+        const [ys, ms, ds] = value.split('-');
+        return new Date(Number(ys), Number(ms) - 1, Number(ds), 0, 0, 0, 0);
+    }
+    if (pattern === 'dd.MM.yyyy') {
+        const [ds, ms, ys] = value.split('.');
+        return new Date(Number(ys), Number(ms) - 1, Number(ds), 0, 0, 0, 0);
+    }
+    if (pattern === 'dd.MM.yy') {
+        const [ds, ms, ys] = value.split('.');
+        let year = Number(ys);
+        if (year < 100) {
+            year += year >= 70 ? 1900 : 2000;
+        }
+        return new Date(year, Number(ms) - 1, Number(ds), 0, 0, 0, 0);
+    }
+    return new Date(value);
+}
+/**
+ * Локальный разбор `yyyy-MM-dd` / `yyyy-MM-dd HH:mm` (строгое совпадение строки).
+ * Реализация через `parseCalendarPattern`; неподдерживаемый pattern → NaN.
+ */
+function parseDate(value, pattern) {
+    const s = value.trim();
+    if (pattern !== 'yyyy-MM-dd' && pattern !== 'yyyy-MM-dd HH:mm') {
+        return new Date(NaN);
+    }
+    if (pattern === 'yyyy-MM-dd' && !/^(\d{4})-(\d{2})-(\d{2})$/.exec(s)) {
+        return new Date(NaN);
+    }
+    if (pattern === 'yyyy-MM-dd HH:mm' &&
+        !/^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2})(?::(\d{2}))?/.exec(s)) {
+        return new Date(NaN);
+    }
+    return parseCalendarPattern(s, pattern);
+}
+/**
+ * Локализованные токены: yyyy, yy, MM, dd, HH, mm, MMM, MMMM, LLL, LLLL, EEE, EEEE, EEEEEE, iii.
+ */
+function formatLocalizedDatePattern(d, pattern, options) {
+    const dt = d instanceof Date
+        ? new Date(d.getTime())
+        : typeof d === 'number' && Number.isFinite(d)
+            ? new Date(d)
+            : typeof d === 'string'
+                ? new Date(d)
+                : new Date(NaN);
+    if (Number.isNaN(dt.getTime())) {
+        return 'Invalid date';
+    }
+    const locale = options?.locale ?? 'en-GB';
+    const y = dt.getFullYear();
+    const m = dt.getMonth();
+    const day = dt.getDate();
+    const h = dt.getHours();
+    const minu = dt.getMinutes();
+    // MMM/MMMM зависят от наличия дня в шаблоне:
+    // c `dd` — форма «в дате» (родительный падеж в ru: «2 мая»),
+    // без `dd` — стандартная форма («Май», «Сент»), без числовой деградации в локалях вроде cs/sk/hu.
+    const hasDayToken = /dd/.test(pattern);
+    const monthShort = () => hasDayToken
+        ? intlMonthInDateContext(dt, locale, 'short')
+        : intlStandaloneMonth(dt, locale, 'short');
+    const monthLong = () => hasDayToken
+        ? intlMonthInDateContext(dt, locale, 'long')
+        : intlStandaloneMonth(dt, locale, 'long');
+    const tokenReplacements = [
+        [/yyyy/g, () => String(y)],
+        [/LLLL/g, () => intlStandaloneMonth(dt, locale, 'long')],
+        [/MMMM/g, () => monthLong()],
+        [/LLL/g, () => intlStandaloneMonth(dt, locale, 'short')],
+        [/MMM/g, () => monthShort()],
+        [/EEEEEE/g, () => intlWeekdayVeryShort(dt, locale)],
+        [/EEEE/g, () => intlWeekdayPart(dt, locale, 'long')],
+        [/EEE/g, () => intlWeekdayPart(dt, locale, 'short')],
+        [/iii/g, () => intlWeekdayPart(dt, locale, 'short')],
+        [/MM/g, () => pad2(m + 1)],
+        [/dd/g, () => pad2(day)],
+        [/HH/g, () => pad2(h)],
+        [/mm/g, () => pad2(minu)],
+        [/yy/g, () => pad2(y % 100)],
+    ];
+    let out = pattern;
+    tokenReplacements.forEach(([re, fn]) => {
+        out = out.replace(re, fn);
+    });
+    return out;
+}
+function formatDateForLocaleInput(date, { time, format: fmt = 'dd MMMM yyyy, HH:mm', lang }) {
+    if (date == null || date === '')
+        return '-';
+    const localeTag = resolveDisplayLocaleTag(lang);
+    let d;
+    try {
+        if (typeof date === 'number' && Number.isFinite(date)) {
+            d = new Date(date);
+        }
+        else if (date instanceof Date) {
+            d = new Date(date.getTime());
+        }
+        else if (typeof date === 'string' &&
+            (date.includes('Z') || /^\d{4}-\d{2}-\d{2}T/.test(date))) {
+            d = new Date(date);
+        }
+        else if (typeof date === 'string') {
+            const split = date.split('-');
+            let dateFormat = split.length === 3 ? 'yyyy-MM-dd' : 'dd.MM.yyyy';
+            const formattedTime = time ? ` ${time.split(':')[0]}:${time.split(':')[1]}` : '';
+            if (formattedTime)
+                dateFormat += ' HH:mm';
+            d = parseCalendarPattern(`${date}${formattedTime}`, dateFormat);
+        }
+        else {
+            d = new Date(NaN);
+        }
+        if (Number.isNaN(d.getTime()))
+            return `Invalid date ${date}`;
+        return formatLocalizedDatePattern(d, fmt, { locale: localeTag });
+    }
+    catch {
+        return `Invalid date ${date}`;
+    }
+}
+/** Поддержка токенов yyyy MM dd HH mm ss и литералов (другие символы копируются). Только для `Date`. */
+function formatWallClockPattern(date, pattern) {
+    if (!(date instanceof Date) || Number.isNaN(date.getTime())) {
+        throw new TypeError('formatWallClockPattern: invalid Date');
+    }
+    const y = date.getFullYear();
+    const mo = date.getMonth() + 1;
+    const d = date.getDate();
+    const H = date.getHours();
+    const mi = date.getMinutes();
+    const sec = date.getSeconds();
+    let out = '';
+    let i = 0;
+    while (i < pattern.length) {
+        if (pattern.startsWith('yyyy', i)) {
+            out += y;
+            i += 4;
+        }
+        else if (pattern.startsWith('MM', i)) {
+            out += pad2(mo);
+            i += 2;
+        }
+        else if (pattern.startsWith('dd', i)) {
+            out += pad2(d);
+            i += 2;
+        }
+        else if (pattern.startsWith('HH', i)) {
+            out += pad2(H);
+            i += 2;
+        }
+        else if (pattern.startsWith('mm', i)) {
+            out += pad2(mi);
+            i += 2;
+        }
+        else if (pattern.startsWith('ss', i)) {
+            out += pad2(sec);
+            i += 2;
+        }
+        else {
+            out += pattern[i];
+            i += 1;
+        }
+    }
+    return out;
+}
+var date_timezone_1 = require("./date-timezone");
+Object.defineProperty(exports, "utcToZonedTime", { enumerable: true, get: function () { return date_timezone_1.utcToZonedTime; } });
+Object.defineProperty(exports, "zonedTimeToUtc", { enumerable: true, get: function () { return date_timezone_1.zonedTimeToUtc; } });
+function formatDate(date, patternOrOptions) {
+    if (typeof patternOrOptions === 'string') {
+        if (!(date instanceof Date)) {
+            throw new TypeError('formatDate(date, pattern): first argument must be a Date');
+        }
+        return formatWallClockPattern(date, patternOrOptions);
+    }
+    return formatDateForLocaleInput(date, patternOrOptions);
+}

package/dist/date.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/date.test.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const date_1 = require("./date");
+describe('formatLocalizedDatePattern', () => {
+    const nov23 = new Date(2024, 10, 23, 15, 5);
+    it('uses genitive month in ru for MMMM with separate dd', () => {
+        const s = (0, date_1.formatLocalizedDatePattern)(nov23, 'dd MMMM', { locale: 'ru-RU' });
+        expect(s).toBe('23 ноября');
+    });
+    it('uses nominative standalone month for LLLL in ru', () => {
+        const s = (0, date_1.formatLocalizedDatePattern)(nov23, 'LLLL', { locale: 'ru-RU' });
+        expect(s).toBe('ноябрь');
+    });
+    it('uses standalone short month for MMM without dd in ru', () => {
+        const may2 = new Date(2024, 4, 2);
+        const s = (0, date_1.formatLocalizedDatePattern)(may2, 'MMM', { locale: 'ru-RU' });
+        expect(s).not.toMatch(/^\d+\.?$/);
+        expect(s.toLowerCase()).toContain('ма');
+    });
+    it('uses contextual short month for dd MMM in ru', () => {
+        const may2 = new Date(2024, 4, 2);
+        const s = (0, date_1.formatLocalizedDatePattern)(may2, 'dd MMM', { locale: 'ru-RU' });
+        expect(s).toMatch(/^02\s+\S+/);
+        expect(s).not.toMatch(/\d+\.?$/);
+    });
+    it('returns textual month for MMM in cs (no numeric fallback)', () => {
+        const may2 = new Date(2024, 4, 2);
+        const s = (0, date_1.formatLocalizedDatePattern)(may2, 'MMM', { locale: 'cs-CZ' });
+        expect(s).not.toMatch(/^\d+\.?$/);
+    });
+    it('returns textual month for dd MMM in cs (no numeric fallback)', () => {
+        const may2 = new Date(2024, 4, 2);
+        const s = (0, date_1.formatLocalizedDatePattern)(may2, 'dd MMM', { locale: 'cs-CZ' });
+        expect(s.replace(/^02\s*/, '')).not.toMatch(/^\d+\.?$/);
+    });
+});
+describe('formatDate (locale overload)', () => {
+    it('parses yyyy-MM-dd with time like @alphakits/ui', () => {
+        const s = (0, date_1.formatDate)('2024-11-23', {
+            lang: 'ru',
+            time: '14:30',
+            format: 'dd MMMM, HH:mm',
+        });
+        expect(s).toContain('ноября');
+        expect(s).toContain('14:30');
+    });
+});
+describe('formatDate (wall-clock pattern)', () => {
+    it('formats numeric pattern', () => {
+        const d = new Date(2024, 10, 23, 14, 5, 9);
+        expect((0, date_1.formatDate)(d, 'yyyy-MM-dd HH:mm:ss')).toBe('2024-11-23 14:05:09');
+    });
+});
+describe('parseCalendarPattern', () => {
+    it('parses dd.MM.yyyy', () => {
+        const d = (0, date_1.parseCalendarPattern)('23.11.2024', 'dd.MM.yyyy');
+        expect(d.getFullYear()).toBe(2024);
+        expect(d.getMonth()).toBe(10);
+        expect(d.getDate()).toBe(23);
+    });
+});