svelte-date-utils 0.2.0 → 0.5.0

package/dist/AdapterDayjs.d.ts

@@ -0,0 +1,66 @@
+import dayjs from 'dayjs';
+import type { Dayjs } from 'dayjs';
+import type { DateAdapter } from './types.js';
+export interface AdapterDayjsOptions {
+    /** Locale such as `de` or `en-gb`. Import the matching Day.js locale before using it. */
+    locale?: string;
+    /** First day of the week, 0 (Sunday) to 6 (Saturday). Defaults to the locale's first day. */
+    weekStartsOn?: number;
+}
+/** Adapter for Day.js. Values are immutable Day.js `Dayjs` objects. */
+export declare class AdapterDayjs implements DateAdapter<Dayjs> {
+    readonly lib = "dayjs";
+    readonly locale: string;
+    private readonly weekStartsOn?;
+    constructor({ locale, weekStartsOn }?: AdapterDayjsOptions);
+    private withLocale;
+    private getWeekStart;
+    private formatForDayjs;
+    date: (value?: string) => dayjs.Dayjs;
+    getInvalidDate: () => dayjs.Dayjs;
+    isValid: (value: Dayjs | null | undefined) => value is Dayjs;
+    toJsDate: (value: Dayjs) => Date;
+    formatByString: (value: Dayjs, format: string) => string;
+    parse: (value: string, format: string) => dayjs.Dayjs | null;
+    isEqual: (value: Dayjs | null, comparing: Dayjs | null) => boolean;
+    isSameYear: (value: Dayjs, comparing: Dayjs) => boolean;
+    isSameMonth: (value: Dayjs, comparing: Dayjs) => boolean;
+    isSameDay: (value: Dayjs, comparing: Dayjs) => boolean;
+    isAfter: (value: Dayjs, comparing: Dayjs) => boolean;
+    isBefore: (value: Dayjs, comparing: Dayjs) => boolean;
+    isWithinRange: (value: Dayjs, [start, end]: [Dayjs, Dayjs]) => boolean;
+    startOfYear: (value: Dayjs) => dayjs.Dayjs;
+    startOfMonth: (value: Dayjs) => dayjs.Dayjs;
+    startOfWeek: (value: Dayjs) => dayjs.Dayjs;
+    startOfDay: (value: Dayjs) => dayjs.Dayjs;
+    endOfYear: (value: Dayjs) => dayjs.Dayjs;
+    endOfMonth: (value: Dayjs) => dayjs.Dayjs;
+    endOfWeek: (value: Dayjs) => dayjs.Dayjs;
+    endOfDay: (value: Dayjs) => dayjs.Dayjs;
+    addYears: (value: Dayjs, amount: number) => dayjs.Dayjs;
+    addMonths: (value: Dayjs, amount: number) => dayjs.Dayjs;
+    addWeeks: (value: Dayjs, amount: number) => dayjs.Dayjs;
+    addDays: (value: Dayjs, amount: number) => dayjs.Dayjs;
+    addHours: (value: Dayjs, amount: number) => dayjs.Dayjs;
+    addMinutes: (value: Dayjs, amount: number) => dayjs.Dayjs;
+    addSeconds: (value: Dayjs, amount: number) => dayjs.Dayjs;
+    getYear: (value: Dayjs) => number;
+    getMonth: (value: Dayjs) => number;
+    getDate: (value: Dayjs) => number;
+    getHours: (value: Dayjs) => number;
+    getMinutes: (value: Dayjs) => number;
+    getSeconds: (value: Dayjs) => number;
+    getMilliseconds: (value: Dayjs) => number;
+    setYear: (value: Dayjs, year: number) => dayjs.Dayjs;
+    setMonth: (value: Dayjs, month: number) => dayjs.Dayjs;
+    setDate: (value: Dayjs, date: number) => dayjs.Dayjs;
+    setHours: (value: Dayjs, hours: number) => dayjs.Dayjs;
+    setMinutes: (value: Dayjs, minutes: number) => dayjs.Dayjs;
+    setSeconds: (value: Dayjs, seconds: number) => dayjs.Dayjs;
+    setMilliseconds: (value: Dayjs, milliseconds: number) => dayjs.Dayjs;
+    getDaysInMonth: (value: Dayjs) => number;
+    getWeekArray: (value: Dayjs) => dayjs.Dayjs[][];
+    /** Week number where week 1 contains January 1, matching the other adapters. */
+    getWeekNumber: (value: Dayjs) => number;
+    getDayOfWeek: (value: Dayjs) => number;
+}

package/dist/AdapterDayjs.js

