temporal-utils 1.0.0 → 1.0.1

package/dist/diff.d.ts

@@ -0,0 +1,17 @@
+import { RoundingMathOptions, RoundingMode } from './utils';
+type DiffFunc<T extends Temporal.Instant | Temporal.PlainTime | Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime = Temporal.Instant | Temporal.PlainTime | Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime> = {
+    (date0: T, date1: T): number;
+    (date0: T, date1: T, roundingMode: RoundingMode): number;
+    (date0: T, date1: T, options: RoundingMathOptions): number;
+};
+export declare const diffYears: DiffFunc<Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>;
+export declare const diffMonths: DiffFunc<Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>;
+export declare const diffWeeks: DiffFunc<Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>;
+export declare const diffDays: DiffFunc<Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>;
+export declare const diffHours: DiffFunc<Temporal.Instant | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>;
+export declare const diffMinutes: DiffFunc<Temporal.Instant | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>;
+export declare const diffSeconds: DiffFunc<Temporal.Instant | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>;
+export declare const diffMilliseconds: DiffFunc<Temporal.Instant | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>;
+export declare const diffMicroseconds: DiffFunc<Temporal.Instant | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>;
+export declare const diffNanoseconds: DiffFunc<Temporal.Instant | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>;
+export {};

package/dist/diff.js

@@ -0,0 +1,52 @@
+function createDiffFunc(unit) {
+    return (date0, date1, options) => {
+        const normOptions = normalizeDiffOptions(options);
+        // TODO: throw error if unit impossible for input-types?
+        // like diffing years for PlainTime?
+        if (normOptions.roundingMode) {
+            return date0.until(date1, {
+                ...normOptions,
+                largestUnit: unit,
+                smallestUnit: unit,
+            })[unit];
+        }
+        const duration = date0.until(date1, {
+            ...normOptions,
+            largestUnit: unit,
+        });
+        // Time-unit helpers produce pure elapsed-time totals. This keeps Instant
+        // and PlainTime valid because neither can be used as a `relativeTo` value.
+        if (isTimeUnit(unit)) {
+            return duration.total(unit);
+        }
+        // Date-bearing objects need `relativeTo` so totals account for calendar
+        // units and, for ZonedDateTime, time-zone transitions. PlainYearMonth has
+        // month precision, so day 1 gives Duration.total a concrete date anchor.
+        const relativeTo = (!('day' in date0) && 'toPlainDate' in date0
+            ? date0.toPlainDate({ day: 1 })
+            : date0);
+        return duration.total({ unit, relativeTo });
+    };
+}
+// TODO: more DRY with elsewhere?
+function isTimeUnit(unit) {
+    return (unit === 'hours' ||
+        unit === 'minutes' ||
+        unit === 'seconds' ||
+        unit === 'milliseconds' ||
+        unit === 'microseconds' ||
+        unit === 'nanoseconds');
+}
+export const diffYears = createDiffFunc('years');
+export const diffMonths = createDiffFunc('months');
+export const diffWeeks = createDiffFunc('weeks');
+export const diffDays = createDiffFunc('days');
+export const diffHours = createDiffFunc('hours');
+export const diffMinutes = createDiffFunc('minutes');
+export const diffSeconds = createDiffFunc('seconds');
+export const diffMilliseconds = createDiffFunc('milliseconds');
+export const diffMicroseconds = createDiffFunc('microseconds');
+export const diffNanoseconds = createDiffFunc('nanoseconds');
+function normalizeDiffOptions(options) {
+    return typeof options === 'string' ? { roundingMode: options } : options || {};
+}

package/dist/endOf.d.ts

@@ -0,0 +1,9 @@
+export declare function endOfYear<T extends Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function endOfMonth<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function endOfWeek<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function endOfDay<T extends Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function endOfHour<T extends Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function endOfMinute<T extends Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function endOfSecond<T extends Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function endOfMillisecond<T extends Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function endOfMicrosecond<T extends Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;

package/dist/endOf.js

