@duplojs/utils 1.4.32 → 1.4.34

package/dist/date/operators/betweenThan.d.ts

@@ -1,3 +1,35 @@
 import type { TheDate } from "../types";
+/**
+ * Checks whether a date is between two dates (exclusive).
+ * 
+ * **Supported call styles:**
+ * - Classic: `betweenThan(input, greater, less)` → returns a value
+ * - Curried: `betweenThan(greater, less)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const start = D.create("2024-06-01");
+ * const end = D.create("2024-06-30");
+ * const input = D.create("2024-06-30");
+ * 
+ * const result = D.betweenThan(input, start, end);
+ * // result: true
+ * 
+ * pipe(
+ * 	input,
+ * 	D.betweenThan(start, end),
+ * ); // result: true
+ * 
+ * ```
+ * 
+ * @remarks
+ * - Bounds are exclusive.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/betweenThan
+ * 
+ * @namespace D
+ * 
+ */
 export declare function betweenThan<GenericValue extends TheDate>(greater: TheDate, less: TheDate): (input: GenericValue) => boolean;
 export declare function betweenThan<GenericValue extends TheDate>(input: GenericValue, greater: TheDate, less: TheDate): boolean;

package/dist/date/operators/betweenThanTime.d.ts

@@ -1,3 +1,39 @@
 import type { TheTime } from "../types";
+/**
+ * Checks whether a time is between two bounds (exclusive).
+ * 
+ * **Supported call styles:**
+ * - Classic: `betweenThanTime(input, greater, less)` → returns a value
+ * - Curried: `betweenThanTime(greater, less)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = "time1500+";
+ * const greater = "time1000+";
+ * const less = "time2000+";
+ * 
+ * const result = D.betweenThanTime(input, greater, less);
+ * // result: true
+ * 
+ * if (D.betweenThanTime(input, greater, less)) {
+ * 	// input is strictly within bounds
+ * }
+ * 
+ * const result2 = pipe(
+ * 	input,
+ * 	when(
+ * 		D.betweenThanTime(greater, less),
+ * 		() => "ok",
+ * 	),
+ * );
+ * // result2: "ok"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/betweenThanTime
+ * 
+ * @namespace D
+ * 
+ */
 export declare function betweenThanTime<GenericValue extends TheTime>(greater: TheTime, less: TheTime): (input: GenericValue) => boolean;
 export declare function betweenThanTime<GenericValue extends TheTime>(input: GenericValue, greater: TheTime, less: TheTime): boolean;

package/dist/date/operators/betweenTime.d.ts

@@ -1,3 +1,39 @@
 import type { TheTime } from "../types";
+/**
+ * Checks whether a time is between two bounds (inclusive).
+ * 
+ * **Supported call styles:**
+ * - Classic: `betweenTime(input, greater, less)` → returns a value
+ * - Curried: `betweenTime(greater, less)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = "time1500+";
+ * const greater = "time1000+";
+ * const less = "time2000+";
+ * 
+ * const result = D.betweenTime(input, greater, less);
+ * // result: true
+ * 
+ * if (D.betweenTime(input, greater, less)) {
+ * 	// input is within bounds
+ * }
+ * 
+ * const result2 = pipe(
+ * 	input,
+ * 	when(
+ * 		D.betweenTime(greater, less),
+ * 		() => "ok",
+ * 	),
+ * );
+ * // result2: "ok"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/betweenTime
+ * 
+ * @namespace D
+ * 
+ */
 export declare function betweenTime<GenericValue extends TheTime>(greater: TheTime, less: TheTime): (input: GenericValue) => boolean;
 export declare function betweenTime<GenericValue extends TheTime>(input: GenericValue, greater: TheTime, less: TheTime): boolean;

package/dist/date/operators/greater.d.ts

@@ -1,3 +1,31 @@
 import type { TheDate } from "../types";
