@northguild/gmt 1.14.2

package/dist/plain/compare/areDatesEqualBy.d.ts

@@ -0,0 +1,34 @@
+import { Temporal } from "@js-temporal/polyfill";
+/**
+ * Compare two ISO date strings for equality at a given calendar unit.
+ *
+ * - Equality means both values share the same start-of-`unit` boundary, so
+ *   `"month"` requires the same month AND year — March 2023 and March 2024 are
+ *   NOT equal by month, matching date-fns's `isSameMonth` and Luxon's
+ *   `dt.hasSame(other, "month")`. This is a common point of confusion for
+ *   callers expecting a bare "same month-of-year" comparison.
+ * - `"day"` is equivalent to `areDatesEqual`.
+ * - `"year"`, `"month"`, `"week"` are computed via `startOfDate`.
+ * - Returns false for an unsupported unit or invalid input.
+ *
+ * Mapping from date-fns (Decision 5, `context/roadmap/issues/J.md`):
+ * - `isSameDay(a, b)` → `areDatesEqualBy(a, b, "day")`
+ * - `isSameWeek(a, b, options)` → `areDatesEqualBy(a, b, "week", { weekStartsOn })`
+ * - `isSameMonth(a, b)` → `areDatesEqualBy(a, b, "month")`
+ * - `isSameYear(a, b)` → `areDatesEqualBy(a, b, "year")`
+ *
+ * @param value1 first ISO date string
+ * @param value2 second ISO date string
+ * @param unit Temporal.DateUnit to compare by ("year" | "month" | "week" | "day")
+ * @param optionsArg optional: weekStartsOn ("monday" | "sunday")
+ * @returns true if both dates share the same start-of-unit boundary, false on an unsupported unit or invalid input
+ *
+ * @example areDatesEqualBy("2024-03-15", "2024-03-20", "month") // true
+ * @example areDatesEqualBy("2023-03-15", "2024-03-15", "month") // false (same month, different year)
+ * @example areDatesEqualBy("2024-03-15", "2024-03-16", "day") // false
+ * @example areDatesEqualBy("2024-03-15", "2024-03-15", "hour" as never) // false (unsupported unit)
+ * @example areDatesEqualBy("invalid", "2024-03-15", "month") // false
+ */
+export declare function areDatesEqualBy(value1: string, value2: string, unit: Temporal.DateUnit, optionsArg?: {
+    weekStartsOn?: "monday" | "sunday";
+}): boolean;

package/dist/plain/compare/areDatesEqualBy.js