@@ -0,0 +1,56 @@
+import { startOfHour, startOfMicrosecond, startOfMillisecond, startOfMinute, startOfMonth, startOfSecond, startOfWeek, startOfYear, } from './startOf.js';
+import { nanoInHour, nanoInMicro, nanoInMilli, nanoInMinute, nanoInSec, } from './utils.js';
+export function endOfYear(date) {
+    return startOfYear(date)
+        .add({ years: 1 })
+        .subtract(date.day === undefined
+        ? { months: 1 }
+        : date
+            .nanosecond !== undefined
+            ? { nanoseconds: 1 }
+            : { days: 1 });
+}
+export function endOfMonth(date) {
+    return startOfMonth(date)
+        .add({ months: 1 })
+        .subtract(date.nanosecond !==
+        undefined
+        ? { nanoseconds: 1 }
+        : { days: 1 });
+}
+export function endOfWeek(date) {
+    return startOfWeek(date)
+        .add({ weeks: 1 })
+        .subtract(date.nanosecond !==
+        undefined
+        ? { nanoseconds: 1 }
+        : { days: 1 });
+}
+export function endOfDay(date) {
+    if (date.withPlainTime) {
+        return date
+            .withPlainTime()
+            .add({ days: 1 })
+            .subtract({ nanoseconds: 1 });
+    }
+    return date; // in case PlainDate passed in, not moved to next day
+}
+export function endOfHour(date) {
+    return startOfHour(date).add({ nanoseconds: nanoInHour - 1 });
+}
+export function endOfMinute(date) {
+    return startOfMinute(date).add({ nanoseconds: nanoInMinute - 1 });
+}
+export function endOfSecond(date) {
+    return startOfSecond(date).add({ nanoseconds: nanoInSec - 1 });
+}
+export function endOfMillisecond(date) {
+    return startOfMillisecond(date).add({
+        nanoseconds: nanoInMilli - 1,
+    });
+}
+export function endOfMicrosecond(date) {
+    return startOfMicrosecond(date).add({
+        nanoseconds: nanoInMicro - 1,
+    });
+}

package/dist/errorMessages.d.ts

@@ -0,0 +1,9 @@
+export declare const expectedPositive: (entityName: string, num: number) => string;
+export declare const expectedFinite: (entityName: string, num: number) => string;
+export declare const forbiddenBigIntToNumber: (entityName: string) => string;
+export declare const invalidObject = "Invalid object";
+export declare const numberOutOfRange: (entityName: string, val: number | string, min: number | string, max: number | string) => string;
+export declare const invalidEntity: (fieldName: string, val: any) => string;
+export declare const unsupportedWeekNumbers = "Calendar week operations forbidden";
+export declare const nonOneRoundingIncrement = "Non-1 roundingIncrement not allowed";
+export declare const invalidOverflowOption = "Invalid overflow option";

package/dist/errorMessages.js

@@ -0,0 +1,14 @@
+// Low-Level
+export const expectedPositive = (entityName, num) => `Non-positive ${entityName}: ${num}`;
+export const expectedFinite = (entityName, num) => `Non-finite ${entityName}: ${num}`;
+export const forbiddenBigIntToNumber = (entityName) => `Cannot convert bigint to ${entityName}`;
+export const invalidObject = 'Invalid object';
+export const numberOutOfRange = (entityName, val, min, max) => invalidEntity(entityName, val) + `; must be between ${min}-${max}`;
+// Entity/Fields/Bags
+export const invalidEntity = (fieldName, val) => `Invalid ${fieldName}: ${val}`;
+// Calendar
+export const unsupportedWeekNumbers = 'Calendar week operations forbidden';
+// Rounding
+export const nonOneRoundingIncrement = 'Non-1 roundingIncrement not allowed';
+// Options
+export const invalidOverflowOption = 'Invalid overflow option';

package/dist/global-types.d.ts

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

package/dist/global-types.js

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './with.js';
+export * from './round.js';
+export * from './startOf.js';
+export * from './endOf.js';
+export * from './diff.js';
+export type { RoundingMathOptions, RoundingMode } from './utils.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './with.js';
+export * from './round.js';
+export * from './startOf.js';
+export * from './endOf.js';
+export * from './diff.js';

package/dist/protected-error-messages.d.ts