@@ -0,0 +1,124 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+import localeData from 'dayjs/plugin/localeData.js';
+dayjs.extend(customParseFormat);
+dayjs.extend(localeData);
+const FORMAT_TOKENS = {
+    yyyy: 'YYYY',
+    yy: 'YY',
+    y: 'YYYY',
+    MMMM: 'MMMM',
+    MMM: 'MMM',
+    MM: 'MM',
+    M: 'M',
+    dd: 'DD',
+    d: 'D',
+    HH: 'HH',
+    H: 'H',
+    hh: 'hh',
+    h: 'h',
+    mm: 'mm',
+    m: 'm',
+    ss: 'ss',
+    s: 's',
+    SSS: 'SSS',
+    a: 'a',
+};
+const FORMAT_TOKEN_PATTERN = /yyyy|MMMM|MMM|yy|y|MM|M|dd|d|HH|H|hh|h|mm|m|ss|s|SSS|a/g;
+/** Adapter for Day.js. Values are immutable Day.js `Dayjs` objects. */
+export class AdapterDayjs {
+    lib = 'dayjs';
+    locale;
+    weekStartsOn;
+    constructor({ locale = 'en', weekStartsOn } = {}) {
+        if (weekStartsOn !== undefined &&
+            (!Number.isInteger(weekStartsOn) || weekStartsOn < 0 || weekStartsOn > 6)) {
+            throw new RangeError('weekStartsOn must be an integer from 0 to 6.');
+        }
+        this.locale = locale.toLowerCase();
+        this.weekStartsOn = weekStartsOn;
+    }
+    withLocale = (value) => value.locale(this.locale);
+    getWeekStart = (value) => this.weekStartsOn ?? this.withLocale(value).localeData().firstDayOfWeek();
+    formatForDayjs = (format) => format.replace(FORMAT_TOKEN_PATTERN, (token) => FORMAT_TOKENS[token] ?? token);
+    date = (value) => value === undefined ? this.withLocale(dayjs()) : this.withLocale(dayjs(value));
+    getInvalidDate = () => this.withLocale(dayjs(Number.NaN));
+    isValid = (value) => value != null && value.isValid();
+    toJsDate = (value) => value.toDate();
+    formatByString = (value, format) => this.withLocale(value).format(this.formatForDayjs(format));
+    parse = (value, format) => value === ''
+        ? null
+        : this.withLocale(dayjs(value, this.formatForDayjs(format), this.locale, true));
+    isEqual = (value, comparing) => value === null || comparing === null
+        ? value === comparing
+        : value.valueOf() === comparing.valueOf();
+    isSameYear = (value, comparing) => value.isSame(comparing, 'year');
+    isSameMonth = (value, comparing) => value.isSame(comparing, 'month');
+    isSameDay = (value, comparing) => value.isSame(comparing, 'day');
+    isAfter = (value, comparing) => value.isAfter(comparing);
+    isBefore = (value, comparing) => value.isBefore(comparing);
+    isWithinRange = (value, [start, end]) => !value.isBefore(start) && !value.isAfter(end);
+    startOfYear = (value) => value.startOf('year');
+    startOfMonth = (value) => value.startOf('month');
+    startOfWeek = (value) => value.startOf('day').subtract((value.day() - this.getWeekStart(value) + 7) % 7, 'day');
+    startOfDay = (value) => value.startOf('day');
+    endOfYear = (value) => value.endOf('year');
+    endOfMonth = (value) => value.endOf('month');
+    endOfWeek = (value) => this.startOfWeek(value).add(6, 'day').endOf('day');
+    endOfDay = (value) => value.endOf('day');
+    addYears = (value, amount) => this.addMonths(value, amount * 12);
+    addMonths = (value, amount) => {
+        const day = value.date();
+        const result = value.date(1).add(amount, 'month');
+        return result.date(Math.min(day, result.daysInMonth()));
+    };
+    addWeeks = (value, amount) => value.add(amount, 'week');
+    addDays = (value, amount) => value.add(amount, 'day');
+    addHours = (value, amount) => value.add(amount, 'hour');
+    addMinutes = (value, amount) => value.add(amount, 'minute');
+    addSeconds = (value, amount) => value.add(amount, 'second');
+    getYear = (value) => value.year();
+    getMonth = (value) => value.month();
+    getDate = (value) => value.date();
+    getHours = (value) => value.hour();
+    getMinutes = (value) => value.minute();
+    getSeconds = (value) => value.second();
+    getMilliseconds = (value) => value.millisecond();
+    setYear = (value, year) => {
+        const day = value.date();
+        const result = value.date(1).year(year);
+        return result.date(Math.min(day, result.daysInMonth()));
+    };
+    setMonth = (value, month) => {
+        const day = value.date();
+        const result = value.date(1).month(month);
+        return result.date(Math.min(day, result.daysInMonth()));
+    };
+    setDate = (value, date) => value.date(date);
+    setHours = (value, hours) => value.hour(hours);
+    setMinutes = (value, minutes) => value.minute(minutes);
+    setSeconds = (value, seconds) => value.second(seconds);
+    setMilliseconds = (value, milliseconds) => value.millisecond(milliseconds);
+    getDaysInMonth = (value) => value.daysInMonth();
+    getWeekArray = (value) => {
+        const start = this.startOfWeek(this.startOfMonth(value));
+        const end = this.endOfWeek(this.endOfMonth(value));
+        const weeks = [];
+        let current = start;
+        for (let count = 0; !current.isAfter(end); count += 1) {
+            (weeks[Math.floor(count / 7)] ??= []).push(current);
+            current = this.addDays(current, 1);
+        }
+        return weeks;
+    };
+    /** Week number where week 1 contains January 1, matching the other adapters. */
+    getWeekNumber = (value) => {
+        const yearStart = this.startOfWeek(this.startOfYear(value));
+        const weekStart = this.startOfWeek(value);
+        const nextYearStart = this.startOfWeek(this.startOfYear(this.addYears(value, 1)));
+        if (!weekStart.isBefore(nextYearStart))
+            return 1;
+        return Math.round(weekStart.diff(yearStart, 'day') / 7) + 1;
+    };
+    getDayOfWeek = (value) => ((value.day() - this.getWeekStart(value) + 7) % 7) + 1;
+}

package/dist/AdapterInternationalizedDate.d.ts

@@ -0,0 +1,66 @@
+import { CalendarDateTime, type DateValue } from '@internationalized/date';
+import type { DateAdapter } from './types.js';
+export interface AdapterInternationalizedDateOptions {
+    /** Locale used for week rules and formatting. Defaults to the user's locale. */
+    locale?: string;
+    /** First day of the week, 0 (Sunday) to 6 (Saturday). Defaults to the locale's first day. */
+    weekStartsOn?: number;
+    /** Time zone used to create and convert dates. Defaults to the system time zone. */
+    timeZone?: string;
+}
+/** Adapter for `@internationalized/date`. Values are its immutable CalendarDate types. */
+export declare class AdapterInternationalizedDate implements DateAdapter<DateValue> {
+    readonly lib = "@internationalized/date";
+    readonly locale: string;
+    readonly timeZone: string;
+    private readonly weekStartsOn?;
+    constructor({ locale, weekStartsOn, timeZone }?: AdapterInternationalizedDateOptions);
+    date: (value?: string) => DateValue;
+    getInvalidDate: () => DateValue;
+    isValid: (value: DateValue | null | undefined) => value is DateValue;
+    toJsDate: (value: DateValue) => Date;
+    private asDateTime;
+    private startDay;
+    formatByString: (value: DateValue, format: string) => string;
+    parse: (value: string, format: string) => DateValue | null;
+    isEqual: (value: DateValue | null, comparing: DateValue | null) => boolean;
+    isSameYear: (value: DateValue, comparing: DateValue) => boolean;
+    isSameMonth: (value: DateValue, comparing: DateValue) => boolean;
+    isSameDay: (value: DateValue, comparing: DateValue) => boolean;
+    isAfter: (value: DateValue, comparing: DateValue) => boolean;
+    isBefore: (value: DateValue, comparing: DateValue) => boolean;
+    isWithinRange: (value: DateValue, [start, end]: [DateValue, DateValue]) => boolean;
+    startOfYear: (value: DateValue) => DateValue;
+    startOfMonth: (value: DateValue) => DateValue;
+    startOfWeek: (value: DateValue) => DateValue;
+    startOfDay: (value: DateValue) => DateValue;
+    endOfYear: (value: DateValue) => DateValue;
+    endOfMonth: (value: DateValue) => DateValue;
+    endOfWeek: (value: DateValue) => DateValue;
+    endOfDay: (value: DateValue) => import("@internationalized/date").CalendarDate | CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    addYears: (value: DateValue, amount: number) => import("@internationalized/date").CalendarDate | CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    addMonths: (value: DateValue, amount: number) => import("@internationalized/date").CalendarDate | CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    addWeeks: (value: DateValue, amount: number) => import("@internationalized/date").CalendarDate | CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    addDays: (value: DateValue, amount: number) => import("@internationalized/date").CalendarDate | CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    addHours: (value: DateValue, amount: number) => CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    addMinutes: (value: DateValue, amount: number) => CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    addSeconds: (value: DateValue, amount: number) => CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    getYear: (value: DateValue) => number;
+    getMonth: (value: DateValue) => number;
+    getDate: (value: DateValue) => number;
+    getHours: (value: DateValue) => number;
+    getMinutes: (value: DateValue) => number;
+    getSeconds: (value: DateValue) => number;
+    getMilliseconds: (value: DateValue) => number;
+    setYear: (value: DateValue, year: number) => import("@internationalized/date").CalendarDate | CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    setMonth: (value: DateValue, month: number) => import("@internationalized/date").CalendarDate | CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    setDate: (value: DateValue, day: number) => import("@internationalized/date").CalendarDate | CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    setHours: (value: DateValue, hour: number) => CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    setMinutes: (value: DateValue, minute: number) => CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    setSeconds: (value: DateValue, second: number) => CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    setMilliseconds: (value: DateValue, millisecond: number) => CalendarDateTime | import("@internationalized/date").ZonedDateTime;
+    getDaysInMonth: (value: DateValue) => number;
+    getWeekArray: (value: DateValue) => DateValue[][];
+    getWeekNumber: (value: DateValue) => number;
+    getDayOfWeek: (value: DateValue) => number;
+}