@@ -0,0 +1,54 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { startOfDate } from "../calculate/startOfDate.js";
+import { isValidDate } from "../validate/index.js";
+import { areDatesEqual } from "./areDatesEqual.js";
+const supported = ["year", "month", "week", "day"];
+/**
+ * Compare two ISO date strings for equality at a given calendar unit.
+ *
+ * - Equality means both values share the same start-of-`unit` boundary, so
+ *   `"month"` requires the same month AND year — March 2023 and March 2024 are
+ *   NOT equal by month, matching date-fns's `isSameMonth` and Luxon's
+ *   `dt.hasSame(other, "month")`. This is a common point of confusion for
+ *   callers expecting a bare "same month-of-year" comparison.
+ * - `"day"` is equivalent to `areDatesEqual`.
+ * - `"year"`, `"month"`, `"week"` are computed via `startOfDate`.
+ * - Returns false for an unsupported unit or invalid input.
+ *
+ * Mapping from date-fns (Decision 5, `context/roadmap/issues/J.md`):
+ * - `isSameDay(a, b)` → `areDatesEqualBy(a, b, "day")`
+ * - `isSameWeek(a, b, options)` → `areDatesEqualBy(a, b, "week", { weekStartsOn })`
+ * - `isSameMonth(a, b)` → `areDatesEqualBy(a, b, "month")`
+ * - `isSameYear(a, b)` → `areDatesEqualBy(a, b, "year")`
+ *
+ * @param value1 first ISO date string
+ * @param value2 second ISO date string
+ * @param unit Temporal.DateUnit to compare by ("year" | "month" | "week" | "day")
+ * @param optionsArg optional: weekStartsOn ("monday" | "sunday")
+ * @returns true if both dates share the same start-of-unit boundary, false on an unsupported unit or invalid input
+ *
+ * @example areDatesEqualBy("2024-03-15", "2024-03-20", "month") // true
+ * @example areDatesEqualBy("2023-03-15", "2024-03-15", "month") // false (same month, different year)
+ * @example areDatesEqualBy("2024-03-15", "2024-03-16", "day") // false
+ * @example areDatesEqualBy("2024-03-15", "2024-03-15", "hour" as never) // false (unsupported unit)
+ * @example areDatesEqualBy("invalid", "2024-03-15", "month") // false
+ */
+export function areDatesEqualBy(value1, value2, unit, optionsArg) {
+    if (!isValidDate(value1) ||
+        !isValidDate(value2) ||
+        !supported.includes(unit)) {
+        return false;
+    }
+    // "day" has no coarser boundary to reset, so this is just direct equality.
+    if (unit === "day") {
+        return areDatesEqual(value1, value2);
+    }
+    try {
+        const start1 = startOfDate(value1, unit, optionsArg);
+        const start2 = startOfDate(value2, unit, optionsArg);
+        return start1 !== "" && start1 === start2;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/compare/areTimesEqual.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Return true if two PlainTime ISO strings represent the same time components.
+ *
+ * - Compares all time components: hour, minute, second, millisecond, microsecond, nanosecond.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 first ISO PlainTime string
+ * @param value2 second ISO PlainTime string
+ * @returns boolean indicating whether both times are equal component-wise
+ *
+ * @example areTimesEqual("12:34:56", "12:34:56") // true
+ * @example areTimesEqual("12:34:56", "12:34:57") // false
+ * @example areTimesEqual("12:34:56.789", "12:34:56.789") // true
+ * @example areTimesEqual("12:34:56.789", "12:34:56.790") // false
+ * @example areTimesEqual("invalid", "12:34:56") // false
+ * @example areTimesEqual("12:34:56", "invalid") // false
+ */
+export declare function areTimesEqual(value1: string, value2: string): boolean;

package/dist/plain/compare/areTimesEqual.js

@@ -0,0 +1,37 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidTime } from "../validate/index.js";
+/**
+ * Return true if two PlainTime ISO strings represent the same time components.
+ *
+ * - Compares all time components: hour, minute, second, millisecond, microsecond, nanosecond.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 first ISO PlainTime string
+ * @param value2 second ISO PlainTime string
+ * @returns boolean indicating whether both times are equal component-wise
+ *
+ * @example areTimesEqual("12:34:56", "12:34:56") // true
+ * @example areTimesEqual("12:34:56", "12:34:57") // false
+ * @example areTimesEqual("12:34:56.789", "12:34:56.789") // true
+ * @example areTimesEqual("12:34:56.789", "12:34:56.790") // false
+ * @example areTimesEqual("invalid", "12:34:56") // false
+ * @example areTimesEqual("12:34:56", "invalid") // false
+ */
+export function areTimesEqual(value1, value2) {
+    if (!isValidTime(value1) || !isValidTime(value2)) {
+        return false;
+    }
+    try {
+        const time1 = Temporal.PlainTime.from(value1);
+        const time2 = Temporal.PlainTime.from(value2);
+        return (time1.hour === time2.hour &&
+            time1.minute === time2.minute &&
+            time1.second === time2.second &&
+            time1.millisecond === time2.millisecond &&
+            time1.microsecond === time2.microsecond &&
+            time1.nanosecond === time2.nanosecond);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/compare/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./areDatesEqual.js";
+export * from "./areDatesEqualBy.js";
+export * from "./areDateTimesEqual.js";
+export * from "./areDateTimesEqualBy.js";
+export * from "./areTimesEqual.js";
+export * from "./isAfterDate.js";
+export * from "./isAfterDateTime.js";
+export * from "./isAfterTime.js";
+export * from "./isBeforeDate.js";
+export * from "./isBeforeDateTime.js";
+export * from "./isBeforeTime.js";
+export * from "./isBetweenDate.js";
+export * from "./isBetweenDateTime.js";
+export * from "./isBetweenTime.js";
+export * from "./isBusinessDay.js";
+export * from "./isFuture.js";
+export * from "./isPast.js";
+export * from "./isRelativeDay.js";
+export * from "./isThisUnit.js";
+export * from "./isWeekend.js";

package/dist/plain/compare/index.js

@@ -0,0 +1,20 @@
+export * from "./areDatesEqual.js";
+export * from "./areDatesEqualBy.js";
+export * from "./areDateTimesEqual.js";
+export * from "./areDateTimesEqualBy.js";
+export * from "./areTimesEqual.js";
+export * from "./isAfterDate.js";
+export * from "./isAfterDateTime.js";
+export * from "./isAfterTime.js";
+export * from "./isBeforeDate.js";
+export * from "./isBeforeDateTime.js";
+export * from "./isBeforeTime.js";
+export * from "./isBetweenDate.js";
+export * from "./isBetweenDateTime.js";
+export * from "./isBetweenTime.js";
+export * from "./isBusinessDay.js";
+export * from "./isFuture.js";
+export * from "./isPast.js";
+export * from "./isRelativeDay.js";
+export * from "./isThisUnit.js";
+export * from "./isWeekend.js";

package/dist/plain/compare/isAfterDate.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Return true if the first ISO PlainDate string represents a date after the second.
+ *
+ * - Uses Temporal.PlainDate.compare to compare dates.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 first ISO PlainDate string
+ * @param value2 second ISO PlainDate string
+ * @returns boolean indicating whether value1 is after value2
+ *
+ * @example isAfterDate("2024-03-01", "2024-02-29") // true
+ * @example isAfterDate("2024-02-28", "2024-02-29") // false
+ * @example isAfterDate("invalid", "2024-02-29") // false
+ * @example isAfterDate("2024-02-29", "invalid") // false
+ */
+export declare function isAfterDate(value1: string, value2: string): boolean;

package/dist/plain/compare/isAfterDate.js

@@ -0,0 +1,28 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDate } from "../validate/index.js";
+/**
+ * Return true if the first ISO PlainDate string represents a date after the second.
+ *
+ * - Uses Temporal.PlainDate.compare to compare dates.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 first ISO PlainDate string
+ * @param value2 second ISO PlainDate string
+ * @returns boolean indicating whether value1 is after value2
+ *
+ * @example isAfterDate("2024-03-01", "2024-02-29") // true
+ * @example isAfterDate("2024-02-28", "2024-02-29") // false
+ * @example isAfterDate("invalid", "2024-02-29") // false
+ * @example isAfterDate("2024-02-29", "invalid") // false
+ */
+export function isAfterDate(value1, value2) {
+    if (!isValidDate(value1) || !isValidDate(value2)) {
+        return false;
+    }
+    try {
+        return (Temporal.PlainDate.compare(Temporal.PlainDate.from(value1), Temporal.PlainDate.from(value2)) === 1);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/compare/isAfterDateTime.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Return true when `value1` is strictly after `value2` for PlainDateTime values.
+ *
+ * - Uses Temporal.PlainDateTime.compare to compare date-times.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 ISO PlainDateTime string for the first value
+ * @param value2 ISO PlainDateTime string for the second value
+ * @returns boolean indicating whether value1 > value2
+ *
+ * @example isAfterDateTime("2024-02-29T12:34:56", "2024-02-28T12:34:56") // true
+ * @example isAfterDateTime("2024-02-29T12:34:56", "2024-02-29T12:34:56") // false
+ * @example isAfterDateTime("2024-02-28T12:34:56", "2024-02-29T12:34:56") // false
+ * @example isAfterDateTime("invalid", "2024-02-29T12:34:56") // false
+ * @example isAfterDateTime("2024-02-29T12:34:56", "invalid") // false
+ */
+export declare function isAfterDateTime(value1: string, value2: string): boolean;

package/dist/plain/compare/isAfterDateTime.js

@@ -0,0 +1,29 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDateTime } from "../validate/index.js";
+/**
+ * Return true when `value1` is strictly after `value2` for PlainDateTime values.
+ *
+ * - Uses Temporal.PlainDateTime.compare to compare date-times.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 ISO PlainDateTime string for the first value
+ * @param value2 ISO PlainDateTime string for the second value
+ * @returns boolean indicating whether value1 > value2
+ *
+ * @example isAfterDateTime("2024-02-29T12:34:56", "2024-02-28T12:34:56") // true
+ * @example isAfterDateTime("2024-02-29T12:34:56", "2024-02-29T12:34:56") // false
+ * @example isAfterDateTime("2024-02-28T12:34:56", "2024-02-29T12:34:56") // false
+ * @example isAfterDateTime("invalid", "2024-02-29T12:34:56") // false
+ * @example isAfterDateTime("2024-02-29T12:34:56", "invalid") // false
+ */
+export function isAfterDateTime(value1, value2) {
+    if (!isValidDateTime(value1) || !isValidDateTime(value2)) {
+        return false;
+    }
+    try {
+        return (Temporal.PlainDateTime.compare(Temporal.PlainDateTime.from(value1), Temporal.PlainDateTime.from(value2)) === 1);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/compare/isAfterTime.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Return true when `value1` is strictly after `value2` for PlainTime values.
+ *
+ * - Uses Temporal.PlainTime.compare to compare times.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 ISO PlainTime string for the first value
+ * @param value2 ISO PlainTime string for the second value
+ * @returns boolean indicating whether value1 > value2
+ *
+ * @example isAfterTime("12:34:56", "11:34:56") // true
+ * @example isAfterTime("12:34:56", "12:34:56") // false
+ * @example isAfterTime("11:34:56", "12:34:56") // false
+ * @example isAfterTime("invalid", "12:34:56") // false
+ * @example isAfterTime("12:34:56", "invalid") // false
+ */
+export declare function isAfterTime(value1: string, value2: string): boolean;

package/dist/plain/compare/isAfterTime.js

@@ -0,0 +1,29 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidTime } from "../validate/index.js";
+/**
+ * Return true when `value1` is strictly after `value2` for PlainTime values.
+ *
+ * - Uses Temporal.PlainTime.compare to compare times.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 ISO PlainTime string for the first value
+ * @param value2 ISO PlainTime string for the second value
+ * @returns boolean indicating whether value1 > value2
+ *
+ * @example isAfterTime("12:34:56", "11:34:56") // true
+ * @example isAfterTime("12:34:56", "12:34:56") // false
+ * @example isAfterTime("11:34:56", "12:34:56") // false
+ * @example isAfterTime("invalid", "12:34:56") // false
+ * @example isAfterTime("12:34:56", "invalid") // false
+ */
+export function isAfterTime(value1, value2) {
+    if (!isValidTime(value1) || !isValidTime(value2)) {
+        return false;
+    }
+    try {
+        return (Temporal.PlainTime.compare(Temporal.PlainTime.from(value1), Temporal.PlainTime.from(value2)) === 1);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/compare/isBeforeDate.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Return true when `value1` is strictly before `value2` for PlainDate values.
+ *
+ * - Uses Temporal.PlainDate.compare to compare dates.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 ISO PlainDate string for the first value
+ * @param value2 ISO PlainDate string for the second value
+ * @returns boolean indicating whether value1 < value2
+ *
+ * @example isBeforeDate("2024-02-28", "2024-02-29") // true
+ * @example isBeforeDate("2024-02-29", "2024-02-29") // false
+ * @example isBeforeDate("2024-02-29", "2024-02-28") // false
+ * @example isBeforeDate("invalid", "2024-02-29") // false
+ * @example isBeforeDate("2024-02-29", "invalid") // false
+ */
+export declare function isBeforeDate(value1: string, value2: string): boolean;

package/dist/plain/compare/isBeforeDate.js

@@ -0,0 +1,29 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDate } from "../validate/index.js";
+/**
+ * Return true when `value1` is strictly before `value2` for PlainDate values.
+ *
+ * - Uses Temporal.PlainDate.compare to compare dates.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 ISO PlainDate string for the first value
+ * @param value2 ISO PlainDate string for the second value
+ * @returns boolean indicating whether value1 < value2
+ *
+ * @example isBeforeDate("2024-02-28", "2024-02-29") // true
+ * @example isBeforeDate("2024-02-29", "2024-02-29") // false
+ * @example isBeforeDate("2024-02-29", "2024-02-28") // false
+ * @example isBeforeDate("invalid", "2024-02-29") // false
+ * @example isBeforeDate("2024-02-29", "invalid") // false
+ */
+export function isBeforeDate(value1, value2) {
+    if (!isValidDate(value1) || !isValidDate(value2)) {
+        return false;
+    }
+    try {
+        return (Temporal.PlainDate.compare(Temporal.PlainDate.from(value1), Temporal.PlainDate.from(value2)) === -1);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/compare/isBeforeDateTime.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Return true when `value1` is strictly before `value2` for PlainDateTime values.
+ *
+ * - Uses Temporal.PlainDateTime.compare to compare date-times.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 ISO PlainDateTime string for the first value
+ * @param value2 ISO PlainDateTime string for the second value
+ * @returns boolean indicating whether value1 < value2
+ *
+ * @example isBeforeDateTime("2024-02-28T12:34:56", "2024-02-29T12:34:56") // true
+ * @example isBeforeDateTime("2024-02-29T12:34:56", "2024-02-29T12:34:56") // false
+ * @example isBeforeDateTime("2024-02-29T12:34:56", "2024-02-28T12:34:56") // false
+ * @example isBeforeDateTime("invalid", "2024-02-29T12:34:56") // false
+ * @example isBeforeDateTime("2024-02-29T12:34:56", "invalid") // false
+ */
+export declare function isBeforeDateTime(value1: string, value2: string): boolean;

package/dist/plain/compare/isBeforeDateTime.js

@@ -0,0 +1,29 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDateTime } from "../validate/index.js";
+/**
+ * Return true when `value1` is strictly before `value2` for PlainDateTime values.
+ *
+ * - Uses Temporal.PlainDateTime.compare to compare date-times.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 ISO PlainDateTime string for the first value
+ * @param value2 ISO PlainDateTime string for the second value
+ * @returns boolean indicating whether value1 < value2
+ *
+ * @example isBeforeDateTime("2024-02-28T12:34:56", "2024-02-29T12:34:56") // true
+ * @example isBeforeDateTime("2024-02-29T12:34:56", "2024-02-29T12:34:56") // false
+ * @example isBeforeDateTime("2024-02-29T12:34:56", "2024-02-28T12:34:56") // false
+ * @example isBeforeDateTime("invalid", "2024-02-29T12:34:56") // false
+ * @example isBeforeDateTime("2024-02-29T12:34:56", "invalid") // false
+ */
+export function isBeforeDateTime(value1, value2) {
+    if (!isValidDateTime(value1) || !isValidDateTime(value2)) {
+        return false;
+    }
+    try {
+        return (Temporal.PlainDateTime.compare(Temporal.PlainDateTime.from(value1), Temporal.PlainDateTime.from(value2)) === -1);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/compare/isBeforeTime.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Return true when `value1` is strictly before `value2` for PlainTime values.
+ *
+ * - Uses Temporal.PlainTime.compare to compare times.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 ISO PlainTime string for the first value
+ * @param value2 ISO PlainTime string for the second value
+ * @returns boolean indicating whether value1 < value2
+ *
+ * @example isBeforeTime("12:34:56", "13:34:56") // true
+ * @example isBeforeTime("12:34:56", "12:34:56") // false
+ * @example isBeforeTime("13:34:56", "12:34:56") // false
+ * @example isBeforeTime("invalid", "12:34:56") // false
+ * @example isBeforeTime("12:34:56", "invalid") // false
+ */
+export declare function isBeforeTime(value1: string, value2: string): boolean;

package/dist/plain/compare/isBeforeTime.js

@@ -0,0 +1,29 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidTime } from "../validate/index.js";
+/**
+ * Return true when `value1` is strictly before `value2` for PlainTime values.
+ *
+ * - Uses Temporal.PlainTime.compare to compare times.
+ * - Returns false if either input is invalid.
+ *
+ * @param value1 ISO PlainTime string for the first value
+ * @param value2 ISO PlainTime string for the second value
+ * @returns boolean indicating whether value1 < value2
+ *
+ * @example isBeforeTime("12:34:56", "13:34:56") // true
+ * @example isBeforeTime("12:34:56", "12:34:56") // false
+ * @example isBeforeTime("13:34:56", "12:34:56") // false
+ * @example isBeforeTime("invalid", "12:34:56") // false
+ * @example isBeforeTime("12:34:56", "invalid") // false
+ */
+export function isBeforeTime(value1, value2) {
+    if (!isValidTime(value1) || !isValidTime(value2)) {
+        return false;
+    }
+    try {
+        return (Temporal.PlainTime.compare(Temporal.PlainTime.from(value1), Temporal.PlainTime.from(value2)) === -1);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/compare/isBetweenDate.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Return true when `date` is between `start` and `end` (inclusive by default).
+ *
+ * - Uses Temporal.PlainDate.compare to compare dates.
+ * - Returns false if start > end (invalid range).
+ * - Returns false if any input is invalid.
+ * - Use options.inclusiveStart and options.inclusiveEnd to control boundary inclusivity.
+ *
+ * @param date ISO PlainDate string to check
+ * @param start ISO PlainDate string for the start of the range
+ * @param end ISO PlainDate string for the end of the range
+ * @param options { inclusiveStart?: boolean = true, inclusiveEnd?: boolean = true }
+ * @returns boolean indicating whether date is between start and end
+ *
+ * @example isBetweenDate("2024-02-29", "2024-02-01", "2024-02-28") // false
+ * @example isBetweenDate("2024-02-29", "2024-02-01", "2024-02-29") // true
+ * @example isBetweenDate("2024-02-29", "2024-02-29", "2024-02-28") // false
+ * @example isBetweenDate("2024-02-29", "2024-02-28", "2024-03-01") // true
+ * @example isBetweenDate("invalid", "2024-02-01", "2024-02-28") // false
+ * @example isBetweenDate("2024-02-29", "invalid", "2024-02-28") // false
+ * @example isBetweenDate("2024-02-29", "2024-02-01", "invalid") // false
+ */
+export declare function isBetweenDate(date: string, start: string, end: string, options?: {
+    inclusiveStart?: boolean;
+    inclusiveEnd?: boolean;
+}): boolean;

package/dist/plain/compare/isBetweenDate.js

@@ -0,0 +1,49 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDate } from "../validate/index.js";
+/**
+ * Return true when `date` is between `start` and `end` (inclusive by default).
+ *
+ * - Uses Temporal.PlainDate.compare to compare dates.
+ * - Returns false if start > end (invalid range).
+ * - Returns false if any input is invalid.
+ * - Use options.inclusiveStart and options.inclusiveEnd to control boundary inclusivity.
+ *
+ * @param date ISO PlainDate string to check
+ * @param start ISO PlainDate string for the start of the range
+ * @param end ISO PlainDate string for the end of the range
+ * @param options { inclusiveStart?: boolean = true, inclusiveEnd?: boolean = true }
+ * @returns boolean indicating whether date is between start and end
+ *
+ * @example isBetweenDate("2024-02-29", "2024-02-01", "2024-02-28") // false
+ * @example isBetweenDate("2024-02-29", "2024-02-01", "2024-02-29") // true
+ * @example isBetweenDate("2024-02-29", "2024-02-29", "2024-02-28") // false
+ * @example isBetweenDate("2024-02-29", "2024-02-28", "2024-03-01") // true
+ * @example isBetweenDate("invalid", "2024-02-01", "2024-02-28") // false
+ * @example isBetweenDate("2024-02-29", "invalid", "2024-02-28") // false
+ * @example isBetweenDate("2024-02-29", "2024-02-01", "invalid") // false
+ */
+export function isBetweenDate(date, start, end, options) {
+    const inclusiveStart = options?.inclusiveStart ?? true;
+    const inclusiveEnd = options?.inclusiveEnd ?? true;
+    if (!isValidDate(date) || !isValidDate(start) || !isValidDate(end)) {
+        return false;
+    }
+    try {
+        const d = Temporal.PlainDate.from(date);
+        const s = Temporal.PlainDate.from(start);
+        const e = Temporal.PlainDate.from(end);
+        if (Temporal.PlainDate.compare(s, e) === 1) {
+            return false;
+        }
+        const startCheck = inclusiveStart
+            ? Temporal.PlainDate.compare(s, d) <= 0
+            : Temporal.PlainDate.compare(s, d) < 0;
+        const endCheck = inclusiveEnd
+            ? Temporal.PlainDate.compare(d, e) <= 0
+            : Temporal.PlainDate.compare(d, e) < 0;
+        return startCheck && endCheck;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plain/compare/isBetweenDateTime.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Return true when `dateTime` is between `start` and `end` (inclusive by default).
+ *
+ * - Uses Temporal.PlainDateTime.compare to compare date-times.
+ * - Returns false if start > end (invalid range).
+ * - Returns false if any input is invalid.
+ * - Use options.inclusiveStart and options.inclusiveEnd to control boundary inclusivity.
+ *
+ * @param dateTime ISO PlainDateTime string to check
+ * @param start ISO PlainDateTime string for the start of the range
+ * @param end ISO PlainDateTime string for the end of the range
+ * @param options { inclusiveStart?: boolean = true, inclusiveEnd?: boolean = true }
+ * @returns boolean indicating whether dateTime is between start and end
+ *
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "2024-02-01T00:00:00", "2024-02-28T23:59:59") // false
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "2024-02-01T00:00:00", "2024-02-29T12:00:00") // true
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "2024-02-29T12:00:00", "2024-02-28T23:59:59") // false
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "2024-02-28T23:59:59", "2024-03-01T00:00:00") // true
+ * @example isBetweenDateTime("invalid", "2024-02-01T00:00:00", "2024-02-28T23:59:59") // false
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "invalid", "2024-02-28T23:59:59") // false
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "2024-02-01T00:00:00", "invalid") // false
+ */
+export declare function isBetweenDateTime(dateTime: string, start: string, end: string, options?: {
+    inclusiveStart?: boolean;
+    inclusiveEnd?: boolean;
+}): boolean;

package/dist/plain/compare/isBetweenDateTime.js

@@ -0,0 +1,51 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { isValidDateTime } from "../validate/index.js";
+/**
+ * Return true when `dateTime` is between `start` and `end` (inclusive by default).
+ *
+ * - Uses Temporal.PlainDateTime.compare to compare date-times.
+ * - Returns false if start > end (invalid range).
+ * - Returns false if any input is invalid.
+ * - Use options.inclusiveStart and options.inclusiveEnd to control boundary inclusivity.
+ *
+ * @param dateTime ISO PlainDateTime string to check
+ * @param start ISO PlainDateTime string for the start of the range
+ * @param end ISO PlainDateTime string for the end of the range
+ * @param options { inclusiveStart?: boolean = true, inclusiveEnd?: boolean = true }
+ * @returns boolean indicating whether dateTime is between start and end
+ *
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "2024-02-01T00:00:00", "2024-02-28T23:59:59") // false
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "2024-02-01T00:00:00", "2024-02-29T12:00:00") // true
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "2024-02-29T12:00:00", "2024-02-28T23:59:59") // false
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "2024-02-28T23:59:59", "2024-03-01T00:00:00") // true
+ * @example isBetweenDateTime("invalid", "2024-02-01T00:00:00", "2024-02-28T23:59:59") // false
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "invalid", "2024-02-28T23:59:59") // false
+ * @example isBetweenDateTime("2024-02-29T12:00:00", "2024-02-01T00:00:00", "invalid") // false
+ */
+export function isBetweenDateTime(dateTime, start, end, options) {
+    const inclusiveStart = options?.inclusiveStart ?? true;
+    const inclusiveEnd = options?.inclusiveEnd ?? true;
+    if (!isValidDateTime(dateTime) ||
+        !isValidDateTime(start) ||
+        !isValidDateTime(end)) {
+        return false;
+    }
+    try {
+        const d = Temporal.PlainDateTime.from(dateTime);
+        const s = Temporal.PlainDateTime.from(start);
+        const e = Temporal.PlainDateTime.from(end);
+        if (Temporal.PlainDateTime.compare(s, e) === 1) {
+            return false;
+        }
+        const startCheck = inclusiveStart
+            ? Temporal.PlainDateTime.compare(s, d) <= 0
+            : Temporal.PlainDateTime.compare(s, d) < 0;
+        const endCheck = inclusiveEnd
+            ? Temporal.PlainDateTime.compare(d, e) <= 0
+            : Temporal.PlainDateTime.compare(d, e) < 0;
+        return startCheck && endCheck;
+    }
+    catch {
+        return false;
+    }
+}