@@ -0,0 +1 @@
+export { invalidEntity, numberOutOfRange, unsupportedWeekNumbers, } from './errorMessages.js';

package/dist/protected-error-messages.js

@@ -0,0 +1 @@
+export { invalidEntity, numberOutOfRange, unsupportedWeekNumbers, } from './errorMessages.js';

package/dist/protected.d.ts

@@ -0,0 +1 @@
+export { constrainToRange, isObjectLike, nanoInHour, nanoInMicro, nanoInMilli, nanoInMinute, nanoInSec, normalizeNumberInRange, normalizeOptions, requireNumberIsPositive, requireObjectLike, toFiniteNumber, toIntegerWithTrunc, toPositiveIntegerWithTruncation, } from './utils.js';

package/dist/protected.js

@@ -0,0 +1 @@
+export { constrainToRange, isObjectLike, nanoInHour, nanoInMicro, nanoInMilli, nanoInMinute, nanoInSec, normalizeNumberInRange, normalizeOptions, requireNumberIsPositive, requireObjectLike, toFiniteNumber, toIntegerWithTrunc, toPositiveIntegerWithTruncation, } from './utils.js';

package/dist/round.d.ts

@@ -0,0 +1,24 @@
+import { RoundingMathOptions, RoundingMode } from './utils.js';
+export declare function roundToYear<T extends Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function roundToYear<T extends Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T, roundingMode: RoundingMode): T;
+export declare function roundToYear<T extends Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T, options: RoundingMathOptions): T;
+export declare function roundToMonth<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function roundToMonth<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T, roundingMode: RoundingMode): T;
+export declare function roundToMonth<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T, options: RoundingMathOptions): T;
+export declare function roundToWeek<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function roundToWeek<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T, roundingMode: RoundingMode): T;
+export declare function roundToWeek<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T, options: RoundingMathOptions): T;
+type NativeRoundFunc<T> = {
+    (date: T): T;
+    (date: T, roundingMode: RoundingMode): T;
+    (date: T, options: RoundingMathOptions): T;
+};
+type DayRoundable = Temporal.PlainDateTime | Temporal.ZonedDateTime;
+type TimeRoundable = Temporal.Instant | Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime;
+export declare const roundToDay: NativeRoundFunc<DayRoundable>;
+export declare const roundToHour: NativeRoundFunc<TimeRoundable>;
+export declare const roundToMinute: NativeRoundFunc<TimeRoundable>;
+export declare const roundToSecond: NativeRoundFunc<TimeRoundable>;
+export declare const roundToMillisecond: NativeRoundFunc<TimeRoundable>;
+export declare const roundToMicrosecond: NativeRoundFunc<TimeRoundable>;
+export {};

package/dist/round.js

@@ -0,0 +1,47 @@
+import * as errorMessages from './errorMessages.js';
+import { startOfMonth, startOfWeek, startOfYear } from './startOf.js';
+import { normalizeOptions } from './utils.js';
+export function roundToYear(date, options) {
+    const start = startOfYear(date);
+    const duration = start.until(date, normalizeRoundingOptions('year', options));
+    return start.add(duration);
+}
+export function roundToMonth(date, options) {
+    const start = startOfMonth(date);
+    const duration = start.until(date, normalizeRoundingOptions('month', options));
+    return start.add(duration);
+}
+export function roundToWeek(date, options) {
+    const start = startOfWeek(date);
+    const duration = start.until(date, normalizeRoundingOptions('week', options));
+    return start.add(duration);
+}
+export const roundToDay = ((date, options) => date.round(getNativeRoundOptions('day', options)));
+export const roundToHour = ((date, options) => date.round(getNativeRoundOptions('hour', options)));
+export const roundToMinute = ((date, options) => date.round(getNativeRoundOptions('minute', options)));
+export const roundToSecond = ((date, options) => date.round(getNativeRoundOptions('second', options)));
+export const roundToMillisecond = ((date, options) => date.round(getNativeRoundOptions('millisecond', options)));
+export const roundToMicrosecond = ((date, options) => date.round(getNativeRoundOptions('microsecond', options)));
+function getNativeRoundOptions(forcedUnit, options) {
+    return {
+        ...(typeof options === 'string'
+            ? { roundingMode: options }
+            : normalizeOptions(options)),
+        smallestUnit: forcedUnit,
+    };
+}
+function normalizeRoundingOptions(forcedUnit, options) {
+    // Accept a bare roundingMode string as shorthand for { roundingMode }.
+    const normOptions = typeof options === 'string'
+        ? { roundingMode: options }
+        : normalizeOptions(options);
+    // This is just for units >day
+    if (normOptions.roundingIncrement && normOptions.roundingIncrement !== 1) {
+        throw new RangeError(errorMessages.nonOneRoundingIncrement);
+    }
+    return {
+        roundingMode: 'halfExpand',
+        ...normOptions,
+        smallestUnit: forcedUnit,
+    };
+}

