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

package/date/conversion.js

@@ -0,0 +1,269 @@
+// Ported from @internationalized/date src/conversion.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.
+ */
+// Portions of the code in this file are based on code from the TC39 Temporal proposal.
+// Original licensing can be found in the NOTICE file in the root directory of this source tree.
+import {} from "./types.js";
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from "./CalendarDate.js";
+import { constrain } from "./manipulation.js";
+import { getExtendedYear, GregorianCalendar } from "./calendars/GregorianCalendar.js";
+import { getLocalTimeZone, isEqualCalendar, isLocalTimeZoneOverridden } from "./queries.js";
+import {} from "./utils.js";
+export function epochFromDate(date) {
+    date = toCalendar(date, new GregorianCalendar());
+    let year = getExtendedYear(date.era, date.year);
+    return epochFromParts(year, date.month, date.day, date.hour, date.minute, date.second, date.millisecond);
+}
+function epochFromParts(year, month, day, hour, minute, second, millisecond) {
+    // Note: Date.UTC() interprets one and two-digit years as being in the
+    // 20th century, so don't use it
+    let date = new Date();
+    date.setUTCHours(hour, minute, second, millisecond);
+    date.setUTCFullYear(year, month - 1, day);
+    return date.getTime();
+}
+export function getTimeZoneOffset(ms, timeZone) {
+    // Fast path for UTC.
+    if (timeZone === 'UTC') {
+        return 0;
+    }
+    // Fast path: for local timezone after 1970, use native Date.
+    // Skip this fast path if the local timezone was explicitly overridden via setLocalTimeZone,
+    // since native Date always uses the browser's timezone, not the overridden one.
+    if (ms > 0 && timeZone === getLocalTimeZone() && !isLocalTimeZoneOverridden()) {
+        return new Date(ms).getTimezoneOffset() * -60 * 1000;
+    }
+    let { year, month, day, hour, minute, second } = getTimeZoneParts(ms, timeZone);
+    let utc = epochFromParts(year, month, day, hour, minute, second, 0);
+    return utc - Math.floor(ms / 1000) * 1000;
+}
+const formattersByTimeZone = new Map();
+function getTimeZoneParts(ms, timeZone) {
+    let formatter = formattersByTimeZone.get(timeZone);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone,
+            hour12: false,
+            era: 'short',
+            year: 'numeric',
+            month: 'numeric',
+            day: 'numeric',
+            hour: 'numeric',
+            minute: 'numeric',
+            second: 'numeric'
+        });
+        formattersByTimeZone.set(timeZone, formatter);
+    }
+    let parts = formatter.formatToParts(new Date(ms));
+    let namedParts = {};
+    for (let part of parts) {
+        if (part.type !== 'literal') {
+            namedParts[part.type] = part.value;
+        }
+    }
+    return {
+        // Firefox returns B instead of BC... https://bugzilla.mozilla.org/show_bug.cgi?id=1752253
+        year: namedParts.era === 'BC' || namedParts.era === 'B' ? -namedParts.year + 1 : +namedParts.year,
+        month: +namedParts.month,
+        day: +namedParts.day,
+        hour: namedParts.hour === '24' ? 0 : +namedParts.hour, // bugs.chromium.org/p/chromium/issues/detail?id=1045791
+        minute: +namedParts.minute,
+        second: +namedParts.second
+    };
+}
+const DAYMILLIS = 86400000;
+export function possibleAbsolutes(date, timeZone) {
+    let ms = epochFromDate(date);
+    let earlier = ms - getTimeZoneOffset(ms - DAYMILLIS, timeZone);
+    let later = ms - getTimeZoneOffset(ms + DAYMILLIS, timeZone);
+    return getValidWallTimes(date, timeZone, earlier, later);
+}
+function getValidWallTimes(date, timeZone, earlier, later) {
+    let found = earlier === later ? [earlier] : [earlier, later];
+    return found.filter(absolute => isValidWallTime(date, timeZone, absolute));
+}
+function isValidWallTime(date, timeZone, absolute) {
+    let parts = getTimeZoneParts(absolute, timeZone);
+    return (date.year === parts.year &&
+        date.month === parts.month &&
+        date.day === parts.day &&
+        date.hour === parts.hour &&
+        date.minute === parts.minute &&
+        date.second === parts.second);
+}
+export function toAbsolute(date, timeZone, disambiguation = 'compatible') {
+    let dateTime = toCalendarDateTime(date);
+    // Fast path: if the time zone is UTC, use native Date.
+    if (timeZone === 'UTC') {
+        return epochFromDate(dateTime);
+    }
+    // Fast path: if the time zone is the local timezone and disambiguation is compatible, use native Date.
+    // Skip this fast path if the local timezone was explicitly overridden via setLocalTimeZone,
+    // since native Date always uses the browser's timezone, not the overridden one.
+    if (timeZone === getLocalTimeZone() &&
+        disambiguation === 'compatible' &&
+        !isLocalTimeZoneOverridden()) {
+        dateTime = toCalendar(dateTime, new GregorianCalendar());
+        // Don't use Date constructor here because two-digit years are interpreted in the 20th century.
+        let date = new Date();
+        let year = getExtendedYear(dateTime.era, dateTime.year);
+        date.setFullYear(year, dateTime.month - 1, dateTime.day);
+        date.setHours(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
+        return date.getTime();
+    }
+    let ms = epochFromDate(dateTime);
+    let offsetBefore = getTimeZoneOffset(ms - DAYMILLIS, timeZone);
+    let offsetAfter = getTimeZoneOffset(ms + DAYMILLIS, timeZone);
+    let valid = getValidWallTimes(dateTime, timeZone, ms - offsetBefore, ms - offsetAfter);
+    if (valid.length === 1) {
+        return valid[0];
+    }
+    if (valid.length > 1) {
+        switch (disambiguation) {
+            // 'compatible' means 'earlier' for "fall back" transitions
+            case 'compatible':
+            case 'earlier':
+                return valid[0];
+            case 'later':
+                return valid[valid.length - 1];
+            case 'reject':
+                throw new RangeError('Multiple possible absolute times found');
+        }
+    }
+    switch (disambiguation) {
+        case 'earlier':
+            return Math.min(ms - offsetBefore, ms - offsetAfter);
+        // 'compatible' means 'later' for "spring forward" transitions
+        case 'compatible':
+        case 'later':
+            return Math.max(ms - offsetBefore, ms - offsetAfter);
+        case 'reject':
+            throw new RangeError('No such absolute time found');
+    }
+}
+export function toDate(dateTime, timeZone, disambiguation = 'compatible') {
+    return new Date(toAbsolute(dateTime, timeZone, disambiguation));
+}
+/**
+ * Takes a Unix epoch (milliseconds since 1970) and converts it to the provided time zone.
+ */
+export function fromAbsolute(ms, timeZone) {
+    let offset = getTimeZoneOffset(ms, timeZone);
+    let date = new Date(ms + offset);
+    let year = date.getUTCFullYear();
+    let month = date.getUTCMonth() + 1;
+    let day = date.getUTCDate();
+    let hour = date.getUTCHours();
+    let minute = date.getUTCMinutes();
+    let second = date.getUTCSeconds();
+    let millisecond = date.getUTCMilliseconds();
+    return new ZonedDateTime(year < 1 ? 'BC' : 'AD', year < 1 ? -year + 1 : year, month, day, timeZone, offset, hour, minute, second, millisecond);
+}
+/**
+ * Takes a `Date` object and converts it to the provided time zone.
+ */
+export function fromDate(date, timeZone) {
+    return fromAbsolute(date.getTime(), timeZone);
+}
+/**
+ * Takes a `Date` object and converts it to the time zone identifier for the current user.
+ */
+export function fromDateToLocal(date) {
+    return fromDate(date, getLocalTimeZone());
+}
+/**
+ * Converts a value with date components such as a `CalendarDateTime` or `ZonedDateTime` into a
+ * `CalendarDate`.
+ */
+export function toCalendarDate(dateTime) {
+    return new CalendarDate(dateTime.calendar, dateTime.era, dateTime.year, dateTime.month, dateTime.day);
+}
+export function toDateFields(date) {
+    return {
+        era: date.era,
+        year: date.year,
+        month: date.month,
+        day: date.day
+    };
+}
+export function toTimeFields(date) {
+    return {
+        hour: date.hour,
+        minute: date.minute,
+        second: date.second,
+        millisecond: date.millisecond
+    };
+}
+/**
+ * Converts a date value to a `CalendarDateTime`. An optional `Time` value can be passed to set the
+ * time of the resulting value, otherwise it will default to midnight.
+ */
+export function toCalendarDateTime(date, time) {
+    let hour = 0, minute = 0, second = 0, millisecond = 0;
+    if ('timeZone' in date) {
+        ({ hour, minute, second, millisecond } = date);
+    }
+    else if ('hour' in date && !time) {
+        return date;
+    }
+    if (time) {
+        ({ hour, minute, second, millisecond } = time);
+    }
+    return new CalendarDateTime(date.calendar, date.era, date.year, date.month, date.day, hour, minute, second, millisecond);
+}
+/** Extracts the time components from a value containing a date and time. */
+export function toTime(dateTime) {
+    return new Time(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
+}
+/** Converts a date from one calendar system to another. */
+export function toCalendar(date, calendar) {
+    if (isEqualCalendar(date.calendar, calendar)) {
+        return date;
+    }
+    let calendarDate = calendar.fromJulianDay(date.calendar.toJulianDay(date));
+    let copy = date.copy();
+    copy.calendar = calendar;
+    copy.era = calendarDate.era;
+    copy.year = calendarDate.year;
+    copy.month = calendarDate.month;
+    copy.day = calendarDate.day;
+    constrain(copy);
+    return copy;
+}
+/**
+ * Converts a date value to a `ZonedDateTime` in the provided time zone. The `disambiguation` option
+ * can be set to control how values that fall on daylight saving time changes are interpreted.
+ */
+export function toZoned(date, timeZone, disambiguation) {
+    if (date instanceof ZonedDateTime) {
+        if (date.timeZone === timeZone) {
+            return date;
+        }
+        return toTimeZone(date, timeZone);
+    }
+    let ms = toAbsolute(date, timeZone, disambiguation);
+    return fromAbsolute(ms, timeZone);
+}
+export function zonedToDate(date) {
+    let ms = epochFromDate(date) - date.offset;
+    return new Date(ms);
+}
+/** Converts a `ZonedDateTime` from one time zone to another. */
+export function toTimeZone(date, timeZone) {
+    let ms = epochFromDate(date) - date.offset;
+    return toCalendar(fromAbsolute(ms, timeZone), date.calendar);
+}
+/** Converts the given `ZonedDateTime` into the user's local time zone. */
+export function toLocalTimeZone(date) {
+    return toTimeZone(date, getLocalTimeZone());
+}

package/date/createCalendar.d.ts

@@ -0,0 +1,3 @@
+import { type Calendar, type CalendarIdentifier } from './types.js';
+/** Creates a `Calendar` instance from a Unicode calendar identifier string. */
+export declare function createCalendar(name: CalendarIdentifier): Calendar;

package/date/createCalendar.js

@@ -0,0 +1,55 @@
+// Ported from @internationalized/date src/createCalendar.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 { BuddhistCalendar } from "./calendars/BuddhistCalendar.js";
+import {} from "./types.js";
+import { CopticCalendar, EthiopicAmeteAlemCalendar, EthiopicCalendar } from "./calendars/EthiopicCalendar.js";
+import { GregorianCalendar } from "./calendars/GregorianCalendar.js";
+import { HebrewCalendar } from "./calendars/HebrewCalendar.js";
+import { IndianCalendar } from "./calendars/IndianCalendar.js";
+import { IslamicCivilCalendar, IslamicTabularCalendar, IslamicUmalquraCalendar } from "./calendars/IslamicCalendar.js";
+import { JapaneseCalendar } from "./calendars/JapaneseCalendar.js";
+import { PersianCalendar } from "./calendars/PersianCalendar.js";
+import { TaiwanCalendar } from "./calendars/TaiwanCalendar.js";
+/** Creates a `Calendar` instance from a Unicode calendar identifier string. */
+export function createCalendar(name) {
+    switch (name) {
+        case 'buddhist':
+            return new BuddhistCalendar();
+        case 'ethiopic':
+            return new EthiopicCalendar();
+        case 'ethioaa':
+            return new EthiopicAmeteAlemCalendar();
+        case 'coptic':
+            return new CopticCalendar();
+        case 'hebrew':
+            return new HebrewCalendar();
+        case 'indian':
+            return new IndianCalendar();
+        case 'islamic-civil':
+            return new IslamicCivilCalendar();
+        case 'islamic-tbla':
+            return new IslamicTabularCalendar();
+        case 'islamic-umalqura':
+            return new IslamicUmalquraCalendar();
+        case 'japanese':
+            return new JapaneseCalendar();
+        case 'persian':
+            return new PersianCalendar();
+        case 'roc':
+            return new TaiwanCalendar();
+        case 'gregory':
+        default:
+            return new GregorianCalendar();
+    }
+}

package/date/index.d.ts

@@ -0,0 +1,20 @@
+export type { AnyCalendarDate, AnyTime, AnyDateTime, Calendar, CalendarIdentifier, DateDuration, TimeDuration, DateTimeDuration, DateFields, TimeFields, DateField, TimeField, Disambiguation, CycleOptions, CycleTimeOptions } from './types.js';
+export type { DateValue } from './CalendarDate.js';
+export type { DayOfWeek } from './queries.js';
+export { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from './CalendarDate.js';
+export { GregorianCalendar } from './calendars/GregorianCalendar.js';
+export { JapaneseCalendar } from './calendars/JapaneseCalendar.js';
+export { BuddhistCalendar } from './calendars/BuddhistCalendar.js';
+export { TaiwanCalendar } from './calendars/TaiwanCalendar.js';
+export { PersianCalendar } from './calendars/PersianCalendar.js';
+export { IndianCalendar } from './calendars/IndianCalendar.js';
+export { IslamicCivilCalendar, IslamicTabularCalendar, IslamicUmalquraCalendar } from './calendars/IslamicCalendar.js';
+export { HebrewCalendar } from './calendars/HebrewCalendar.js';
+export { EthiopicCalendar, EthiopicAmeteAlemCalendar, CopticCalendar } from './calendars/EthiopicCalendar.js';
+export { createCalendar } from './createCalendar.js';
+export { toCalendarDate, toCalendarDateTime, toTime, toCalendar, toZoned, toTimeZone, toLocalTimeZone, fromDate, fromDateToLocal, fromAbsolute } from './conversion.js';
+export { isSameDay, isSameMonth, isSameYear, isEqualDay, isEqualMonth, isEqualYear, isToday, getDayOfWeek, now, today, getHoursInDay, getLocalTimeZone, setLocalTimeZone, resetLocalTimeZone, startOfMonth, startOfWeek, startOfYear, endOfMonth, endOfWeek, endOfYear, getMinimumMonthInYear, getMinimumDayInMonth, getWeeksInMonth, minDate, maxDate, isWeekend, isWeekday, isEqualCalendar } from './queries.js';
+export { parseDate, parseDateTime, parseTime, parseAbsolute, parseAbsoluteToLocal, parseZonedDateTime, parseDuration } from './string.js';
+export { DateFormatter } from './DateFormatter.js';
+export { stringifyDateValue, parseDateValue, toDateValueString } from './serialize.js';
+export type { AnyDateValue, AnyTimeValue, DateValueString } from './serialize.js';

package/date/index.js

@@ -0,0 +1,30 @@
+// Ported from @internationalized/date src/index.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.
+ */
+export { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from "./CalendarDate.js";
+export { GregorianCalendar } from "./calendars/GregorianCalendar.js";
+export { JapaneseCalendar } from "./calendars/JapaneseCalendar.js";
+export { BuddhistCalendar } from "./calendars/BuddhistCalendar.js";
+export { TaiwanCalendar } from "./calendars/TaiwanCalendar.js";
+export { PersianCalendar } from "./calendars/PersianCalendar.js";
+export { IndianCalendar } from "./calendars/IndianCalendar.js";
+export { IslamicCivilCalendar, IslamicTabularCalendar, IslamicUmalquraCalendar } from "./calendars/IslamicCalendar.js";
+export { HebrewCalendar } from "./calendars/HebrewCalendar.js";
+export { EthiopicCalendar, EthiopicAmeteAlemCalendar, CopticCalendar } from "./calendars/EthiopicCalendar.js";
+export { createCalendar } from "./createCalendar.js";
+export { toCalendarDate, toCalendarDateTime, toTime, toCalendar, toZoned, toTimeZone, toLocalTimeZone, fromDate, fromDateToLocal, fromAbsolute } from "./conversion.js";
+export { isSameDay, isSameMonth, isSameYear, isEqualDay, isEqualMonth, isEqualYear, isToday, getDayOfWeek, now, today, getHoursInDay, getLocalTimeZone, setLocalTimeZone, resetLocalTimeZone, startOfMonth, startOfWeek, startOfYear, endOfMonth, endOfWeek, endOfYear, getMinimumMonthInYear, getMinimumDayInMonth, getWeeksInMonth, minDate, maxDate, isWeekend, isWeekday, isEqualCalendar } from "./queries.js";
+export { parseDate, parseDateTime, parseTime, parseAbsolute, parseAbsoluteToLocal, parseZonedDateTime, parseDuration } from "./string.js";
+export { DateFormatter } from "./DateFormatter.js";
+// Rivet addition: string forms of date values for resumable state.
+export { stringifyDateValue, parseDateValue, toDateValueString } from "./serialize.js";

package/date/manipulation.d.ts

@@ -0,0 +1,25 @@
+import { type AnyCalendarDate, type AnyTime, type CycleOptions, type CycleTimeOptions, type DateDuration, type DateField, type DateFields, type DateTimeDuration, type Disambiguation, type TimeDuration, type TimeField, type TimeFields } from './types.js';
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from './CalendarDate.js';
+import { type Mutable } from './utils.js';
+export declare function add(date: CalendarDateTime, duration: DateTimeDuration): CalendarDateTime;
+export declare function add(date: CalendarDate, duration: DateDuration): CalendarDate;
+export declare function add(date: CalendarDate | CalendarDateTime, duration: DateTimeDuration): CalendarDate | CalendarDateTime;
+export declare function constrain(date: Mutable<AnyCalendarDate>): void;
+export declare function invertDuration(duration: DateTimeDuration): DateTimeDuration;
+export declare function subtract(date: CalendarDateTime, duration: DateTimeDuration): CalendarDateTime;
+export declare function subtract(date: CalendarDate, duration: DateDuration): CalendarDate;
+export declare function set(date: CalendarDateTime, fields: DateFields): CalendarDateTime;
+export declare function set(date: CalendarDate, fields: DateFields): CalendarDate;
+export declare function setTime(value: CalendarDateTime, fields: TimeFields): CalendarDateTime;
+export declare function setTime(value: Time, fields: TimeFields): Time;
+export declare function constrainTime(time: Mutable<AnyTime>): void;
+export declare function addTime(time: Time, duration: TimeDuration): Time;
+export declare function subtractTime(time: Time, duration: TimeDuration): Time;
+export declare function cycleDate(value: CalendarDateTime, field: DateField, amount: number, options?: CycleOptions): CalendarDateTime;
+export declare function cycleDate(value: CalendarDate, field: DateField, amount: number, options?: CycleOptions): CalendarDate;
+export declare function cycleTime(value: CalendarDateTime, field: TimeField, amount: number, options?: CycleTimeOptions): CalendarDateTime;
+export declare function cycleTime(value: Time, field: TimeField, amount: number, options?: CycleTimeOptions): Time;
+export declare function addZoned(dateTime: ZonedDateTime, duration: DateTimeDuration): ZonedDateTime;
+export declare function subtractZoned(dateTime: ZonedDateTime, duration: DateTimeDuration): ZonedDateTime;
+export declare function cycleZoned(dateTime: ZonedDateTime, field: DateField | TimeField, amount: number, options?: CycleTimeOptions): ZonedDateTime;
+export declare function setZoned(dateTime: ZonedDateTime, fields: DateFields & TimeFields, disambiguation?: Disambiguation): ZonedDateTime;