package/dist/AdapterInternationalizedDate.js

@@ -0,0 +1,144 @@
+import { CalendarDateTime, endOfMonth, endOfWeek, endOfYear, getLocalTimeZone, getDayOfWeek, isSameDay, isSameMonth, isSameYear, now, parseDate, parseDateTime, parseZonedDateTime, startOfMonth, startOfWeek, startOfYear, toCalendarDateTime, } from '@internationalized/date';
+const WEEKDAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+const invalidValues = new WeakSet();
+/** Adapter for `@internationalized/date`. Values are its immutable CalendarDate types. */
+export class AdapterInternationalizedDate {
+    lib = '@internationalized/date';
+    locale;
+    timeZone;
+    weekStartsOn;
+    constructor({ locale, weekStartsOn, timeZone } = {}) {
+        this.locale = locale ?? (typeof navigator === 'undefined' ? 'en-US' : navigator.language);
+        this.timeZone = timeZone ?? getLocalTimeZone();
+        if (weekStartsOn !== undefined) {
+            if (!Number.isInteger(weekStartsOn) || weekStartsOn < 0 || weekStartsOn > 6) {
+                throw new RangeError('weekStartsOn must be an integer from 0 to 6.');
+            }
+            this.weekStartsOn = WEEKDAYS[weekStartsOn];
+        }
+    }
+    date = (value) => {
+        if (value === undefined)
+            return toCalendarDateTime(now(this.timeZone));
+        try {
+            if (/T.*(?:Z|[+-]\d{2}:?\d{2})$/.test(value))
+                return parseZonedDateTime(value);
+            return value.includes('T') ? parseDateTime(value) : parseDate(value);
+        }
+        catch {
+            return this.getInvalidDate();
+        }
+    };
+    getInvalidDate = () => {
+        const value = new CalendarDateTime(1, 1, 1);
+        invalidValues.add(value);
+        return value;
+    };
+    isValid = (value) => value != null && !invalidValues.has(value);
+    toJsDate = (value) => 'timeZone' in value ? value.toDate() : value.toDate(this.timeZone);
+    asDateTime = (value) => toCalendarDateTime(value);
+    startDay = (value) => 'hour' in value ? value.set({ hour: 0, minute: 0, second: 0, millisecond: 0 }) : value;
+    formatByString = (value, format) => {
+        const pad = (number, size = 2) => String(number).padStart(size, '0');
+        const tokens = {
+            yyyy: pad(value.year, 4),
+            MM: pad(value.month),
+            dd: pad(value.day),
+            HH: pad(this.getHours(value)),
+            mm: pad(this.getMinutes(value)),
+            ss: pad(this.getSeconds(value)),
+            SSS: pad(this.getMilliseconds(value), 3),
+        };
+        return format.replace(/yyyy|SSS|MM|dd|HH|mm|ss/g, (token) => tokens[token] ?? token);
+    };
+    parse = (value, format) => {
+        if (value === '')
+            return null;
+        const order = [];
+        const source = format
+            .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+            .replace(/yyyy|SSS|MM|dd|HH|mm|ss/g, (token) => {
+            order.push(token);
+            return `(\\d{${token.length}})`;
+        });
+        const match = new RegExp(`^${source}$`).exec(value);
+        if (!match)
+            return this.getInvalidDate();
+        const part = (token, fallback) => {
+            const index = order.indexOf(token);
+            return index === -1 ? fallback : Number(match[index + 1]);
+        };
+        try {
+            const year = part('yyyy', 1970);
+            const month = part('MM', 1);
+            const day = part('dd', 1);
+            return order.some((token) => ['HH', 'mm', 'ss', 'SSS'].includes(token))
+                ? new CalendarDateTime(year, month, day, part('HH', 0), part('mm', 0), part('ss', 0), part('SSS', 0))
+                : parseDate(`${String(year).padStart(4, '0')}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`);
+        }
+        catch {
+            return this.getInvalidDate();
+        }
+    };
+    isEqual = (value, comparing) => value === null || comparing === null ? value === comparing : value.compare(comparing) === 0;
+    isSameYear = (value, comparing) => isSameYear(value, comparing);
+    isSameMonth = (value, comparing) => isSameMonth(value, comparing);
+    isSameDay = (value, comparing) => isSameDay(value, comparing);
+    isAfter = (value, comparing) => value.compare(comparing) > 0;
+    isBefore = (value, comparing) => value.compare(comparing) < 0;
+    isWithinRange = (value, [start, end]) => value.compare(start) >= 0 && value.compare(end) <= 0;
+    startOfYear = (value) => startOfYear(value);
+    startOfMonth = (value) => startOfMonth(value);
+    startOfWeek = (value) => startOfWeek(value, this.locale, this.weekStartsOn);
+    startOfDay = (value) => this.startDay(value);
+    endOfYear = (value) => endOfYear(value);
+    endOfMonth = (value) => endOfMonth(value);
+    endOfWeek = (value) => endOfWeek(value, this.locale, this.weekStartsOn);
+    endOfDay = (value) => 'hour' in value ? this.startDay(value).add({ days: 1 }).subtract({ milliseconds: 1 }) : value;
+    addYears = (value, amount) => value.add({ years: amount });
+    addMonths = (value, amount) => value.add({ months: amount });
+    addWeeks = (value, amount) => value.add({ weeks: amount });
+    addDays = (value, amount) => value.add({ days: amount });
+    addHours = (value, amount) => 'hour' in value ? value.add({ hours: amount }) : this.asDateTime(value).add({ hours: amount });
+    addMinutes = (value, amount) => 'hour' in value
+        ? value.add({ minutes: amount })
+        : this.asDateTime(value).add({ minutes: amount });
+    addSeconds = (value, amount) => 'hour' in value
+        ? value.add({ seconds: amount })
+        : this.asDateTime(value).add({ seconds: amount });
+    getYear = (value) => value.year;
+    getMonth = (value) => value.month - 1;
+    getDate = (value) => value.day;
+    getHours = (value) => ('hour' in value ? value.hour : 0);
+    getMinutes = (value) => ('minute' in value ? value.minute : 0);
+    getSeconds = (value) => ('second' in value ? value.second : 0);
+    getMilliseconds = (value) => ('millisecond' in value ? value.millisecond : 0);
+    setYear = (value, year) => value.set({ year });
+    setMonth = (value, month) => value.set({ month: month + 1 });
+    setDate = (value, day) => value.set({ day });
+    setHours = (value, hour) => 'hour' in value ? value.set({ hour }) : this.asDateTime(value).set({ hour });
+    setMinutes = (value, minute) => 'hour' in value ? value.set({ minute }) : this.asDateTime(value).set({ minute });
+    setSeconds = (value, second) => 'hour' in value ? value.set({ second }) : this.asDateTime(value).set({ second });
+    setMilliseconds = (value, millisecond) => 'hour' in value ? value.set({ millisecond }) : this.asDateTime(value).set({ millisecond });
+    getDaysInMonth = (value) => value.calendar.getDaysInMonth(value);
+    getWeekArray = (value) => {
+        const start = this.startOfWeek(this.startOfMonth(value));
+        const end = this.endOfWeek(this.endOfMonth(value));
+        const weeks = [];
+        let current = start;
+        for (let count = 0; current.compare(end) <= 0; count += 1) {
+            (weeks[Math.floor(count / 7)] ??= []).push(current);
+            current = current.add({ days: 1 });
+        }
+        return weeks;
+    };
+    getWeekNumber = (value) => {
+        const yearStart = this.startOfWeek(this.startOfYear(value));
+        const weekStart = this.startOfWeek(value);
+        const nextYearStart = this.startOfWeek(this.startOfYear(value.add({ years: 1 })));
+        if (weekStart.compare(nextYearStart) >= 0)
+            return 1;
+        return Math.round((+this.toJsDate(weekStart) - +this.toJsDate(yearStart)) / 604_800_000) + 1;
+    };
+    getDayOfWeek = (value) => getDayOfWeek(value, this.locale, this.weekStartsOn) + 1;
+}