package/dist/startOf.d.ts

@@ -0,0 +1,9 @@
+export declare function startOfYear<T extends Temporal.PlainYearMonth | Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function startOfMonth<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function startOfWeek<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T): T;
+export declare function startOfDay<T extends Temporal.PlainDateTime | Temporal.ZonedDateTime>(dateTime: T): T;
+export declare function startOfHour<T extends Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>(dateTime: T): T;
+export declare function startOfMinute<T extends Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>(dateTime: T): T;
+export declare function startOfSecond<T extends Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>(dateTime: T): T;
+export declare function startOfMillisecond<T extends Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>(dateTime: T): T;
+export declare function startOfMicrosecond<T extends Temporal.PlainTime | Temporal.PlainDateTime | Temporal.ZonedDateTime>(dateTime: T): T;

package/dist/startOf.js

@@ -0,0 +1,73 @@
+import { withDayOfWeek } from './with.js';
+const zeroTimeFields = {
+    hour: 0,
+    minute: 0,
+    second: 0,
+    millisecond: 0,
+    microsecond: 0,
+    nanosecond: 0,
+};
+export function startOfYear(date) {
+    if (date.day === undefined) {
+        return date.with({ month: 1 });
+    }
+    return date.with({
+        month: 1,
+        day: 1,
+        ...zeroTimeFields,
+    });
+}
+export function startOfMonth(date) {
+    return date.with({
+        day: 1,
+        ...zeroTimeFields,
+    });
+}
+export function startOfWeek(date) {
+    const movedDate = withDayOfWeek(date, 1);
+    return movedDate
+        .withPlainTime
+        ? movedDate.withPlainTime()
+        : movedDate;
+}
+export function startOfDay(dateTime) {
+    if (dateTime.withPlainTime) {
+        return dateTime.withPlainTime();
+    }
+    return dateTime; // in case PlainDate passed in, no error
+}
+export function startOfHour(dateTime) {
+    return dateTime.with({
+        minute: 0,
+        second: 0,
+        millisecond: 0,
+        microsecond: 0,
+        nanosecond: 0,
+    });
+}
+export function startOfMinute(dateTime) {
+    return dateTime.with({
+        second: 0,
+        millisecond: 0,
+        microsecond: 0,
+        nanosecond: 0,
+    });
+}
+export function startOfSecond(dateTime) {
+    return dateTime.with({
+        millisecond: 0,
+        microsecond: 0,
+        nanosecond: 0,
+    });
+}
+export function startOfMillisecond(dateTime) {
+    return dateTime.with({
+        microsecond: 0,
+        nanosecond: 0,
+    });
+}
+export function startOfMicrosecond(dateTime) {
+    return dateTime.with({
+        nanosecond: 0,
+    });
+}

package/dist/utils.d.ts