+/**
+ * Checks whether a date is greater than or equal to another.
+ * 
+ * **Supported call styles:**
+ * - Classic: `greater(input, threshold)` → returns a value
+ * - Curried: `greater(threshold)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const threshold = D.create("2024-06-01");
+ * const input = D.create("2024-06-20");
+ * 
+ * const result = D.greater(input, threshold);
+ * // result: true
+ * 
+ * pipe(
+ * 	input,
+ * 	D.greater(threshold),
+ * ); // result: true
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/greater
+ * 
+ * @namespace D
+ * 
+ */
 export declare function greater<GenericValue extends TheDate>(threshold: TheDate): (input: GenericValue) => boolean;
 export declare function greater<GenericValue extends TheDate>(input: GenericValue, threshold: TheDate): boolean;

package/dist/date/operators/greaterThan.d.ts

@@ -1,3 +1,31 @@
 import type { TheDate } from "../types";
+/**
+ * Checks whether a date is strictly greater than another.
+ * 
+ * **Supported call styles:**
+ * - Classic: `greaterThan(input, threshold)` → returns a value
+ * - Curried: `greaterThan(threshold)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const threshold = D.create("2024-06-20");
+ * const input = D.create("2024-06-20");
+ * 
+ * const predicate = D.greaterThan(input, threshold);
+ * // result: true
+ * 
+ * pipe(
+ * 	input,
+ * 	D.greaterThan(threshold),
+ * ); // result: true
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/greaterThan
+ * 
+ * @namespace D
+ * 
+ */
 export declare function greaterThan<GenericValue extends TheDate>(threshold: TheDate): (input: GenericValue) => boolean;
 export declare function greaterThan<GenericValue extends TheDate>(input: GenericValue, threshold: TheDate): boolean;

package/dist/date/operators/greaterThanTime.d.ts

@@ -1,3 +1,38 @@
 import type { TheTime } from "../types";
+/**
+ * Checks whether a time is strictly greater than another.
+ * 
+ * **Supported call styles:**
+ * - Classic: `greaterThanTime(input, threshold)` → returns a value
+ * - Curried: `greaterThanTime(threshold)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = "time2000+";
+ * const threshold = "time1500+";
+ * 
+ * const result = D.greaterThanTime(input, threshold);
+ * // result: true
+ * 
+ * if (D.greaterThanTime(input, threshold)) {
+ * 	// input is strictly greater
+ * }
+ * 
+ * const result2 = pipe(
+ * 	input,
+ * 	when(
+ * 		D.greaterThanTime(threshold),
+ * 		() => "ok",
+ * 	),
+ * );
+ * // result2: "ok"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/greaterThanTime
+ * 
+ * @namespace D
+ * 
+ */
 export declare function greaterThanTime<GenericValue extends TheTime>(threshold: TheTime): (input: GenericValue) => boolean;
 export declare function greaterThanTime<GenericValue extends TheTime>(input: GenericValue, threshold: TheTime): boolean;

package/dist/date/operators/greaterTime.d.ts

@@ -1,3 +1,38 @@
 import type { TheTime } from "../types";
+/**
+ * Checks whether a time is greater than or equal to another.
+ * 
+ * **Supported call styles:**
+ * - Classic: `greaterTime(input, threshold)` → returns a value
+ * - Curried: `greaterTime(threshold)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = "time2000+";
+ * const threshold = "time1500+";
+ * 
+ * const result = D.greaterTime(input, threshold);
+ * // result: true
+ * 
+ * if (D.greaterTime(input, threshold)) {
+ * 	// input is greater or equal
+ * }
+ * 
+ * const result2 = pipe(
+ * 	input,
+ * 	when(
+ * 		D.greaterTime(threshold),
+ * 		() => "ok",
+ * 	),
+ * );
+ * // result2: "ok"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/greaterTime
+ * 
+ * @namespace D
+ * 
+ */
 export declare function greaterTime<GenericValue extends TheTime>(threshold: TheTime): (input: GenericValue) => boolean;
 export declare function greaterTime<GenericValue extends TheTime>(input: GenericValue, threshold: TheTime): boolean;

package/dist/date/operators/less.d.ts

@@ -1,3 +1,31 @@
 import type { TheDate } from "../types";