package/dist/context.d.ts

@@ -0,0 +1,5 @@
+import type { DateAdapter } from './types.js';
+/** Makes an adapter available to date components rendered below the current Svelte component. */
+export declare function provideDateAdapter<T>(adapter: DateAdapter<T>): void;
+/** Reads the adapter from the current component tree, throwing when no provider is present. */
+export declare function getDateAdapter<T>(componentName: string): DateAdapter<T>;

package/dist/context.js

@@ -0,0 +1,14 @@
+import { getContext, setContext } from 'svelte';
+const dateAdapterContextKey = Symbol.for('svelte-date-utils.date-adapter');
+/** Makes an adapter available to date components rendered below the current Svelte component. */
+export function provideDateAdapter(adapter) {
+    setContext(dateAdapterContextKey, adapter);
+}
+/** Reads the adapter from the current component tree, throwing when no provider is present. */
+export function getDateAdapter(componentName) {
+    const adapter = getContext(dateAdapterContextKey);
+    if (!adapter) {
+        throw new Error(`${componentName} requires a date adapter context. Call provideDateAdapter(adapter) in a parent component.`);
+    }
+    return adapter;
+}

package/dist/dayjs.d.ts

@@ -0,0 +1,2 @@
+export { AdapterDayjs } from './AdapterDayjs.js';
+export type { AdapterDayjsOptions } from './AdapterDayjs.js';

package/dist/dayjs.js

@@ -0,0 +1 @@
+export { AdapterDayjs } from './AdapterDayjs.js';

package/dist/getUserLocale.d.ts

@@ -0,0 +1,13 @@
+export interface UserLocaleOptions {
+    /** Add `fallbackLocale` at the end of the list. Defaults to true. */
+    useFallbackLocale?: boolean;
+    /** Defaults to `en-US`. */
+    fallbackLocale?: string;
+}
+/** The locales of the browser, most preferred first, without duplicates. */
+export declare function getUserLocales({ useFallbackLocale, fallbackLocale, }?: UserLocaleOptions): string[];
+/** The most preferred locale of the browser. With `useFallbackLocale: false` there may be none. */
+export declare function getUserLocale(options?: UserLocaleOptions & {
+    useFallbackLocale?: true;
+}): string;
+export declare function getUserLocale(options: UserLocaleOptions): string | undefined;

package/dist/getUserLocale.js

@@ -0,0 +1,39 @@
+// A dependency-free replacement for `get-user-locale` (and its `memoize` dependency).
+const splitCommas = (locale) => (locale.includes(',') ? locale.split(',') : [locale]);
+/** Turns `en-us` into `en-US`, `en-US.UTF-8` and `en-US@posix` into `en-US`, and `C` into `en-US`. */
+function normalizeLocale(locale) {
+    if (!locale)
+        return locale;
+    if (locale === 'C' || locale === 'posix' || locale === 'POSIX')
+        return 'en-US';
+    // "en-US.UTF-8": keep the part before the dot
+    if (locale.includes('.'))
+        return normalizeLocale(locale.split('.')[0] ?? '');
+    // "en-US@posix": keep the part before the at sign
+    if (locale.includes('@'))
+        return normalizeLocale(locale.split('@')[0] ?? '');
+    // already "en-US", or has no region
+    if (!locale.includes('-') || locale.toLowerCase() !== locale)
+        return locale;
+    const [language, region = ''] = locale.split('-');
+    return `${language}-${region.toUpperCase()}`;
+}
+/** The locales of the browser, most preferred first, without duplicates. */
+export function getUserLocales({ useFallbackLocale = true, fallbackLocale = 'en-US', } = {}) {
+    const list = [];
+    if (typeof navigator !== 'undefined') {
+        for (const language of navigator.languages ?? [])
+            list.push(...splitCommas(language));
+        if (navigator.language)
+            list.push(...splitCommas(navigator.language));
+    }
+    if (useFallbackLocale)
+        list.push(fallbackLocale);
+    return list
+        .filter((locale) => typeof locale === 'string')
+        .map(normalizeLocale)
+        .filter((locale, index, all) => all.indexOf(locale) === index);
+}
+export function getUserLocale(options) {
+    return getUserLocales(options)[0];
+}

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 export { AdapterDate } from './AdapterDate.js';
 export type { AdapterDateOptions } from './AdapterDate.js';
 export { createDateUtils } from './createDateUtils.js';