@@ -0,0 +1,20 @@
+export declare const nanoInMicro = 1000;
+export declare const nanoInMilli = 1000000;
+export declare const nanoInSec = 1000000000;
+export declare const nanoInMinute = 60000000000;
+export declare const nanoInHour = 3600000000000;
+type RoundingUnit = Temporal.DateUnit | Temporal.TimeUnit;
+type RoundingOptionBag = Temporal.RoundingOptions<RoundingUnit>;
+export type RoundingMode = RoundingOptionBag['roundingMode'];
+export type RoundingMathOptions = Pick<RoundingOptionBag, 'roundingIncrement' | 'roundingMode'>;
+export declare function normalizeOptions<O extends {}>(options: O | undefined): O;
+export declare function toFiniteNumber(arg: number, entityName?: string): number;
+export declare function toIntegerWithTrunc(arg: number, entityName?: string): number;
+export declare function toPositiveIntegerWithTruncation(arg: number, entityName?: string): number;
+export declare function requireNumberIsPositive(num: number, entityName?: string): number;
+export declare function constrainToRange(num: number, min: number, max: number): number;
+export declare function isObjectLike(arg: unknown): arg is {};
+export declare function requireObjectLike<O extends {}>(arg: O): O;
+export declare function normalizeNumberInRange(num: number, min: number, max: number, // inclusive
+options?: Temporal.OverflowOptions): number;
+export {};

package/dist/utils.js

@@ -0,0 +1,81 @@
+import * as errorMessages from './errorMessages.js';
+export const nanoInMicro = 1_000;
+export const nanoInMilli = 1_000_000;
+export const nanoInSec = 1_000_000_000;
+export const nanoInMinute = 60_000_000_000;
+export const nanoInHour = 3_600_000_000_000;
+export function normalizeOptions(options) {
+    if (options === undefined) {
+        return Object.create(null);
+    }
+    return requireObjectLike(options);
+}
+export function toFiniteNumber(arg, entityName = 'number') {
+    if (typeof arg === 'bigint') {
+        throw new TypeError(errorMessages.forbiddenBigIntToNumber(entityName));
+    }
+    arg = Number(arg);
+    if (!Number.isFinite(arg)) {
+        throw new RangeError(errorMessages.expectedFinite(entityName, arg));
+    }
+    return arg;
+}
+export function toIntegerWithTrunc(arg, entityName) {
+    return Math.trunc(toFiniteNumber(arg, entityName)) || 0; // ensure no -0
+}
+export function toPositiveIntegerWithTruncation(arg, entityName) {
+    return requireNumberIsPositive(toIntegerWithTrunc(arg, entityName), entityName);
+}
+/*
+Already known to be number.
+*/
+export function requireNumberIsPositive(num, entityName = 'number') {
+    if (num <= 0) {
+        throw new RangeError(errorMessages.expectedPositive(entityName, num));
+    }
+    return num;
+}
+/*
+min/max are inclusive
+*/
+export function constrainToRange(num, min, max) {
+    return Math.min(Math.max(num, min), max);
+}
+export function isObjectLike(arg) {
+    return arg !== null && (typeof arg === 'object' || typeof arg === 'function');
+}
+export function requireObjectLike(arg) {
+    if (!isObjectLike(arg)) {
+        throw new TypeError(errorMessages.invalidObject);
+    }
+    return arg;
+}
+// Options-bag-parsing-adjacent
+// ----------------------------
+/*
+Already known to be number
+*/
+export function normalizeNumberInRange(num, min, max, // inclusive
+options) {
+    const clamped = constrainToRange(num, min, max);
+    if (normalizeOverflow(options) === 'reject' && num !== clamped) {
+        throw new RangeError(errorMessages.numberOutOfRange('number', num, min, max));
+    }
+    return clamped;
+}
+/*
+Match Temporal's field overflow shape without depending on the polyfill's
+internal option readers. Undefined defaults to constrain; explicit reject asks
+for exact in-range input.
+*/
+function normalizeOverflow(options) {
+    options = normalizeOptions(options);
+    const overflow = options.overflow;
+    if (overflow === undefined) {
+        return 'constrain';
+    }
+    if (overflow === 'constrain' || overflow === 'reject') {
+        return overflow;
+    }
+    throw new RangeError(errorMessages.invalidOverflowOption);
+}

package/dist/with.d.ts

@@ -0,0 +1,3 @@
+export declare function withDayOfYear<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T, dayOfYear: number, options?: Temporal.OverflowOptions): T;
+export declare function withDayOfWeek<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T, dayOfWeek: number, options?: Temporal.OverflowOptions): T;
+export declare function withWeekOfYear<T extends Temporal.PlainDate | Temporal.PlainDateTime | Temporal.ZonedDateTime>(date: T, weekOfYear: number, options?: Temporal.OverflowOptions): T;