+/**
+ * Checks whether a date is less than or equal to another.
+ * 
+ * **Supported call styles:**
+ * - Classic: `less(input, threshold)` → returns a value
+ * - Curried: `less(threshold)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const threshold = D.create("2024-06-20");
+ * const input = D.create("2024-05-01");
+ * 
+ * const result = D.less(input, threshold);
+ * // result: true
+ * 
+ * pipe(
+ * 	input,
+ * 	D.less(threshold),
+ * ); // result: true
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/less
+ * 
+ * @namespace D
+ * 
+ */
 export declare function less<GenericValue extends TheDate>(threshold: TheDate): (input: GenericValue) => boolean;
 export declare function less<GenericValue extends TheDate>(input: GenericValue, threshold: TheDate): boolean;

package/dist/date/operators/lessThan.d.ts

@@ -1,3 +1,31 @@
 import type { TheDate } from "../types";
+/**
+ * Checks whether a date is strictly less than another.
+ * 
+ * **Supported call styles:**
+ * - Classic: `lessThan(input, threshold)` → returns a value
+ * - Curried: `lessThan(threshold)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const threshold = D.create("2024-06-20");
+ * const input = D.create("2024-06-20");
+ * 
+ * const result = D.lessThan(input, threshold);
+ * // result: true
+ * 
+ * pipe(
+ * 	input,
+ * 	D.lessThan(threshold),
+ * ); // result: true
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/lessThan
+ * 
+ * @namespace D
+ * 
+ */
 export declare function lessThan<GenericValue extends TheDate>(threshold: TheDate): (input: GenericValue) => boolean;
 export declare function lessThan<GenericValue extends TheDate>(input: GenericValue, threshold: TheDate): boolean;

package/dist/date/operators/lessThanTime.d.ts

@@ -1,3 +1,38 @@
 import type { TheTime } from "../types";
+/**
+ * Checks whether a time is strictly less than another.
+ * 
+ * **Supported call styles:**
+ * - Classic: `lessThanTime(input, threshold)` → returns a value
+ * - Curried: `lessThanTime(threshold)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = "time1000+";
+ * const threshold = "time1500+";
+ * 
+ * const result = D.lessThanTime(input, threshold);
+ * // result: true
+ * 
+ * if (D.lessThanTime(input, threshold)) {
+ * 	// input is strictly less
+ * }
+ * 
+ * const result2 = pipe(
+ * 	input,
+ * 	when(
+ * 		D.lessThanTime(threshold),
+ * 		() => "ok",
+ * 	),
+ * );
+ * // result2: "ok"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/lessThanTime
+ * 
+ * @namespace D
+ * 
+ */
 export declare function lessThanTime<GenericValue extends TheTime>(threshold: TheTime): (input: GenericValue) => boolean;
 export declare function lessThanTime<GenericValue extends TheTime>(input: GenericValue, threshold: TheTime): boolean;

package/dist/date/operators/lessTime.d.ts

@@ -1,3 +1,38 @@
 import type { TheTime } from "../types";
+/**
+ * Checks whether a time is less than or equal to another.
+ * 
+ * **Supported call styles:**
+ * - Classic: `lessTime(input, threshold)` → returns a value
+ * - Curried: `lessTime(threshold)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = "time1000+";
+ * const threshold = "time1500+";
+ * 
+ * const result = D.lessTime(input, threshold);
+ * // result: true
+ * 
+ * if (D.lessTime(input, threshold)) {
+ * 	// input is less or equal
+ * }
+ * 
+ * const result2 = pipe(
+ * 	input,
+ * 	when(
+ * 		D.lessTime(threshold),
+ * 		() => "ok",
+ * 	),
+ * );
+ * // result2: "ok"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/lessTime
+ * 
+ * @namespace D
+ * 
+ */
 export declare function lessTime<GenericValue extends TheTime>(threshold: TheTime): (input: GenericValue) => boolean;
 export declare function lessTime<GenericValue extends TheTime>(input: GenericValue, threshold: TheTime): boolean;

package/dist/date/operators/subtractDays.d.ts

@@ -1,3 +1,29 @@
 import type { TheDate } from "../types";
+/**
+ * Subtracts days from a date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `subtractDays(input, day)` → returns a value
+ * - Curried: `subtractDays(day)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = D.create("2024-06-20");
+ * const result = D.subtractDays(input, 3);
+ * // result: "date1718582400000+"
+ * 
+ * pipe(
+ * 	input,
+ * 	D.subtractDays(3),
+ * ); // result: "date1718582400000+"
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/subtractDays
+ * 
+ * @namespace D
+ * 
+ */
 export declare function subtractDays<GenericInput extends TheDate, GenericDay extends number>(day: GenericDay): (input: GenericInput) => TheDate;
 export declare function subtractDays<GenericInput extends TheDate, GenericDay extends number>(input: GenericInput, day: GenericDay): TheDate;