+export { getDateAdapter, provideDateAdapter } from './context.js';
 export type { DateUtils, TimeLike, YearLike } from './createDateUtils.js';
 export type { DateAdapter } from './types.js';
+export { getUserLocale, getUserLocales } from './getUserLocale.js';
+export type { UserLocaleOptions } from './getUserLocale.js';
 /**
  * The helpers on the native `Date`, with the names and behavior of `@wojtekmaj/date-utils`.
  * For date-fns or Luxon, call `createDateUtils` with `AdapterDateFns` or `AdapterLuxon`

package/dist/index.js

@@ -2,6 +2,8 @@ import { AdapterDate } from './AdapterDate.js';
 import { createDateUtils } from './createDateUtils.js';
 export { AdapterDate } from './AdapterDate.js';
 export { createDateUtils } from './createDateUtils.js';
+export { getDateAdapter, provideDateAdapter } from './context.js';
+export { getUserLocale, getUserLocales } from './getUserLocale.js';
 /**
  * The helpers on the native `Date`, with the names and behavior of `@wojtekmaj/date-utils`.
  * For date-fns or Luxon, call `createDateUtils` with `AdapterDateFns` or `AdapterLuxon`

package/dist/internationalized.d.ts

@@ -0,0 +1,2 @@
+export { AdapterInternationalizedDate } from './AdapterInternationalizedDate.js';
+export type { AdapterInternationalizedDateOptions } from './AdapterInternationalizedDate.js';

package/dist/internationalized.js

@@ -0,0 +1 @@
+export { AdapterInternationalizedDate } from './AdapterInternationalizedDate.js';

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "svelte-date-utils",
-  "version": "0.2.0",
-  "description": "Date helpers for calendars and date inputs (start, end, previous, next and range of a century, decade, year, month and day) that work on native Date, date-fns or Luxon through adapters.",
+  "version": "0.5.0",
+  "description": "Date helpers for calendars and date inputs (start, end, previous, next and range of a century, decade, year, month and day) with native Date, date-fns, Day.js, Luxon and @internationalized/date adapters.",
   "keywords": [
     "date",
     "date-fns",
+    "dayjs",
     "luxon",
     "svelte",
     "utils"
@@ -31,9 +32,17 @@
       "types": "./dist/date-fns.d.ts",
       "default": "./dist/date-fns.js"
     },
+    "./dayjs": {
+      "types": "./dist/dayjs.d.ts",
+      "default": "./dist/dayjs.js"
+    },
     "./luxon": {
       "types": "./dist/luxon.d.ts",
       "default": "./dist/luxon.js"
+    },
+    "./internationalized": {
+      "types": "./dist/internationalized.d.ts",
+      "default": "./dist/internationalized.js"
     }
   },
   "publishConfig": {
@@ -52,26 +61,41 @@
     "watch": "tsc -p tsconfig.build.json --watch"
   },
   "devDependencies": {
+    "@internationalized/date": "^3.12.4",
     "@types/luxon": "^3.7.1",
     "@vitest/browser-playwright": "5.0.5",
     "date-fns": "^4.1.0",
+    "dayjs": "^1.11.23",
     "luxon": "^3.7.2",
     "playwright": "^1.64.1",
+    "svelte": "^5.0.0",
     "typescript": "^6.0.3",
     "vite": "npm:@voidzero-dev/vite-plus-core@1.4.0",
     "vite-plus": "1.4.0",
     "vitest": "5.0.5"
   },
   "peerDependencies": {
+    "@internationalized/date": "^3.12.4",
     "date-fns": "^3.2.0 || ^4.0.0",
-    "luxon": "^3.0.2"
+    "dayjs": "^1.11.23",
+    "luxon": "^3.0.2",
+    "svelte": "^5.0.0"
   },
   "peerDependenciesMeta": {
+    "@internationalized/date": {
+      "optional": true
+    },
     "date-fns": {
       "optional": true
     },
     "luxon": {
       "optional": true
+    },
+    "dayjs": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
     }
   }
 }

package/src/AdapterDayjs.ts

@@ -0,0 +1,159 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
+import localeData from 'dayjs/plugin/localeData.js';
+
+import type { Dayjs } from 'dayjs';
+import type { DateAdapter } from './types.js';
+
+dayjs.extend(customParseFormat);
+dayjs.extend(localeData);
+
+const FORMAT_TOKENS: Record<string, string> = {
+  yyyy: 'YYYY',
+  yy: 'YY',
+  y: 'YYYY',
+  MMMM: 'MMMM',
+  MMM: 'MMM',
+  MM: 'MM',
+  M: 'M',
+  dd: 'DD',
+  d: 'D',
+  HH: 'HH',
+  H: 'H',
+  hh: 'hh',
+  h: 'h',
+  mm: 'mm',
+  m: 'm',
+  ss: 'ss',
+  s: 's',
+  SSS: 'SSS',
+  a: 'a',
+};
+
+const FORMAT_TOKEN_PATTERN = /yyyy|MMMM|MMM|yy|y|MM|M|dd|d|HH|H|hh|h|mm|m|ss|s|SSS|a/g;
+
+export interface AdapterDayjsOptions {
+  /** Locale such as `de` or `en-gb`. Import the matching Day.js locale before using it. */
+  locale?: string;
+  /** First day of the week, 0 (Sunday) to 6 (Saturday). Defaults to the locale's first day. */
+  weekStartsOn?: number;
+}
+
+/** Adapter for Day.js. Values are immutable Day.js `Dayjs` objects. */
+export class AdapterDayjs implements DateAdapter<Dayjs> {
+  public readonly lib = 'dayjs';
+  public readonly locale: string;
+  private readonly weekStartsOn?: number;
+
+  constructor({ locale = 'en', weekStartsOn }: AdapterDayjsOptions = {}) {
+    if (
+      weekStartsOn !== undefined &&
+      (!Number.isInteger(weekStartsOn) || weekStartsOn < 0 || weekStartsOn > 6)
+    ) {
+      throw new RangeError('weekStartsOn must be an integer from 0 to 6.');
+    }
+    this.locale = locale.toLowerCase();
+    this.weekStartsOn = weekStartsOn;
+  }
+
+  private withLocale = (value: Dayjs) => value.locale(this.locale);
+  private getWeekStart = (value: Dayjs) =>
+    this.weekStartsOn ?? this.withLocale(value).localeData().firstDayOfWeek();
+  private formatForDayjs = (format: string) =>
+    format.replace(FORMAT_TOKEN_PATTERN, (token) => FORMAT_TOKENS[token] ?? token);
+
+  public date = (value?: string) =>
+    value === undefined ? this.withLocale(dayjs()) : this.withLocale(dayjs(value));
+  public getInvalidDate = () => this.withLocale(dayjs(Number.NaN));
+  public isValid = (value: Dayjs | null | undefined): value is Dayjs =>
+    value != null && value.isValid();
+  public toJsDate = (value: Dayjs) => value.toDate();
+
+  public formatByString = (value: Dayjs, format: string) =>
+    this.withLocale(value).format(this.formatForDayjs(format));
+  public parse = (value: string, format: string) =>
+    value === ''
+      ? null
+      : this.withLocale(dayjs(value, this.formatForDayjs(format), this.locale, true));
+
+  public isEqual = (value: Dayjs | null, comparing: Dayjs | null) =>
+    value === null || comparing === null
+      ? value === comparing
+      : value.valueOf() === comparing.valueOf();
+  public isSameYear = (value: Dayjs, comparing: Dayjs) => value.isSame(comparing, 'year');
+  public isSameMonth = (value: Dayjs, comparing: Dayjs) => value.isSame(comparing, 'month');
+  public isSameDay = (value: Dayjs, comparing: Dayjs) => value.isSame(comparing, 'day');
+  public isAfter = (value: Dayjs, comparing: Dayjs) => value.isAfter(comparing);
+  public isBefore = (value: Dayjs, comparing: Dayjs) => value.isBefore(comparing);
+  public isWithinRange = (value: Dayjs, [start, end]: [Dayjs, Dayjs]) =>
+    !value.isBefore(start) && !value.isAfter(end);
+
+  public startOfYear = (value: Dayjs) => value.startOf('year');
+  public startOfMonth = (value: Dayjs) => value.startOf('month');
+  public startOfWeek = (value: Dayjs) =>
+    value.startOf('day').subtract((value.day() - this.getWeekStart(value) + 7) % 7, 'day');
+  public startOfDay = (value: Dayjs) => value.startOf('day');
+  public endOfYear = (value: Dayjs) => value.endOf('year');
+  public endOfMonth = (value: Dayjs) => value.endOf('month');
+  public endOfWeek = (value: Dayjs) => this.startOfWeek(value).add(6, 'day').endOf('day');
+  public endOfDay = (value: Dayjs) => value.endOf('day');
+
+  public addYears = (value: Dayjs, amount: number) => this.addMonths(value, amount * 12);
+  public addMonths = (value: Dayjs, amount: number) => {
+    const day = value.date();
+    const result = value.date(1).add(amount, 'month');
+    return result.date(Math.min(day, result.daysInMonth()));
+  };
+  public addWeeks = (value: Dayjs, amount: number) => value.add(amount, 'week');
+  public addDays = (value: Dayjs, amount: number) => value.add(amount, 'day');
+  public addHours = (value: Dayjs, amount: number) => value.add(amount, 'hour');
+  public addMinutes = (value: Dayjs, amount: number) => value.add(amount, 'minute');
+  public addSeconds = (value: Dayjs, amount: number) => value.add(amount, 'second');
+
+  public getYear = (value: Dayjs) => value.year();
+  public getMonth = (value: Dayjs) => value.month();
+  public getDate = (value: Dayjs) => value.date();
+  public getHours = (value: Dayjs) => value.hour();
+  public getMinutes = (value: Dayjs) => value.minute();
+  public getSeconds = (value: Dayjs) => value.second();
+  public getMilliseconds = (value: Dayjs) => value.millisecond();
+
+  public setYear = (value: Dayjs, year: number) => {
+    const day = value.date();
+    const result = value.date(1).year(year);
+    return result.date(Math.min(day, result.daysInMonth()));
+  };
+  public setMonth = (value: Dayjs, month: number) => {
+    const day = value.date();
+    const result = value.date(1).month(month);
+    return result.date(Math.min(day, result.daysInMonth()));
+  };
+  public setDate = (value: Dayjs, date: number) => value.date(date);
+  public setHours = (value: Dayjs, hours: number) => value.hour(hours);
+  public setMinutes = (value: Dayjs, minutes: number) => value.minute(minutes);
+  public setSeconds = (value: Dayjs, seconds: number) => value.second(seconds);
+  public setMilliseconds = (value: Dayjs, milliseconds: number) => value.millisecond(milliseconds);
+
+  public getDaysInMonth = (value: Dayjs) => value.daysInMonth();
+  public getWeekArray = (value: Dayjs) => {
+    const start = this.startOfWeek(this.startOfMonth(value));
+    const end = this.endOfWeek(this.endOfMonth(value));
+    const weeks: Dayjs[][] = [];
+    let current = start;
+    for (let count = 0; !current.isAfter(end); count += 1) {
+      (weeks[Math.floor(count / 7)] ??= []).push(current);
+      current = this.addDays(current, 1);
+    }
+    return weeks;
+  };
+
+  /** Week number where week 1 contains January 1, matching the other adapters. */
+  public getWeekNumber = (value: Dayjs) => {
+    const yearStart = this.startOfWeek(this.startOfYear(value));
+    const weekStart = this.startOfWeek(value);
+    const nextYearStart = this.startOfWeek(this.startOfYear(this.addYears(value, 1)));
+    if (!weekStart.isBefore(nextYearStart)) return 1;
+    return Math.round(weekStart.diff(yearStart, 'day') / 7) + 1;
+  };
+  public getDayOfWeek = (value: Dayjs) => ((value.day() - this.getWeekStart(value) + 7) % 7) + 1;
+}

