@duplojs/utils 1.1.16 → 1.2.16

package/dist/dataParser/parsers/tuple.mjs

@@ -1,10 +1,37 @@
+import '../../common/stringToBytes.mjs';
+import '../../common/stringToMillisecond.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
+import '../../either/bool/falsy.mjs';
+import '../../either/bool/truthy.mjs';
+import '../../either/bool/base.mjs';
+import '../../either/left/create.mjs';
+import '../../either/left/error.mjs';
+import '../../either/left/fail.mjs';
+import '../../either/kind.mjs';
+import '../../either/right/success.mjs';
+import '../../either/right/create.mjs';
+import '../../either/right/ok.mjs';
+import '../../either/future/success.mjs';
+import '../../either/future/error.mjs';
+import '../../either/future/base.mjs';
+import '../../either/nullable/empty.mjs';
+import '../../either/nullable/filled.mjs';
+import '../../either/nullable/base.mjs';
+import '../../either/nullish/empty.mjs';
+import '../../either/nullish/filled.mjs';
+import '../../either/nullish/base.mjs';
+import '../../either/optional/empty.mjs';
+import '../../either/optional/filled.mjs';
+import '../../either/optional/base.mjs';
+import { createOverride } from '../../common/override.mjs';
 import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { SymbolDataParserErrorIssue, setErrorPath, popErrorPath } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
 const tupleKind = createDataParserKind("tuple");
 function tuple(shape, definition) {
-    return dataParserInit(tupleKind, {
+    const self = dataParserInit(tupleKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -75,6 +102,8 @@ function tuple(shape, definition) {
             return output;
         },
     });
+    return tuple.overrideHandler.apply(self);
 }
+tuple.overrideHandler = createOverride("@duplojs/utils/data-parser/tuple");
 
 export { tuple, tupleKind };

package/dist/dataParser/parsers/union.cjs

@@ -1,12 +1,39 @@
 'use strict';
 
+require('../../common/stringToBytes.cjs');
+require('../../common/stringToMillisecond.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
+require('../../either/bool/falsy.cjs');
+require('../../either/bool/truthy.cjs');
+require('../../either/bool/base.cjs');
+require('../../either/left/create.cjs');
+require('../../either/left/error.cjs');
+require('../../either/left/fail.cjs');
+require('../../either/kind.cjs');
+require('../../either/right/success.cjs');
+require('../../either/right/create.cjs');
+require('../../either/right/ok.cjs');
+require('../../either/future/success.cjs');
+require('../../either/future/error.cjs');
+require('../../either/future/base.cjs');
+require('../../either/nullable/empty.cjs');
+require('../../either/nullable/filled.cjs');
+require('../../either/nullable/base.cjs');
+require('../../either/nullish/empty.cjs');
+require('../../either/nullish/filled.cjs');
+require('../../either/nullish/base.cjs');
+require('../../either/optional/empty.cjs');
+require('../../either/optional/filled.cjs');
+require('../../either/optional/base.cjs');
+var override = require('../../common/override.cjs');
 var base = require('../base.cjs');
 var error = require('../error.cjs');
 var kind = require('../kind.cjs');
 
 const unionKind = kind.createDataParserKind("union");
 function union(options, definition) {
-    return base.dataParserInit(unionKind, {
+    const self = base.dataParserInit(unionKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -32,7 +59,9 @@ function union(options, definition) {
             return error.SymbolDataParserErrorIssue;
         },
     });
+    return union.overrideHandler.apply(self);
 }
+union.overrideHandler = override.createOverride("@duplojs/utils/data-parser/union");
 
 exports.union = union;
 exports.unionKind = unionKind;

package/dist/dataParser/parsers/union.d.ts

@@ -24,4 +24,7 @@ export interface DataParserUnion<GenericDefinition extends DataParserDefinitionU
 export declare function union<GenericOptions extends UnionOptions, const GenericDefinition extends Partial<Omit<DataParserDefinitionUnion, "options">> = never>(options: GenericOptions, definition?: GenericDefinition): DataParserUnion<MergeDefinition<DataParserDefinitionUnion, NeverCoalescing<GenericDefinition, {}> & {
     options: GenericOptions;
 }>>;
+export declare namespace union {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserUnion<DataParserDefinitionUnion>>;
+}
 export {};

package/dist/dataParser/parsers/union.mjs

@@ -1,10 +1,37 @@
+import '../../common/stringToBytes.mjs';
+import '../../common/stringToMillisecond.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
+import '../../either/bool/falsy.mjs';
+import '../../either/bool/truthy.mjs';
+import '../../either/bool/base.mjs';
+import '../../either/left/create.mjs';
+import '../../either/left/error.mjs';
+import '../../either/left/fail.mjs';
+import '../../either/kind.mjs';
+import '../../either/right/success.mjs';
+import '../../either/right/create.mjs';
+import '../../either/right/ok.mjs';
+import '../../either/future/success.mjs';
+import '../../either/future/error.mjs';
+import '../../either/future/base.mjs';
+import '../../either/nullable/empty.mjs';
+import '../../either/nullable/filled.mjs';
+import '../../either/nullable/base.mjs';
+import '../../either/nullish/empty.mjs';
+import '../../either/nullish/filled.mjs';
+import '../../either/nullish/base.mjs';
+import '../../either/optional/empty.mjs';
+import '../../either/optional/filled.mjs';
+import '../../either/optional/base.mjs';
+import { createOverride } from '../../common/override.mjs';
 import { dataParserInit, SymbolDataParserError } from '../base.mjs';
 import { SymbolDataParserErrorIssue } from '../error.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
 const unionKind = createDataParserKind("union");
 function union(options, definition) {
-    return dataParserInit(unionKind, {
+    const self = dataParserInit(unionKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
@@ -30,6 +57,8 @@ function union(options, definition) {
             return SymbolDataParserErrorIssue;
         },
     });
+    return union.overrideHandler.apply(self);
 }
+union.overrideHandler = createOverride("@duplojs/utils/data-parser/union");
 
 export { union, unionKind };

package/dist/dataParser/parsers/unknown.cjs

@@ -1,17 +1,46 @@
 'use strict';
 
+require('../../common/stringToBytes.cjs');
+require('../../common/stringToMillisecond.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
+require('../../either/bool/falsy.cjs');
+require('../../either/bool/truthy.cjs');
+require('../../either/bool/base.cjs');
+require('../../either/left/create.cjs');
+require('../../either/left/error.cjs');
+require('../../either/left/fail.cjs');
+require('../../either/kind.cjs');
+require('../../either/right/success.cjs');
+require('../../either/right/create.cjs');
+require('../../either/right/ok.cjs');
+require('../../either/future/success.cjs');
+require('../../either/future/error.cjs');
+require('../../either/future/base.cjs');
+require('../../either/nullable/empty.cjs');
+require('../../either/nullable/filled.cjs');
+require('../../either/nullable/base.cjs');
+require('../../either/nullish/empty.cjs');
+require('../../either/nullish/filled.cjs');
+require('../../either/nullish/base.cjs');
+require('../../either/optional/empty.cjs');
+require('../../either/optional/filled.cjs');
+require('../../either/optional/base.cjs');
+var override = require('../../common/override.cjs');
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
 
 const unknownKind = kind.createDataParserKind("unknown");
 function unknown(definition) {
-    return base.dataParserInit(unknownKind, {
+    const self = base.dataParserInit(unknownKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
         },
     }, (data) => data);
+    return unknown.overrideHandler.apply(self);
 }
+unknown.overrideHandler = override.createOverride("@duplojs/utils/data-parser/unknown");
 
 exports.unknown = unknown;
 exports.unknownKind = unknownKind;

package/dist/dataParser/parsers/unknown.d.ts

@@ -20,4 +20,7 @@ export interface DataParserUnknown<GenericDefinition extends DataParserDefinitio
     ], GenericChecker>): DataParserUnknown<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function unknown<const GenericDefinition extends Partial<DataParserDefinitionUnknown> = never>(definition?: GenericDefinition): DataParserUnknown<MergeDefinition<DataParserDefinitionUnknown, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace unknown {
+    var overrideHandler: import("../../common").OverrideHandler<DataParserUnknown<DataParserDefinitionUnknown>>;
+}
 export {};

package/dist/dataParser/parsers/unknown.mjs

@@ -1,14 +1,43 @@
+import '../../common/stringToBytes.mjs';
+import '../../common/stringToMillisecond.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
+import '../../either/bool/falsy.mjs';
+import '../../either/bool/truthy.mjs';
+import '../../either/bool/base.mjs';
+import '../../either/left/create.mjs';
+import '../../either/left/error.mjs';
+import '../../either/left/fail.mjs';
+import '../../either/kind.mjs';
+import '../../either/right/success.mjs';
+import '../../either/right/create.mjs';
+import '../../either/right/ok.mjs';
+import '../../either/future/success.mjs';
+import '../../either/future/error.mjs';
+import '../../either/future/base.mjs';
+import '../../either/nullable/empty.mjs';
+import '../../either/nullable/filled.mjs';
+import '../../either/nullable/base.mjs';
+import '../../either/nullish/empty.mjs';
+import '../../either/nullish/filled.mjs';
+import '../../either/nullish/base.mjs';
+import '../../either/optional/empty.mjs';
+import '../../either/optional/filled.mjs';
+import '../../either/optional/base.mjs';
+import { createOverride } from '../../common/override.mjs';
 import { dataParserInit } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
 const unknownKind = createDataParserKind("unknown");
 function unknown(definition) {
-    return dataParserInit(unknownKind, {
+    const self = dataParserInit(unknownKind, {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
         },
     }, (data) => data);
+    return unknown.overrideHandler.apply(self);
 }
+unknown.overrideHandler = createOverride("@duplojs/utils/data-parser/unknown");
 
 export { unknown, unknownKind };

package/dist/dataParser/types/dataParsers.d.ts

@@ -6,8 +6,8 @@ import { type DataParserExtended } from "../baseExtended";
 export interface DataParserCustom {
     base: DataParser;
 }
-export type DataParsers = (DataParserCustom[GetPropsWithValueExtends<DataParserCustom, DataParser>] | AllDataParser.DataParserString | AllDataParser.DataParserObject | AllDataParser.DataParserNumber | AllDataParser.DataParserLiteral | AllDataParser.DataParserUnion | AllDataParser.DataParserArray | AllDataParser.DataParserBigInt | AllDataParser.DataParserTuple | AllDataParser.DataParserTransform | AllDataParser.DataParserBoolean | AllDataParser.DataParserNil | AllDataParser.DataParserEmpty | AllDataParser.DataParserTemplateLiteral | AllDataParser.DataParserPipe | AllDataParser.DataParserNullable | AllDataParser.DataParserOptional | AllDataParser.DataParserLazy | AllDataParser.DataParserUnknown | AllDataParser.DataParserRecord | AllDataParser.DataParserRecover);
+export type DataParsers = (DataParserCustom[GetPropsWithValueExtends<DataParserCustom, DataParser>] | AllDataParser.DataParserString | AllDataParser.DataParserObject | AllDataParser.DataParserNumber | AllDataParser.DataParserLiteral | AllDataParser.DataParserUnion | AllDataParser.DataParserArray | AllDataParser.DataParserBigInt | AllDataParser.DataParserTuple | AllDataParser.DataParserTransform | AllDataParser.DataParserBoolean | AllDataParser.DataParserDate | AllDataParser.DataParserNil | AllDataParser.DataParserEmpty | AllDataParser.DataParserTemplateLiteral | AllDataParser.DataParserPipe | AllDataParser.DataParserNullable | AllDataParser.DataParserOptional | AllDataParser.DataParserLazy | AllDataParser.DataParserUnknown | AllDataParser.DataParserRecord | AllDataParser.DataParserRecover);
 export interface DataParserExtendedCustom {
     base: DataParserExtended;
 }
-export type DataParsersExtended = (DataParserExtendedCustom[GetPropsWithValueExtends<DataParserExtendedCustom, DataParserExtended>] | AllDataParserExtended.DataParserStringExtended | AllDataParserExtended.DataParserObjectExtended | AllDataParserExtended.DataParserNumberExtended | AllDataParserExtended.DataParserLiteralExtended | AllDataParserExtended.DataParserUnionExtended | AllDataParserExtended.DataParserArrayExtended | AllDataParserExtended.DataParserBigIntExtended | AllDataParserExtended.DataParserTupleExtended | AllDataParserExtended.DataParserTransformExtended | AllDataParserExtended.DataParserBooleanExtended | AllDataParserExtended.DataParserNilExtended | AllDataParserExtended.DataParserEmptyExtended | AllDataParserExtended.DataParserTemplateLiteralExtended | AllDataParserExtended.DataParserPipeExtended | AllDataParserExtended.DataParserNullableExtended | AllDataParserExtended.DataParserOptionalExtended | AllDataParserExtended.DataParserLazyExtended | AllDataParserExtended.DataParserUnknownExtended | AllDataParserExtended.DataParserRecordExtended | AllDataParserExtended.DataParserRecoverExtended);
+export type DataParsersExtended = (DataParserExtendedCustom[GetPropsWithValueExtends<DataParserExtendedCustom, DataParserExtended>] | AllDataParserExtended.DataParserStringExtended | AllDataParserExtended.DataParserObjectExtended | AllDataParserExtended.DataParserNumberExtended | AllDataParserExtended.DataParserLiteralExtended | AllDataParserExtended.DataParserUnionExtended | AllDataParserExtended.DataParserArrayExtended | AllDataParserExtended.DataParserBigIntExtended | AllDataParserExtended.DataParserTupleExtended | AllDataParserExtended.DataParserTransformExtended | AllDataParserExtended.DataParserBooleanExtended | AllDataParserExtended.DataParserDateExtended | AllDataParserExtended.DataParserNilExtended | AllDataParserExtended.DataParserEmptyExtended | AllDataParserExtended.DataParserTemplateLiteralExtended | AllDataParserExtended.DataParserPipeExtended | AllDataParserExtended.DataParserNullableExtended | AllDataParserExtended.DataParserOptionalExtended | AllDataParserExtended.DataParserLazyExtended | AllDataParserExtended.DataParserUnknownExtended | AllDataParserExtended.DataParserRecordExtended | AllDataParserExtended.DataParserRecoverExtended);

package/dist/date/closestTo.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var toTimestamp = require('./toTimestamp.cjs');
+
+function closestTo(...args) {
+    if (typeof args[0] === "string") {
+        const [target, params] = args;
+        return (input) => closestTo(input, target, params);
+    }
+    const [input, target, params] = args;
+    const { tieBreaker } = params ?? {};
+    const targetTimestamp = toTimestamp.toTimestamp(target);
+    let closest = undefined;
+    let smallestDiff = Number.POSITIVE_INFINITY;
+    for (const value of input) {
+        const valueTimestamp = toTimestamp.toTimestamp(value);
+        if (tieBreaker === "favorPast" && valueTimestamp > targetTimestamp) {
+            continue;
+        }
+        if (tieBreaker === "favorFuture" && valueTimestamp < targetTimestamp) {
+            continue;
+        }
+        const distance = Math.abs(valueTimestamp - targetTimestamp);
+        if (distance < smallestDiff) {
+            smallestDiff = distance;
+            closest = value;
+        }
+    }
+    return closest;
+}
+
+exports.closestTo = closestTo;

package/dist/date/closestTo.d.ts

@@ -0,0 +1,7 @@
+import type { TheDate } from "./types";
+interface ClosestToParams {
+    tieBreaker?: "favorPast" | "favorFuture";
+}
+export declare function closestTo<GenericIterable extends Iterable<TheDate>>(target: TheDate, params?: ClosestToParams): (input: GenericIterable) => TheDate | undefined;
+export declare function closestTo<GenericIterable extends Iterable<TheDate>>(input: GenericIterable, target: TheDate, params?: ClosestToParams): TheDate | undefined;
+export {};

package/dist/date/closestTo.mjs

@@ -0,0 +1,30 @@
+import { toTimestamp } from './toTimestamp.mjs';
+
+function closestTo(...args) {
+    if (typeof args[0] === "string") {
+        const [target, params] = args;
+        return (input) => closestTo(input, target, params);
+    }
+    const [input, target, params] = args;
+    const { tieBreaker } = params ?? {};
+    const targetTimestamp = toTimestamp(target);
+    let closest = undefined;
+    let smallestDiff = Number.POSITIVE_INFINITY;
+    for (const value of input) {
+        const valueTimestamp = toTimestamp(value);
+        if (tieBreaker === "favorPast" && valueTimestamp > targetTimestamp) {
+            continue;
+        }
+        if (tieBreaker === "favorFuture" && valueTimestamp < targetTimestamp) {
+            continue;
+        }
+        const distance = Math.abs(valueTimestamp - targetTimestamp);
+        if (distance < smallestDiff) {
+            smallestDiff = distance;
+            closest = value;
+        }
+    }
+    return closest;
+}
+
+export { closestTo };

package/dist/date/constants.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+const minTimestamp = -864e13;
+const maxTimestamp = 8640000000000000;
+const millisecondInOneWeek = 604800000;
+const millisecondsInOneDay = 86400000;
+const millisecondInOneHour = 3600000;
+const millisecondInOneMinute = 60000;
+const daysInOneWeek = 7;
+const monthtsInOneYear = 12;
+const minutesInOneHour = 60;
+const secondsInOneMinute = 60;
+const millisecondsInOneSecond = 1000;
+const hoursInOneDay = 24;
+const theDateRegex = /^date(?<value>\d{1,16})(?<sign>[+-])$/;
+
+exports.daysInOneWeek = daysInOneWeek;
+exports.hoursInOneDay = hoursInOneDay;
+exports.maxTimestamp = maxTimestamp;
+exports.millisecondInOneHour = millisecondInOneHour;
+exports.millisecondInOneMinute = millisecondInOneMinute;
+exports.millisecondInOneWeek = millisecondInOneWeek;
+exports.millisecondsInOneDay = millisecondsInOneDay;
+exports.millisecondsInOneSecond = millisecondsInOneSecond;
+exports.minTimestamp = minTimestamp;
+exports.minutesInOneHour = minutesInOneHour;
+exports.monthtsInOneYear = monthtsInOneYear;
+exports.secondsInOneMinute = secondsInOneMinute;
+exports.theDateRegex = theDateRegex;

package/dist/date/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const minTimestamp = -8640000000000000;
+export declare const maxTimestamp = 8640000000000000;
+export declare const millisecondInOneWeek = 604800000;
+export declare const millisecondsInOneDay = 86400000;
+export declare const millisecondInOneHour = 3600000;
+export declare const millisecondInOneMinute = 60000;
+export declare const daysInOneWeek = 7;
+export declare const monthtsInOneYear = 12;
+export declare const minutesInOneHour = 60;
+export declare const secondsInOneMinute = 60;
+export declare const millisecondsInOneSecond = 1000;
+export declare const hoursInOneDay = 24;
+export declare const theDateRegex: RegExp;

package/dist/date/constants.mjs

@@ -0,0 +1,15 @@
+const minTimestamp = -864e13;
+const maxTimestamp = 8640000000000000;
+const millisecondInOneWeek = 604800000;
+const millisecondsInOneDay = 86400000;
+const millisecondInOneHour = 3600000;
+const millisecondInOneMinute = 60000;
+const daysInOneWeek = 7;
+const monthtsInOneYear = 12;
+const minutesInOneHour = 60;
+const secondsInOneMinute = 60;
+const millisecondsInOneSecond = 1000;
+const hoursInOneDay = 24;
+const theDateRegex = /^date(?<value>\d{1,16})(?<sign>[+-])$/;
+
+export { daysInOneWeek, hoursInOneDay, maxTimestamp, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, minTimestamp, minutesInOneHour, monthtsInOneYear, secondsInOneMinute, theDateRegex };

package/dist/date/create.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var isSafeTimestamp = require('./isSafeTimestamp.cjs');
+require('../either/bool/falsy.cjs');
+require('../either/bool/truthy.cjs');
+require('../either/bool/base.cjs');
+var create$1 = require('../either/left/create.cjs');
+require('../either/left/error.cjs');
+require('../either/left/fail.cjs');
+require('../either/kind.cjs');
+require('../common/stringToBytes.cjs');
+require('../common/stringToMillisecond.cjs');
+require('../common/globalStore.cjs');
+require('../common/builder.cjs');
+require('../common/override.cjs');
+require('../either/right/success.cjs');
+var create$2 = require('../either/right/create.cjs');
+require('../either/right/ok.cjs');
+require('../either/future/success.cjs');
+require('../either/future/error.cjs');
+require('../either/future/base.cjs');
+require('../either/nullable/empty.cjs');
+require('../either/nullable/filled.cjs');
+require('../either/nullable/base.cjs');
+require('../either/nullish/empty.cjs');
+require('../either/nullish/filled.cjs');
+require('../either/nullish/base.cjs');
+require('../either/optional/empty.cjs');
+require('../either/optional/filled.cjs');
+require('../either/optional/base.cjs');
+
+const safeDateRegex = /^(?<year>-?[0-9]+)-(?<monthWithDay>[0-1][0-9]-[0-3][0-9])$/;
+function create(input, params) {
+    if (input instanceof Date) {
+        const timestamp = input.getTime();
+        if (!isSafeTimestamp.isSafeTimestamp(timestamp)) {
+            return create$1.left("date-created-error", null);
+        }
+        const isNegative = timestamp < 0;
+        return create$2.right("date-created", `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`);
+    }
+    if (typeof input === "number") {
+        if (!isSafeTimestamp.isSafeTimestamp(input)) {
+            return create$1.left("date-created-error", null);
+        }
+        const isNegative = input < 0;
+        return create$2.right("date-created", `date${Math.abs(input)}${isNegative ? "-" : "+"}`);
+    }
+    const theDateMatch = typeof input === "string" && input.match(constants.theDateRegex);
+    if (theDateMatch) {
+        const { value, sign } = theDateMatch.groups;
+        const magnitude = Number(value);
+        const timestamp = sign === "-" ? -magnitude : magnitude;
+        if (!isSafeTimestamp.isSafeTimestamp(timestamp)) {
+            return create$1.left("date-created-error", null);
+        }
+        return create$2.right("date-created", input);
+    }
+    const safeDateMatch = typeof input === "string" && input.match(safeDateRegex);
+    if (safeDateMatch) {
+        const { year, monthWithDay } = safeDateMatch.groups;
+        const date = new Date(`0000-${monthWithDay}T${params?.hour ?? "00"}:${params?.minute ?? "00"}:${params?.second ?? "00"}.${params?.millisecond ?? "000"}Z`);
+        date.setUTCFullYear(Number(year));
+        const timestamp = date.getTime();
+        if (!isSafeTimestamp.isSafeTimestamp(timestamp)) {
+            return "date0+";
+        }
+        const isNegative = timestamp < 0;
+        return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+    }
+    return create$1.left("date-created-error", null);
+}
+
+exports.create = create;

package/dist/date/create.d.ts

@@ -0,0 +1,16 @@
+import type { Hour, IsLeapYear, Millisecond, Minute, Second, TheDate } from "./types";
+import { type EitherLeft, type EitherRight } from "../either";
+import { type MonthWithDay } from "./types/month";
+export type MayBe = EitherRight<"date-created", TheDate> | EitherLeft<"date-created-error", null>;
+declare const SymbolErrorIsNotLeapYear: unique symbol;
+interface SafeDateParams {
+    hour?: Hour;
+    minute?: Minute;
+    second?: Second;
+    millisecond?: Millisecond;
+}
+export declare function create<GenericInput extends TheDate | Date | number>(input: GenericInput): MayBe;
+export declare function create<GenericInput extends `${"-" | ""}${number}-${MonthWithDay}`>(input: GenericInput & (GenericInput extends `${"-" | ""}${infer InferredYear extends `${number}`}-02-29` ? IsLeapYear<InferredYear> extends true ? GenericInput : {
+    [SymbolErrorIsNotLeapYear]: "Is not a leap year.";
+} : GenericInput), params?: SafeDateParams): TheDate;
+export {};

package/dist/date/create.mjs

@@ -0,0 +1,73 @@
+import { theDateRegex } from './constants.mjs';
+import { isSafeTimestamp } from './isSafeTimestamp.mjs';
+import '../either/bool/falsy.mjs';
+import '../either/bool/truthy.mjs';
+import '../either/bool/base.mjs';
+import { left } from '../either/left/create.mjs';
+import '../either/left/error.mjs';
+import '../either/left/fail.mjs';
+import '../either/kind.mjs';
+import '../common/stringToBytes.mjs';
+import '../common/stringToMillisecond.mjs';
+import '../common/globalStore.mjs';
+import '../common/builder.mjs';
+import '../common/override.mjs';
+import '../either/right/success.mjs';
+import { right } from '../either/right/create.mjs';
+import '../either/right/ok.mjs';
+import '../either/future/success.mjs';
+import '../either/future/error.mjs';
+import '../either/future/base.mjs';
+import '../either/nullable/empty.mjs';
+import '../either/nullable/filled.mjs';
+import '../either/nullable/base.mjs';
+import '../either/nullish/empty.mjs';
+import '../either/nullish/filled.mjs';
+import '../either/nullish/base.mjs';
+import '../either/optional/empty.mjs';
+import '../either/optional/filled.mjs';
+import '../either/optional/base.mjs';
+
+const safeDateRegex = /^(?<year>-?[0-9]+)-(?<monthWithDay>[0-1][0-9]-[0-3][0-9])$/;
+function create(input, params) {
+    if (input instanceof Date) {
+        const timestamp = input.getTime();
+        if (!isSafeTimestamp(timestamp)) {
+            return left("date-created-error", null);
+        }
+        const isNegative = timestamp < 0;
+        return right("date-created", `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`);
+    }
+    if (typeof input === "number") {
+        if (!isSafeTimestamp(input)) {
+            return left("date-created-error", null);
+        }
+        const isNegative = input < 0;
+        return right("date-created", `date${Math.abs(input)}${isNegative ? "-" : "+"}`);
+    }
+    const theDateMatch = typeof input === "string" && input.match(theDateRegex);
+    if (theDateMatch) {
+        const { value, sign } = theDateMatch.groups;
+        const magnitude = Number(value);
+        const timestamp = sign === "-" ? -magnitude : magnitude;
+        if (!isSafeTimestamp(timestamp)) {
+            return left("date-created-error", null);
+        }
+        return right("date-created", input);
+    }
+    const safeDateMatch = typeof input === "string" && input.match(safeDateRegex);
+    if (safeDateMatch) {
+        const { year, monthWithDay } = safeDateMatch.groups;
+        const date = new Date(`0000-${monthWithDay}T${params?.hour ?? "00"}:${params?.minute ?? "00"}:${params?.second ?? "00"}.${params?.millisecond ?? "000"}Z`);
+        date.setUTCFullYear(Number(year));
+        const timestamp = date.getTime();
+        if (!isSafeTimestamp(timestamp)) {
+            return "date0+";
+        }
+        const isNegative = timestamp < 0;
+        return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+    }
+    return left("date-created-error", null);
+}
+
+export { create };

package/dist/date/createOrThrow.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+require('../common/stringToBytes.cjs');
+require('../common/stringToMillisecond.cjs');
+var unwrap = require('../common/unwrap.cjs');
+require('../common/globalStore.cjs');
+require('../common/builder.cjs');
+require('../either/bool/falsy.cjs');
+require('../either/bool/truthy.cjs');
+require('../either/bool/base.cjs');
+require('../either/left/create.cjs');
+require('../either/left/error.cjs');
+require('../either/left/fail.cjs');
+var is = require('../either/left/is.cjs');
+require('../either/right/success.cjs');
+require('../either/kind.cjs');
+require('../either/right/create.cjs');
+require('../either/right/ok.cjs');
+require('../either/future/success.cjs');
+require('../either/future/error.cjs');
+require('../either/future/base.cjs');
+require('../either/nullable/empty.cjs');
+require('../either/nullable/filled.cjs');
+require('../either/nullable/base.cjs');
+require('../either/nullish/empty.cjs');
+require('../either/nullish/filled.cjs');
+require('../either/nullish/base.cjs');
+require('../either/optional/empty.cjs');
+require('../either/optional/filled.cjs');
+require('../either/optional/base.cjs');
+require('../common/override.cjs');
+var errorKindNamespace = require('../common/errorKindNamespace.cjs');
+var create = require('./create.cjs');
+
+class CreateTheDateError extends kind.kindHeritage("create-the-date-error", errorKindNamespace.createErrorKind("create-the-date-error"), Error) {
+    input;
+    constructor(input) {
+        super({}, [`Invalid input: ${input.toString()}`]);
+        this.input = input;
+    }
+}
+function createOrThrow(input) {
+    const result = create.create(input);
+    if (is.isLeft(result)) {
+        throw new CreateTheDateError(input);
+    }
+    return unwrap.unwrap(result);
+}
+
+exports.CreateTheDateError = CreateTheDateError;
+exports.createOrThrow = createOrThrow;

package/dist/date/createOrThrow.d.ts

@@ -0,0 +1,10 @@
+import type { TheDate } from "./types";
+declare const CreateTheDateError_base: new (params: {
+    "@DuplojsUtilsError/create-the-date-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../common").Kind<import("../common").KindDefinition<"create-the-date-error", unknown>, unknown> & import("../common").Kind<import("../common").KindDefinition<"@DuplojsUtilsError/create-the-date-error", unknown>, unknown>;
+export declare class CreateTheDateError extends CreateTheDateError_base {
+    input: TheDate | Date | number;
+    constructor(input: TheDate | Date | number);
+}
+export declare function createOrThrow<GenericInput extends TheDate | Date | number>(input: GenericInput): `date${number}-` | `date${number}+`;
+export {};