@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.0

package/date/manipulation.js

@@ -0,0 +1,399 @@
+// Ported from @internationalized/date src/manipulation.ts (react-spectrum), Apache-2.0, © Adobe.
+// Changes: .ts import specifiers, type-only imports, override modifiers, strict-mode index types.
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import {} from "./types.js";
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from "./CalendarDate.js";
+import { epochFromDate, fromAbsolute, toAbsolute, toCalendar, toCalendarDateTime } from "./conversion.js";
+import { GregorianCalendar } from "./calendars/GregorianCalendar.js";
+import {} from "./utils.js";
+const ONE_HOUR = 3600000;
+export function add(date, duration) {
+    let mutableDate = date.copy();
+    let days = 'hour' in mutableDate ? addTimeFields(mutableDate, duration) : 0;
+    addYears(mutableDate, duration.years || 0);
+    if (mutableDate.calendar.balanceYearMonth) {
+        mutableDate.calendar.balanceYearMonth(mutableDate, date);
+    }
+    mutableDate.month += duration.months || 0;
+    balanceYearMonth(mutableDate);
+    constrainMonthDay(mutableDate);
+    mutableDate.day += (duration.weeks || 0) * 7;
+    mutableDate.day += duration.days || 0;
+    mutableDate.day += days;
+    balanceDay(mutableDate);
+    if (mutableDate.calendar.balanceDate) {
+        mutableDate.calendar.balanceDate(mutableDate);
+    }
+    // Constrain in case adding ended up with a date outside the valid range for the calendar system.
+    // The behavior here is slightly different than when constraining in the `set` function in that
+    // we adjust smaller fields to their minimum/maximum values rather than constraining each field
+    // individually. This matches the general behavior of `add` vs `set` regarding how fields are balanced.
+    if (mutableDate.year < 1) {
+        mutableDate.year = 1;
+        mutableDate.month = 1;
+        mutableDate.day = 1;
+    }
+    let maxYear = mutableDate.calendar.getYearsInEra(mutableDate);
+    if (mutableDate.year > maxYear) {
+        let isInverseEra = mutableDate.calendar.isInverseEra?.(mutableDate);
+        mutableDate.year = maxYear;
+        mutableDate.month = isInverseEra ? 1 : mutableDate.calendar.getMonthsInYear(mutableDate);
+        mutableDate.day = isInverseEra ? 1 : mutableDate.calendar.getDaysInMonth(mutableDate);
+    }
+    if (mutableDate.month < 1) {
+        mutableDate.month = 1;
+        mutableDate.day = 1;
+    }
+    let maxMonth = mutableDate.calendar.getMonthsInYear(mutableDate);
+    if (mutableDate.month > maxMonth) {
+        mutableDate.month = maxMonth;
+        mutableDate.day = mutableDate.calendar.getDaysInMonth(mutableDate);
+    }
+    mutableDate.day = Math.max(1, Math.min(mutableDate.calendar.getDaysInMonth(mutableDate), mutableDate.day));
+    return mutableDate;
+}
+function addYears(date, years) {
+    if (date.calendar.isInverseEra?.(date)) {
+        years = -years;
+    }
+    date.year += years;
+}
+function balanceYearMonth(date) {
+    while (date.month < 1) {
+        addYears(date, -1);
+        date.month += date.calendar.getMonthsInYear(date);
+    }
+    let monthsInYear = 0;
+    while (date.month > (monthsInYear = date.calendar.getMonthsInYear(date))) {
+        date.month -= monthsInYear;
+        addYears(date, 1);
+    }
+}
+function balanceDay(date) {
+    while (date.day < 1) {
+        date.month--;
+        balanceYearMonth(date);
+        date.day += date.calendar.getDaysInMonth(date);
+    }
+    while (date.day > date.calendar.getDaysInMonth(date)) {
+        date.day -= date.calendar.getDaysInMonth(date);
+        date.month++;
+        balanceYearMonth(date);
+    }
+}
+function constrainMonthDay(date) {
+    date.month = Math.max(1, Math.min(date.calendar.getMonthsInYear(date), date.month));
+    date.day = Math.max(1, Math.min(date.calendar.getDaysInMonth(date), date.day));
+}
+export function constrain(date) {
+    if (date.calendar.constrainDate) {
+        date.calendar.constrainDate(date);
+    }
+    date.year = Math.max(1, Math.min(date.calendar.getYearsInEra(date), date.year));
+    constrainMonthDay(date);
+}
+export function invertDuration(duration) {
+    let inverseDuration = {};
+    for (let key in duration) {
+        if (typeof duration[key] === 'number') {
+            inverseDuration[key] = -duration[key];
+        }
+    }
+    return inverseDuration;
+}
+export function subtract(date, duration) {
+    return add(date, invertDuration(duration));
+}
+export function set(date, fields) {
+    let mutableDate = date.copy();
+    if (fields.era != null) {
+        mutableDate.era = fields.era;
+    }
+    if (fields.year != null) {
+        mutableDate.year = fields.year;
+    }
+    if (fields.month != null) {
+        mutableDate.month = fields.month;
+    }
+    if (fields.day != null) {
+        mutableDate.day = fields.day;
+    }
+    constrain(mutableDate);
+    return mutableDate;
+}
+export function setTime(value, fields) {
+    let mutableValue = value.copy();
+    if (fields.hour != null) {
+        mutableValue.hour = fields.hour;
+    }
+    if (fields.minute != null) {
+        mutableValue.minute = fields.minute;
+    }
+    if (fields.second != null) {
+        mutableValue.second = fields.second;
+    }
+    if (fields.millisecond != null) {
+        mutableValue.millisecond = fields.millisecond;
+    }
+    constrainTime(mutableValue);
+    return mutableValue;
+}
+function balanceTime(time) {
+    time.second += Math.floor(time.millisecond / 1000);
+    time.millisecond = nonNegativeMod(time.millisecond, 1000);
+    time.minute += Math.floor(time.second / 60);
+    time.second = nonNegativeMod(time.second, 60);
+    time.hour += Math.floor(time.minute / 60);
+    time.minute = nonNegativeMod(time.minute, 60);
+    let days = Math.floor(time.hour / 24);
+    time.hour = nonNegativeMod(time.hour, 24);
+    return days;
+}
+export function constrainTime(time) {
+    time.millisecond = Math.max(0, Math.min(time.millisecond, 999));
+    time.second = Math.max(0, Math.min(time.second, 59));
+    time.minute = Math.max(0, Math.min(time.minute, 59));
+    time.hour = Math.max(0, Math.min(time.hour, 23));
+}
+function nonNegativeMod(a, b) {
+    let result = a % b;
+    if (result < 0) {
+        result += b;
+    }
+    return result;
+}
+function addTimeFields(time, duration) {
+    time.hour += duration.hours || 0;
+    time.minute += duration.minutes || 0;
+    time.second += duration.seconds || 0;
+    time.millisecond += duration.milliseconds || 0;
+    return balanceTime(time);
+}
+export function addTime(time, duration) {
+    let res = time.copy();
+    addTimeFields(res, duration);
+    return res;
+}
+export function subtractTime(time, duration) {
+    return addTime(time, invertDuration(duration));
+}
+export function cycleDate(value, field, amount, options) {
+    let mutable = value.copy();
+    switch (field) {
+        case 'era': {
+            let eras = value.calendar.getEras();
+            let eraIndex = eras.indexOf(value.era);
+            if (eraIndex < 0) {
+                throw new Error('Invalid era: ' + value.era);
+            }
+            eraIndex = cycleValue(eraIndex, amount, 0, eras.length - 1, options?.round);
+            mutable.era = eras[eraIndex];
+            // Constrain the year and other fields within the era, so the era doesn't change when we balance below.
+            constrain(mutable);
+            break;
+        }
+        case 'year': {
+            if (mutable.calendar.isInverseEra?.(mutable)) {
+                amount = -amount;
+            }
+            // The year field should not cycle within the era as that can cause weird behavior affecting other fields.
+            // We need to also allow values < 1 so that decrementing goes to the previous era. If we get -Infinity back
+            // we know we wrapped around after reaching 9999 (the maximum), so set the year back to 1.
+            mutable.year = cycleValue(value.year, amount, -Infinity, 9999, options?.round);
+            if (mutable.year === -Infinity) {
+                mutable.year = 1;
+            }
+            if (mutable.calendar.balanceYearMonth) {
+                mutable.calendar.balanceYearMonth(mutable, value);
+            }
+            break;
+        }
+        case 'month':
+            mutable.month = cycleValue(value.month, amount, 1, value.calendar.getMonthsInYear(value), options?.round);
+            break;
+        case 'day':
+            mutable.day = cycleValue(value.day, amount, 1, value.calendar.getDaysInMonth(value), options?.round);
+            break;
+        default:
+            throw new Error('Unsupported field ' + field);
+    }
+    if (value.calendar.balanceDate) {
+        value.calendar.balanceDate(mutable);
+    }
+    constrain(mutable);
+    return mutable;
+}
+export function cycleTime(value, field, amount, options) {
+    let mutable = value.copy();
+    switch (field) {
+        case 'hour': {
+            let hours = value.hour;
+            let min = 0;
+            let max = 23;
+            if (options?.hourCycle === 12) {
+                let isPM = hours >= 12;
+                min = isPM ? 12 : 0;
+                max = isPM ? 23 : 11;
+            }
+            mutable.hour = cycleValue(hours, amount, min, max, options?.round);
+            break;
+        }
+        case 'minute':
+            mutable.minute = cycleValue(value.minute, amount, 0, 59, options?.round);
+            break;
+        case 'second':
+            mutable.second = cycleValue(value.second, amount, 0, 59, options?.round);
+            break;
+        case 'millisecond':
+            mutable.millisecond = cycleValue(value.millisecond, amount, 0, 999, options?.round);
+            break;
+        default:
+            throw new Error('Unsupported field ' + field);
+    }
+    return mutable;
+}
+function cycleValue(value, amount, min, max, round = false) {
+    if (round) {
+        value += Math.sign(amount);
+        if (value < min) {
+            value = max;
+        }
+        let div = Math.abs(amount);
+        if (amount > 0) {
+            value = Math.ceil(value / div) * div;
+        }
+        else {
+            value = Math.floor(value / div) * div;
+        }
+        if (value > max) {
+            value = min;
+        }
+    }
+    else {
+        value += amount;
+        if (value < min) {
+            value = max - (min - value - 1);
+        }
+        else if (value > max) {
+            value = min + (value - max - 1);
+        }
+    }
+    return value;
+}
+export function addZoned(dateTime, duration) {
+    let ms;
+    if ((duration.years != null && duration.years !== 0) ||
+        (duration.months != null && duration.months !== 0) ||
+        (duration.weeks != null && duration.weeks !== 0) ||
+        (duration.days != null && duration.days !== 0)) {
+        let res = add(toCalendarDateTime(dateTime), {
+            years: duration.years,
+            months: duration.months,
+            weeks: duration.weeks,
+            days: duration.days
+        });
+        // Changing the date may change the timezone offset, so we need to recompute
+        // using the 'compatible' disambiguation.
+        ms = toAbsolute(res, dateTime.timeZone);
+    }
+    else {
+        // Otherwise, preserve the offset of the original date.
+        ms = epochFromDate(dateTime) - dateTime.offset;
+    }
+    // Perform time manipulation in milliseconds rather than on the original time fields to account for DST.
+    // For example, adding one hour during a DST transition may result in the hour field staying the same or
+    // skipping an hour. This results in the offset field changing value instead of the specified field.
+    ms += duration.milliseconds || 0;
+    ms += (duration.seconds || 0) * 1000;
+    ms += (duration.minutes || 0) * 60 * 1000;
+    ms += (duration.hours || 0) * 60 * 60 * 1000;
+    let res = fromAbsolute(ms, dateTime.timeZone);
+    return toCalendar(res, dateTime.calendar);
+}
+export function subtractZoned(dateTime, duration) {
+    return addZoned(dateTime, invertDuration(duration));
+}
+export function cycleZoned(dateTime, field, amount, options) {
+    // For date fields, we want the time to remain consistent and the UTC offset to potentially change to account for DST changes.
+    // For time fields, we want the time to change by the amount given. This may result in the hour field staying the same, but the UTC
+    // offset changing in the case of a backward DST transition, or skipping an hour in the case of a forward DST transition.
+    switch (field) {
+        case 'hour': {
+            let min = 0;
+            let max = 23;
+            if (options?.hourCycle === 12) {
+                let isPM = dateTime.hour >= 12;
+                min = isPM ? 12 : 0;
+                max = isPM ? 23 : 11;
+            }
+            // The minimum and maximum hour may be affected by daylight saving time.
+            // For example, it might jump forward at midnight, and skip 1am.
+            // Or it might end at midnight and repeat the 11pm hour. To handle this, we get
+            // the possible absolute times for the min and max, and find the maximum range
+            // that is within the current day.
+            let plainDateTime = toCalendarDateTime(dateTime);
+            let minDate = toCalendar(setTime(plainDateTime, { hour: min }), new GregorianCalendar());
+            let minAbsolute = [
+                toAbsolute(minDate, dateTime.timeZone, 'earlier'),
+                toAbsolute(minDate, dateTime.timeZone, 'later')
+            ].filter(ms => fromAbsolute(ms, dateTime.timeZone).day === minDate.day)[0];
+            let maxDate = toCalendar(setTime(plainDateTime, { hour: max }), new GregorianCalendar());
+            let maxAbsolute = [
+                toAbsolute(maxDate, dateTime.timeZone, 'earlier'),
+                toAbsolute(maxDate, dateTime.timeZone, 'later')
+            ]
+                .filter(ms => fromAbsolute(ms, dateTime.timeZone).day === maxDate.day)
+                .pop();
+            // Since hours may repeat, we need to operate on the absolute time in milliseconds.
+            // This is done in hours from the Unix epoch so that cycleValue works correctly,
+            // and then converted back to milliseconds.
+            let ms = epochFromDate(dateTime) - dateTime.offset;
+            let hours = Math.floor(ms / ONE_HOUR);
+            let remainder = ms % ONE_HOUR;
+            ms =
+                cycleValue(hours, amount, Math.floor(minAbsolute / ONE_HOUR), Math.floor(maxAbsolute / ONE_HOUR), options?.round) *
+                    ONE_HOUR +
+                    remainder;
+            // Now compute the new timezone offset, and convert the absolute time back to local time.
+            return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+        }
+        case 'minute':
+        case 'second':
+        case 'millisecond':
+            // @ts-ignore
+            return cycleTime(dateTime, field, amount, options);
+        case 'era':
+        case 'year':
+        case 'month':
+        case 'day': {
+            let res = cycleDate(toCalendarDateTime(dateTime), field, amount, options);
+            let ms = toAbsolute(res, dateTime.timeZone);
+            return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+        }
+        default:
+            throw new Error('Unsupported field ' + field);
+    }
+}
+export function setZoned(dateTime, fields, disambiguation) {
+    // Set the date/time fields, and recompute the UTC offset to account for DST changes.
+    // We also need to validate by converting back to a local time in case hours are skipped during forward DST transitions.
+    let plainDateTime = toCalendarDateTime(dateTime);
+    let res = setTime(set(plainDateTime, fields), fields);
+    // If the resulting plain date time values are equal, return the original time.
+    // We don't want to change the offset when setting the time to the same value.
+    if (res.compare(plainDateTime) === 0) {
+        return dateTime;
+    }
+    let ms = toAbsolute(res, dateTime.timeZone, disambiguation);
+    return toCalendar(fromAbsolute(ms, dateTime.timeZone), dateTime.calendar);
+}