package/src/AdapterInternationalizedDate.ts

@@ -0,0 +1,202 @@
+import {
+  CalendarDateTime,
+  endOfMonth,
+  endOfWeek,
+  endOfYear,
+  getLocalTimeZone,
+  getDayOfWeek,
+  isSameDay,
+  isSameMonth,
+  isSameYear,
+  now,
+  parseDate,
+  parseDateTime,
+  parseZonedDateTime,
+  startOfMonth,
+  startOfWeek,
+  startOfYear,
+  toCalendarDateTime,
+  type DateValue,
+} from '@internationalized/date';
+import type { DateAdapter } from './types.js';
+
+const WEEKDAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'] as const;
+const invalidValues = new WeakSet<object>();
+
+export interface AdapterInternationalizedDateOptions {
+  /** Locale used for week rules and formatting. Defaults to the user's locale. */
+  locale?: string;
+  /** First day of the week, 0 (Sunday) to 6 (Saturday). Defaults to the locale's first day. */
+  weekStartsOn?: number;
+  /** Time zone used to create and convert dates. Defaults to the system time zone. */
+  timeZone?: string;
+}
+
+/** Adapter for `@internationalized/date`. Values are its immutable CalendarDate types. */
+export class AdapterInternationalizedDate implements DateAdapter<DateValue> {
+  public readonly lib = '@internationalized/date';
+  public readonly locale: string;
+  public readonly timeZone: string;
+  private readonly weekStartsOn?: (typeof WEEKDAYS)[number];
+
+  constructor({ locale, weekStartsOn, timeZone }: AdapterInternationalizedDateOptions = {}) {
+    this.locale = locale ?? (typeof navigator === 'undefined' ? 'en-US' : navigator.language);
+    this.timeZone = timeZone ?? getLocalTimeZone();
+    if (weekStartsOn !== undefined) {
+      if (!Number.isInteger(weekStartsOn) || weekStartsOn < 0 || weekStartsOn > 6) {
+        throw new RangeError('weekStartsOn must be an integer from 0 to 6.');
+      }
+      this.weekStartsOn = WEEKDAYS[weekStartsOn];
+    }
+  }
+
+  public date = (value?: string): DateValue => {
+    if (value === undefined) return toCalendarDateTime(now(this.timeZone));
+    try {
+      if (/T.*(?:Z|[+-]\d{2}:?\d{2})$/.test(value)) return parseZonedDateTime(value);
+      return value.includes('T') ? parseDateTime(value) : parseDate(value);
+    } catch {
+      return this.getInvalidDate();
+    }
+  };
+  public getInvalidDate = (): DateValue => {
+    const value = new CalendarDateTime(1, 1, 1);
+    invalidValues.add(value);
+    return value;
+  };
+  public isValid = (value: DateValue | null | undefined): value is DateValue =>
+    value != null && !invalidValues.has(value);
+  public toJsDate = (value: DateValue) =>
+    'timeZone' in value ? value.toDate() : value.toDate(this.timeZone);
+
+  private asDateTime = (value: DateValue) => toCalendarDateTime(value);
+  private startDay = (value: DateValue): DateValue =>
+    'hour' in value ? value.set({ hour: 0, minute: 0, second: 0, millisecond: 0 }) : value;
+  public formatByString = (value: DateValue, format: string) => {
+    const pad = (number: number, size = 2) => String(number).padStart(size, '0');
+    const tokens: Record<string, string> = {
+      yyyy: pad(value.year, 4),
+      MM: pad(value.month),
+      dd: pad(value.day),
+      HH: pad(this.getHours(value)),
+      mm: pad(this.getMinutes(value)),
+      ss: pad(this.getSeconds(value)),
+      SSS: pad(this.getMilliseconds(value), 3),
+    };
+    return format.replace(/yyyy|SSS|MM|dd|HH|mm|ss/g, (token) => tokens[token] ?? token);
+  };
+
+  public parse = (value: string, format: string): DateValue | null => {
+    if (value === '') return null;
+    const order: string[] = [];
+    const source = format
+      .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      .replace(/yyyy|SSS|MM|dd|HH|mm|ss/g, (token) => {
+        order.push(token);
+        return `(\\d{${token.length}})`;
+      });
+    const match = new RegExp(`^${source}$`).exec(value);
+    if (!match) return this.getInvalidDate();
+    const part = (token: string, fallback: number) => {
+      const index = order.indexOf(token);
+      return index === -1 ? fallback : Number(match[index + 1]);
+    };
+    try {
+      const year = part('yyyy', 1970);
+      const month = part('MM', 1);
+      const day = part('dd', 1);
+      return order.some((token) => ['HH', 'mm', 'ss', 'SSS'].includes(token))
+        ? new CalendarDateTime(
+            year,
+            month,
+            day,
+            part('HH', 0),
+            part('mm', 0),
+            part('ss', 0),
+            part('SSS', 0),
+          )
+        : parseDate(
+            `${String(year).padStart(4, '0')}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`,
+          );
+    } catch {
+      return this.getInvalidDate();
+    }
+  };
+
+  public isEqual = (value: DateValue | null, comparing: DateValue | null) =>
+    value === null || comparing === null ? value === comparing : value.compare(comparing) === 0;
+  public isSameYear = (value: DateValue, comparing: DateValue) => isSameYear(value, comparing);
+  public isSameMonth = (value: DateValue, comparing: DateValue) => isSameMonth(value, comparing);
+  public isSameDay = (value: DateValue, comparing: DateValue) => isSameDay(value, comparing);
+  public isAfter = (value: DateValue, comparing: DateValue) => value.compare(comparing) > 0;
+  public isBefore = (value: DateValue, comparing: DateValue) => value.compare(comparing) < 0;
+  public isWithinRange = (value: DateValue, [start, end]: [DateValue, DateValue]) =>
+    value.compare(start) >= 0 && value.compare(end) <= 0;
+
+  public startOfYear = (value: DateValue) => startOfYear(value);
+  public startOfMonth = (value: DateValue) => startOfMonth(value);
+  public startOfWeek = (value: DateValue) => startOfWeek(value, this.locale, this.weekStartsOn);
+  public startOfDay = (value: DateValue) => this.startDay(value);
+  public endOfYear = (value: DateValue) => endOfYear(value);
+  public endOfMonth = (value: DateValue) => endOfMonth(value);
+  public endOfWeek = (value: DateValue) => endOfWeek(value, this.locale, this.weekStartsOn);
+  public endOfDay = (value: DateValue) =>
+    'hour' in value ? this.startDay(value).add({ days: 1 }).subtract({ milliseconds: 1 }) : value;
+
+  public addYears = (value: DateValue, amount: number) => value.add({ years: amount });
+  public addMonths = (value: DateValue, amount: number) => value.add({ months: amount });
+  public addWeeks = (value: DateValue, amount: number) => value.add({ weeks: amount });
+  public addDays = (value: DateValue, amount: number) => value.add({ days: amount });
+  public addHours = (value: DateValue, amount: number) =>
+    'hour' in value ? value.add({ hours: amount }) : this.asDateTime(value).add({ hours: amount });
+  public addMinutes = (value: DateValue, amount: number) =>
+    'hour' in value
+      ? value.add({ minutes: amount })
+      : this.asDateTime(value).add({ minutes: amount });
+  public addSeconds = (value: DateValue, amount: number) =>
+    'hour' in value
+      ? value.add({ seconds: amount })
+      : this.asDateTime(value).add({ seconds: amount });
+
+  public getYear = (value: DateValue) => value.year;
+  public getMonth = (value: DateValue) => value.month - 1;
+  public getDate = (value: DateValue) => value.day;
+  public getHours = (value: DateValue) => ('hour' in value ? value.hour : 0);
+  public getMinutes = (value: DateValue) => ('minute' in value ? value.minute : 0);
+  public getSeconds = (value: DateValue) => ('second' in value ? value.second : 0);
+  public getMilliseconds = (value: DateValue) => ('millisecond' in value ? value.millisecond : 0);
+
+  public setYear = (value: DateValue, year: number) => value.set({ year });
+  public setMonth = (value: DateValue, month: number) => value.set({ month: month + 1 });
+  public setDate = (value: DateValue, day: number) => value.set({ day });
+  public setHours = (value: DateValue, hour: number) =>
+    'hour' in value ? value.set({ hour }) : this.asDateTime(value).set({ hour });
+  public setMinutes = (value: DateValue, minute: number) =>
+    'hour' in value ? value.set({ minute }) : this.asDateTime(value).set({ minute });
+  public setSeconds = (value: DateValue, second: number) =>
+    'hour' in value ? value.set({ second }) : this.asDateTime(value).set({ second });
+  public setMilliseconds = (value: DateValue, millisecond: number) =>
+    'hour' in value ? value.set({ millisecond }) : this.asDateTime(value).set({ millisecond });
+
+  public getDaysInMonth = (value: DateValue) => value.calendar.getDaysInMonth(value);
+  public getWeekArray = (value: DateValue) => {
+    const start = this.startOfWeek(this.startOfMonth(value));
+    const end = this.endOfWeek(this.endOfMonth(value));
+    const weeks: DateValue[][] = [];
+    let current = start;
+    for (let count = 0; current.compare(end) <= 0; count += 1) {
+      (weeks[Math.floor(count / 7)] ??= []).push(current);
+      current = current.add({ days: 1 });
+    }
+    return weeks;
+  };
+  public getWeekNumber = (value: DateValue) => {
+    const yearStart = this.startOfWeek(this.startOfYear(value));
+    const weekStart = this.startOfWeek(value);
+    const nextYearStart = this.startOfWeek(this.startOfYear(value.add({ years: 1 })));
+    if (weekStart.compare(nextYearStart) >= 0) return 1;
+    return Math.round((+this.toJsDate(weekStart) - +this.toJsDate(yearStart)) / 604_800_000) + 1;
+  };
+  public getDayOfWeek = (value: DateValue) =>
+    getDayOfWeek(value, this.locale, this.weekStartsOn) + 1;
+}