package/dist/with.js

@@ -0,0 +1,44 @@
+import * as errorMessages from './errorMessages.js';
+import { normalizeNumberInRange, toIntegerWithTrunc } from './utils.js';
+const isoCalendarId = 'iso8601';
+export function withDayOfYear(date, dayOfYear, options) {
+    const normDayOfYear = normalizeNumberInRange(toIntegerWithTrunc(dayOfYear), 1, date.daysInYear, options);
+    return date.add({
+        days: normDayOfYear - date.dayOfYear,
+    });
+}
+export function withDayOfWeek(date, dayOfWeek, options) {
+    const normDayOfWeek = normalizeNumberInRange(toIntegerWithTrunc(dayOfWeek), 1, date.daysInWeek, options);
+    return date.add({
+        days: normDayOfWeek - date.dayOfWeek,
+    });
+}
+export function withWeekOfYear(date, weekOfYear, options) {
+    if (date.calendarId !== isoCalendarId) {
+        throw new RangeError(errorMessages.unsupportedWeekNumbers);
+    }
+    const currentWeekOfYear = date.weekOfYear;
+    const currentYearOfWeek = date.yearOfWeek;
+    const normWeekOfYear = normalizeNumberInRange(toIntegerWithTrunc(weekOfYear), 1, computeIsoWeeksInYear(currentYearOfWeek), options);
+    return date.add({
+        weeks: normWeekOfYear - currentWeekOfYear,
+    });
+}
+// Week Number Utils
+// TODO: make DRY with temporal-polyfill
+function computeIsoWeeksInYear(year) {
+    const y0DayOfWeek = computeIsoDayOfWeek(year, 1, 1);
+    return y0DayOfWeek === 4 || (y0DayOfWeek === 3 && computeIsoInLeapYear(year))
+        ? 53
+        : 52;
+}
+function computeIsoDayOfWeek(year, month, day) {
+    const legacyDate = new Date(0);
+    legacyDate.setUTCHours(0, 0, 0, 0);
+    legacyDate.setUTCFullYear(year, month - 1, day);
+    const dayOfWeek = legacyDate.getUTCDay();
+    return dayOfWeek || 7;
+}
+function computeIsoInLeapYear(year) {
+    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}

package/package.json

@@ -1,11 +1,57 @@
 {
   "name": "temporal-utils",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "1.0.1",
+  "title": "Temporal Utils",
+  "description": "Convenience helpers for native Temporal objects",
+  "author": {
+    "name": "Adam Shaw",
+    "email": "arshaw@users.noreply.github.com",
+    "url": "http://arshaw.com/"
+  },
+  "license": "MIT",
+  "copyright": "2026 Adam Shaw",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fullcalendar/temporal-polyfill.git",
+    "directory": "utils"
+  },
+  "files": [
+    "dist",
+    "!dist/*.tsbuildinfo"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./protected": {
+      "types": "./dist/protected.d.ts",
+      "import": "./dist/protected.js"
+    },
+    "./protected-error-messages": {
+      "types": "./dist/protected-error-messages.d.ts",
+      "import": "./dist/protected-error-messages.js"
+    }
   },
-  "author": "",
-  "license": "ISC"
-}
+  "type": "module",
+  "devDependencies": {
+    "@biomejs/biome": "1.5.1",
+    "@js-temporal/polyfill": "^0.5.1",
+    "typescript": "~5.3.3",
+    "vitest": "^1.2.2",
+    "temporal-spec": "1.0.0"
+  },
+  "scripts": {
+    "build": "pnpm run clean && tsc --build tsconfig.build.json",
+    "dev": "pnpm run clean && tsc --build tsconfig.dev.json --watch",
+    "lint": "biome check .",
+    "lint:fix": "biome check --apply .",
+    "test": "pnpm run vitest",
+    "vitest": "./scripts/vitest.js",
+    "vitest:dev": "vitest dev",
+    "vitest:debug": "vitest run --no-isolate --no-file-parallelism --test-timeout 3600000",
+    "clean": "rm -rf dist"
+  }
+}