package/dist/date/operators/subtractHours.d.ts

@@ -1,3 +1,29 @@
 import type { TheDate } from "../types";
+/**
+ * Subtracts hours from a date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `subtractHours(input, hour)` → returns a value
+ * - Curried: `subtractHours(hour)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = D.create("2024-06-20");
+ * const result = D.subtractHours(input, 6);
+ * // result: "date1718820000000+"
+ * 
+ * pipe(
+ * 	input,
+ * 	D.subtractHours(6),
+ * ); // result: "date1718820000000+"
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/subtractHours
+ * 
+ * @namespace D
+ * 
+ */
 export declare function subtractHours<GenericInput extends TheDate, GenericHour extends number>(hour: GenericHour): (input: GenericInput) => TheDate;
 export declare function subtractHours<GenericInput extends TheDate, GenericHour extends number>(input: GenericInput, hour: GenericHour): TheDate;

package/dist/date/operators/subtractMilliseconds.d.ts

@@ -1,3 +1,29 @@
 import type { TheDate } from "../types";
+/**
+ * Subtracts milliseconds from a date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `subtractMilliseconds(input, millisecond)` → returns a value
+ * - Curried: `subtractMilliseconds(millisecond)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = D.create("2024-06-20");
+ * const result = D.subtractMilliseconds(input, 500);
+ * // result: "date1718841599500+"
+ * 
+ * pipe(
+ * 	input,
+ * 	D.subtractMilliseconds(500),
+ * ); // result: "date1718841599500+"
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/subtractMilliseconds
+ * 
+ * @namespace D
+ * 
+ */
 export declare function subtractMilliseconds<GenericInput extends TheDate, GenericMillisecond extends number>(millisecond: GenericMillisecond): (input: GenericInput) => TheDate;
 export declare function subtractMilliseconds<GenericInput extends TheDate, GenericMillisecond extends number>(input: GenericInput, millisecond: GenericMillisecond): TheDate;

package/dist/date/operators/subtractMinutes.d.ts

@@ -1,3 +1,29 @@
 import type { TheDate } from "../types";
+/**
+ * Subtracts minutes from a date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `subtractMinutes(input, minute)` → returns a value
+ * - Curried: `subtractMinutes(minute)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = D.create("2024-06-20");
+ * const result = D.subtractMinutes(input, 15);
+ * // result: "date1718840700000+"
+ * 
+ * pipe(
+ * 	input,
+ * 	D.subtractMinutes(15),
+ * ); // result: "date1718840700000+"
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/subtractMinutes
+ * 
+ * @namespace D
+ * 
+ */
 export declare function subtractMinutes<GenericInput extends TheDate, GenericMinute extends number>(minute: GenericMinute): (input: GenericInput) => TheDate;
 export declare function subtractMinutes<GenericInput extends TheDate, GenericMinute extends number>(input: GenericInput, minute: GenericMinute): TheDate;

package/dist/date/operators/subtractMonths.d.ts

@@ -1,3 +1,29 @@
 import type { TheDate } from "../types";
+/**
+ * Subtracts months from a date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `subtractMonths(input, month)` → returns a value
+ * - Curried: `subtractMonths(month)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = D.create("2024-06-30");
+ * const result = D.subtractMonths(input, 2);
+ * // result: "date1711843200000+"
+ * 
+ * pipe(
+ * 	input,
+ * 	D.subtractMonths(2),
+ * ); // result: "date1711843200000+"
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/subtractMonths
+ * 
+ * @namespace D
+ * 
+ */
 export declare function subtractMonths<GenericInput extends TheDate, GenericMonth extends number>(month: GenericMonth): (input: GenericInput) => TheDate;
 export declare function subtractMonths<GenericInput extends TheDate, GenericMonth extends number>(input: GenericInput, month: GenericMonth): TheDate;

package/dist/date/operators/subtractSeconds.d.ts