package/src/context.ts

@@ -0,0 +1,20 @@
+import { getContext, setContext } from 'svelte';
+import type { DateAdapter } from './types.js';
+
+const dateAdapterContextKey = Symbol.for('svelte-date-utils.date-adapter');
+
+/** Makes an adapter available to date components rendered below the current Svelte component. */
+export function provideDateAdapter<T>(adapter: DateAdapter<T>): void {
+  setContext(dateAdapterContextKey, adapter);
+}
+
+/** Reads the adapter from the current component tree, throwing when no provider is present. */
+export function getDateAdapter<T>(componentName: string): DateAdapter<T> {
+  const adapter = getContext<DateAdapter<T> | undefined>(dateAdapterContextKey);
+  if (!adapter) {
+    throw new Error(
+      `${componentName} requires a date adapter context. Call provideDateAdapter(adapter) in a parent component.`,
+    );
+  }
+  return adapter;
+}

package/src/dayjs.ts

@@ -0,0 +1,2 @@
+export { AdapterDayjs } from './AdapterDayjs.js';
+export type { AdapterDayjsOptions } from './AdapterDayjs.js';

package/src/getUserLocale.ts

@@ -0,0 +1,50 @@
+// A dependency-free replacement for `get-user-locale` (and its `memoize` dependency).
+
+export interface UserLocaleOptions {
+  /** Add `fallbackLocale` at the end of the list. Defaults to true. */
+  useFallbackLocale?: boolean;
+  /** Defaults to `en-US`. */
+  fallbackLocale?: string;
+}
+
+const splitCommas = (locale: string) => (locale.includes(',') ? locale.split(',') : [locale]);
+
+/** Turns `en-us` into `en-US`, `en-US.UTF-8` and `en-US@posix` into `en-US`, and `C` into `en-US`. */
+function normalizeLocale(locale: string): string {
+  if (!locale) return locale;
+  if (locale === 'C' || locale === 'posix' || locale === 'POSIX') return 'en-US';
+  // "en-US.UTF-8": keep the part before the dot
+  if (locale.includes('.')) return normalizeLocale(locale.split('.')[0] ?? '');
+  // "en-US@posix": keep the part before the at sign
+  if (locale.includes('@')) return normalizeLocale(locale.split('@')[0] ?? '');
+  // already "en-US", or has no region
+  if (!locale.includes('-') || locale.toLowerCase() !== locale) return locale;
+  const [language, region = ''] = locale.split('-');
+  return `${language}-${region.toUpperCase()}`;
+}
+
+/** The locales of the browser, most preferred first, without duplicates. */
+export function getUserLocales({
+  useFallbackLocale = true,
+  fallbackLocale = 'en-US',
+}: UserLocaleOptions = {}): string[] {
+  const list: unknown[] = [];
+
+  if (typeof navigator !== 'undefined') {
+    for (const language of navigator.languages ?? []) list.push(...splitCommas(language));
+    if (navigator.language) list.push(...splitCommas(navigator.language));
+  }
+  if (useFallbackLocale) list.push(fallbackLocale);
+
+  return list
+    .filter((locale): locale is string => typeof locale === 'string')
+    .map(normalizeLocale)
+    .filter((locale, index, all) => all.indexOf(locale) === index);
+}
+
+/** The most preferred locale of the browser. With `useFallbackLocale: false` there may be none. */
+export function getUserLocale(options?: UserLocaleOptions & { useFallbackLocale?: true }): string;
+export function getUserLocale(options: UserLocaleOptions): string | undefined;
+export function getUserLocale(options?: UserLocaleOptions): string | undefined {
+  return getUserLocales(options)[0];
+}

package/src/index.ts

@@ -4,8 +4,11 @@ import { createDateUtils } from './createDateUtils.js';
 export { AdapterDate } from './AdapterDate.js';
 export type { AdapterDateOptions } from './AdapterDate.js';
 export { createDateUtils } from './createDateUtils.js';
+export { getDateAdapter, provideDateAdapter } from './context.js';
 export type { DateUtils, TimeLike, YearLike } from './createDateUtils.js';
 export type { DateAdapter } from './types.js';
+export { getUserLocale, getUserLocales } from './getUserLocale.js';
+export type { UserLocaleOptions } from './getUserLocale.js';
 
 /**
  * The helpers on the native `Date`, with the names and behavior of `@wojtekmaj/date-utils`.

package/src/internationalized.ts

@@ -0,0 +1,2 @@
+export { AdapterInternationalizedDate } from './AdapterInternationalizedDate.js';
+export type { AdapterInternationalizedDateOptions } from './AdapterInternationalizedDate.js';