package/date/queries.d.ts

@@ -0,0 +1,93 @@
+import { type AnyCalendarDate, type AnyTime, type Calendar } from './types.js';
+import { CalendarDate, CalendarDateTime, type DateValue, ZonedDateTime } from './CalendarDate.js';
+/** Returns whether the given dates occur on the same day, regardless of the time or calendar system. */
+export declare function isSameDay(a: DateValue, b: DateValue): boolean;
+/**
+ * Returns whether the given dates occur in the same month, using the calendar system of the first
+ * date.
+ */
+export declare function isSameMonth(a: DateValue, b: DateValue): boolean;
+/**
+ * Returns whether the given dates occur in the same year, using the calendar system of the first
+ * date.
+ */
+export declare function isSameYear(a: DateValue, b: DateValue): boolean;
+/** Returns whether the given dates occur on the same day, and are of the same calendar system. */
+export declare function isEqualDay(a: DateValue, b: DateValue): boolean;
+/** Returns whether the given dates occur in the same month, and are of the same calendar system. */
+export declare function isEqualMonth(a: DateValue, b: DateValue): boolean;
+/** Returns whether the given dates occur in the same year, and are of the same calendar system. */
+export declare function isEqualYear(a: DateValue, b: DateValue): boolean;
+/** Returns whether two calendars are the same. */
+export declare function isEqualCalendar(a: Calendar, b: Calendar): boolean;
+/** Returns whether the date is today in the given time zone. */
+export declare function isToday(date: DateValue, timeZone: string): boolean;
+export type DayOfWeek = 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
+/**
+ * Returns the day of week for the given date and locale. Days are numbered from zero to six,
+ * where zero is the first day of the week in the given locale. For example, in the United States,
+ * the first day of the week is Sunday, but in France it is Monday.
+ */
+export declare function getDayOfWeek(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): number;
+/** Returns the current time in the given time zone. */
+export declare function now(timeZone: string): ZonedDateTime;
+/** Returns today's date in the given time zone. */
+export declare function today(timeZone: string): CalendarDate;
+export declare function compareDate(a: AnyCalendarDate, b: AnyCalendarDate): number;
+export declare function compareTime(a: AnyTime, b: AnyTime): number;
+/**
+ * Returns the number of hours in the given date and time zone.
+ * Usually this is 24, but it could be 23 or 25 if the date is on a daylight saving transition.
+ */
+export declare function getHoursInDay(a: CalendarDate, timeZone: string): number;
+/** Returns the time zone identifier for the current user. */
+export declare function getLocalTimeZone(): string;
+/** Sets the time zone identifier for the current user. */
+export declare function setLocalTimeZone(timeZone: string): void;
+/** Resets the time zone identifier for the current user. */
+export declare function resetLocalTimeZone(): void;
+/** Returns whether the local time zone has been explicitly overridden via `setLocalTimeZone`. */
+export declare function isLocalTimeZoneOverridden(): boolean;
+/** Returns the first date of the month for the given date. */
+export declare function startOfMonth(date: ZonedDateTime): ZonedDateTime;
+export declare function startOfMonth(date: CalendarDateTime): CalendarDateTime;
+export declare function startOfMonth(date: CalendarDate): CalendarDate;
+export declare function startOfMonth(date: DateValue): DateValue;
+/** Returns the last date of the month for the given date. */
+export declare function endOfMonth(date: ZonedDateTime): ZonedDateTime;
+export declare function endOfMonth(date: CalendarDateTime): CalendarDateTime;
+export declare function endOfMonth(date: CalendarDate): CalendarDate;
+export declare function endOfMonth(date: DateValue): DateValue;
+/** Returns the first day of the year for the given date. */
+export declare function startOfYear(date: ZonedDateTime): ZonedDateTime;
+export declare function startOfYear(date: CalendarDateTime): CalendarDateTime;
+export declare function startOfYear(date: CalendarDate): CalendarDate;
+export declare function startOfYear(date: DateValue): DateValue;
+/** Returns the last day of the year for the given date. */
+export declare function endOfYear(date: ZonedDateTime): ZonedDateTime;
+export declare function endOfYear(date: CalendarDateTime): CalendarDateTime;
+export declare function endOfYear(date: CalendarDate): CalendarDate;
+export declare function endOfYear(date: DateValue): DateValue;
+export declare function getMinimumMonthInYear(date: AnyCalendarDate): number;
+export declare function getMinimumDayInMonth(date: AnyCalendarDate): number;
+/** Returns the first date of the week for the given date and locale. */
+export declare function startOfWeek(date: ZonedDateTime, locale: string, firstDayOfWeek?: DayOfWeek): ZonedDateTime;
+export declare function startOfWeek(date: CalendarDateTime, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDateTime;
+export declare function startOfWeek(date: CalendarDate, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDate;
+export declare function startOfWeek(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): DateValue;
+/** Returns the last date of the week for the given date and locale. */
+export declare function endOfWeek(date: ZonedDateTime, locale: string, firstDayOfWeek?: DayOfWeek): ZonedDateTime;
+export declare function endOfWeek(date: CalendarDateTime, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDateTime;
+export declare function endOfWeek(date: CalendarDate, locale: string, firstDayOfWeek?: DayOfWeek): CalendarDate;
+export declare function endOfWeek(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): DateValue;
+/** Returns the number of weeks in the given month and locale. */
+export declare function getWeeksInMonth(date: DateValue, locale: string, firstDayOfWeek?: DayOfWeek): number;
+/** Returns the lesser of the two provider dates. */
+export declare function minDate<A extends DateValue, B extends DateValue>(a: A, b: B): A | B;
+export declare function minDate<A extends DateValue, B extends DateValue>(a?: A | null, b?: B | null): A | B | null | undefined;
+/** Returns the greater of the two provider dates. */
+export declare function maxDate<A extends DateValue, B extends DateValue>(a?: A | null, b?: B | null): A | B | null | undefined;
+/** Returns whether the given date is on a weekend in the given locale. */
+export declare function isWeekend(date: DateValue, locale: string): boolean;
+/** Returns whether the given date is on a weekday in the given locale. */
+export declare function isWeekday(date: DateValue, locale: string): boolean;