@@ -1,3 +1,29 @@
 import type { TheDate } from "../types";
+/**
+ * Subtracts seconds from a date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `subtractSeconds(input, second)` → returns a value
+ * - Curried: `subtractSeconds(second)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = D.create("2024-06-20");
+ * const result = D.subtractSeconds(input, 30);
+ * // result: "date1718841570000+"
+ * 
+ * pipe(
+ * 	input,
+ * 	D.subtractSeconds(30),
+ * ); // result: "date1718841570000+"
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/subtractSeconds
+ * 
+ * @namespace D
+ * 
+ */
 export declare function subtractSeconds<GenericInput extends TheDate, GenericSecond extends number>(second: GenericSecond): (input: GenericInput) => TheDate;
 export declare function subtractSeconds<GenericInput extends TheDate, GenericSecond extends number>(input: GenericInput, second: GenericSecond): TheDate;

package/dist/date/operators/subtractTime.d.ts

@@ -1,4 +1,35 @@
 import type { TheDate, TheTime } from "../types";
+/**
+ * Subtracts a TheTime from a TheDate or TheTime.
+ * 
+ * **Supported call styles:**
+ * - Classic: `subtractTime(input, time)` → returns a value
+ * - Curried: `subtractTime(time)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const date = D.createTheDate(0);
+ * const time = D.createTheTime(3_600_000);
+ * 
+ * const result = D.subtractTime(date, time);
+ * // result: "date3600000-"
+ * 
+ * const result2 = D.subtractTime("time5000+", "time2000+");
+ * // result2: "time3000+"
+ * 
+ * const result3 = pipe(
+ * 	date,
+ * 	D.subtractTime("time1000+"),
+ * );
+ * // result3: "date3599000-"
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/subtractTime
+ * 
+ * @namespace D
+ * 
+ */
 export declare function subtractTime<GenericInput extends TheDate>(time: TheTime): (input: GenericInput) => TheDate;
 export declare function subtractTime<GenericInput extends TheTime>(time: TheTime): (input: GenericInput) => TheTime;
 export declare function subtractTime<GenericInput extends TheDate>(input: GenericInput, time: TheTime): TheDate;

package/dist/date/operators/subtractWeeks.d.ts

@@ -1,3 +1,29 @@
 import type { TheDate } from "../types";
+/**
+ * Subtracts weeks from a date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `subtractWeeks(input, week)` → returns a value
+ * - Curried: `subtractWeeks(week)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = D.create("2024-06-30");
+ * const result = D.subtractWeeks(input, 4);
+ * // result: "date1716076800000+"
+ * 
+ * pipe(
+ * 	input,
+ * 	D.subtractWeeks(4),
+ * ); // result: "date1716076800000+"
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/subtractWeeks
+ * 
+ * @namespace D
+ * 
+ */
 export declare function subtractWeeks<GenericInput extends TheDate, GenericWeek extends number>(week: GenericWeek): (input: GenericInput) => TheDate;
 export declare function subtractWeeks<GenericInput extends TheDate, GenericWeek extends number>(input: GenericInput, week: GenericWeek): TheDate;

package/dist/date/operators/subtractYears.d.ts

@@ -1,3 +1,29 @@
 import type { TheDate } from "../types";
+/**
+ * Subtracts years from a date.
+ * 
+ * **Supported call styles:**
+ * - Classic: `subtractYears(input, year)` → returns a value
+ * - Curried: `subtractYears(year)` → returns a function waiting for the input
+ * 
+ * The input value is not mutated.
+ * 
+ * ```ts
+ * const input = D.create("2024-06-20");
+ * const result = D.subtractYears(input, 1);
+ * // result: "date1687219200000+"
+ * 
+ * pipe(
+ * 	input,
+ * 	D.subtractYears(1),
+ * ); // result: "date1687219200000+"
+ * 
+ * ```
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/subtractYears
+ * 
+ * @namespace D
+ * 
+ */
 export declare function subtractYears<GenericInput extends TheDate, GenericYear extends number>(year: GenericYear): (input: GenericInput) => TheDate;
 export declare function subtractYears<GenericInput extends TheDate, GenericYear extends number>(input: GenericInput, year: GenericYear): TheDate;