@duplojs/utils 1.3.29 → 1.3.31

package/dist/dataParser/parsers/time/checkers/min.mjs

@@ -0,0 +1,16 @@
+import { dataParserCheckerInit } from '../../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../../error.mjs';
+import { createDataParserKind } from '../../../kind.mjs';
+import { greaterTime } from '../../../../date/operators/greaterTime.mjs';
+
+const checkerTimeMinKind = createDataParserKind("checker-time-min");
+function checkerTimeMin(min, definition = {}) {
+    return dataParserCheckerInit(checkerTimeMinKind, {
+        definition: {
+            ...definition,
+            min,
+        },
+    }, (value, self) => greaterTime(value, self.definition.min) ? value : SymbolDataParserErrorIssue);
+}
+
+export { checkerTimeMin, checkerTimeMinKind };

package/dist/dataParser/parsers/time/index.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+var base = require('../../base.cjs');
+var error = require('../../error.cjs');
+var kind = require('../../kind.cjs');
+var isSafeTimeValue = require('../../../date/isSafeTimeValue.cjs');
+var createTheTime = require('../../../date/createTheTime.cjs');
+var constants = require('../../../date/constants.cjs');
+var createTime = require('../../../date/createTime.cjs');
+var is = require('../../../either/left/is.cjs');
+var unwrap = require('../../../common/unwrap.cjs');
+var isTime = require('../../../date/isTime.cjs');
+var override = require('../../../common/override.cjs');
+
+const timeKind = kind.createDataParserKind("time");
+function time(definition) {
+    const self = base.dataParserInit(timeKind, {
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        coerce: definition?.coerce ?? false,
+    }, (data, _error, self) => {
+        if (self.definition.coerce) {
+            if (typeof data === "number") {
+                if (!isSafeTimeValue.isSafeTimeValue(data)) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+                return createTheTime.createTheTime(data);
+            }
+            if (typeof data === "string" && constants.isoTimeRegex.test(data)) {
+                const result = createTime.createTime({ value: data });
+                if (is.isLeft(result)) {
+                    return error.SymbolDataParserErrorIssue;
+                }
+                return unwrap.unwrap(result);
+            }
+        }
+        if (typeof data === "string" && isTime.isTime(data)) {
+            return data;
+        }
+        return error.SymbolDataParserErrorIssue;
+    });
+    return time.overrideHandler.apply(self);
+}
+time.overrideHandler = override.createOverride("@duplojs/utils/data-parser/time");
+
+exports.time = time;
+exports.timeKind = timeKind;

package/dist/dataParser/parsers/time/index.d.ts

@@ -0,0 +1,33 @@
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../../common";
+import { type DataParserDefinition, type DataParser, type DataParserChecker } from "../../base";
+import { type AddCheckersToDefinition, type MergeDefinition } from "../../../dataParser/types";
+import { type CheckerRefineImplementation } from "../refine";
+import { type GetPropsWithValueExtends } from "../../../object";
+import { type TheTime } from "../../../date";
+import { type DataParserCheckerTimeMax, type DataParserCheckerTimeMin } from "./checkers";
+export * from "./checkers";
+export interface DataParserTimeCheckerCustom {
+}
+export type DataParserTimeCheckers = (DataParserTimeCheckerCustom[GetPropsWithValueExtends<DataParserTimeCheckerCustom, DataParserChecker>] | CheckerRefineImplementation<TheTime> | DataParserCheckerTimeMax | DataParserCheckerTimeMin);
+export interface DataParserDefinitionTime extends DataParserDefinition<DataParserTimeCheckers> {
+    readonly coerce: boolean;
+}
+export declare const timeKind: import("../../../common").KindHandler<import("../../../common").KindDefinition<"@DuplojsUtilsDataParser/time", unknown>>;
+type _DataParserTime<GenericDefinition extends DataParserDefinitionTime> = (DataParser<GenericDefinition, TheTime, TheTime> & Kind<typeof timeKind.definition>);
+export interface DataParserTime<GenericDefinition extends DataParserDefinitionTime = DataParserDefinitionTime> extends _DataParserTime<GenericDefinition> {
+    addChecker<GenericChecker extends readonly [
+        DataParserTimeCheckers,
+        ...DataParserTimeCheckers[]
+    ]>(...args: FixDeepFunctionInfer<readonly [
+        DataParserTimeCheckers,
+        ...DataParserTimeCheckers[]
+    ], GenericChecker>): DataParserTime<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
+    /**
+     * @deprecated Method with unreliable typing.
+     */
+    construct<const GenericDefinition extends DataParserDefinitionTime>(definition: GenericDefinition): DataParserTime<MergeDefinition<DataParserDefinitionTime, GenericDefinition>>;
+}
+export declare function time<const GenericDefinition extends Partial<DataParserDefinitionTime> = never>(definition?: GenericDefinition): DataParserTime<MergeDefinition<DataParserDefinitionTime, NeverCoalescing<GenericDefinition, {}>>>;
+export declare namespace time {
+    var overrideHandler: import("../../../common").OverrideHandler<DataParserTime<DataParserDefinitionTime>>;
+}

package/dist/dataParser/parsers/time/index.mjs

@@ -0,0 +1,44 @@
+import { dataParserInit } from '../../base.mjs';
+import { SymbolDataParserErrorIssue } from '../../error.mjs';
+import { createDataParserKind } from '../../kind.mjs';
+import { isSafeTimeValue } from '../../../date/isSafeTimeValue.mjs';
+import { createTheTime } from '../../../date/createTheTime.mjs';
+import { isoTimeRegex } from '../../../date/constants.mjs';
+import { createTime } from '../../../date/createTime.mjs';
+import { isLeft } from '../../../either/left/is.mjs';
+import { unwrap } from '../../../common/unwrap.mjs';
+import { isTime } from '../../../date/isTime.mjs';
+import { createOverride } from '../../../common/override.mjs';
+
+const timeKind = createDataParserKind("time");
+function time(definition) {
+    const self = dataParserInit(timeKind, {
+        errorMessage: definition?.errorMessage,
+        checkers: definition?.checkers ?? [],
+        coerce: definition?.coerce ?? false,
+    }, (data, _error, self) => {
+        if (self.definition.coerce) {
+            if (typeof data === "number") {
+                if (!isSafeTimeValue(data)) {
+                    return SymbolDataParserErrorIssue;
+                }
+                return createTheTime(data);
+            }
+            if (typeof data === "string" && isoTimeRegex.test(data)) {
+                const result = createTime({ value: data });
+                if (isLeft(result)) {
+                    return SymbolDataParserErrorIssue;
+                }
+                return unwrap(result);
+            }
+        }
+        if (typeof data === "string" && isTime(data)) {
+            return data;
+        }
+        return SymbolDataParserErrorIssue;
+    });
+    return time.overrideHandler.apply(self);
+}
+time.overrideHandler = createOverride("@duplojs/utils/data-parser/time");
+
+export { time, timeKind };

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

@@ -4,4 +4,4 @@ import type * as AllDataParser from "../parsers";
 export interface CheckerCustom {
     base: DataParserChecker;
 }
-export type DataParserCheckers = (CheckerCustom[GetPropsWithValueExtends<CheckerCustom, DataParserChecker>] | AllDataParser.DataParserCheckerUrl | AllDataParser.DataParserCheckerArrayMax | AllDataParser.DataParserCheckerArrayMin | AllDataParser.DataParserCheckerBigIntMax | AllDataParser.DataParserCheckerBigIntMin | AllDataParser.DataParserCheckerNumberMax | AllDataParser.DataParserCheckerNumberMin | AllDataParser.DataParserCheckerInt | AllDataParser.DataParserCheckerEmail | AllDataParser.DataParserCheckerRefine);
+export type DataParserCheckers = (CheckerCustom[GetPropsWithValueExtends<CheckerCustom, DataParserChecker>] | AllDataParser.DataParserCheckerUrl | AllDataParser.DataParserCheckerArrayMax | AllDataParser.DataParserCheckerArrayMin | AllDataParser.DataParserCheckerBigIntMax | AllDataParser.DataParserCheckerBigIntMin | AllDataParser.DataParserCheckerNumberMax | AllDataParser.DataParserCheckerNumberMin | AllDataParser.DataParserCheckerInt | AllDataParser.DataParserCheckerEmail | AllDataParser.DataParserCheckerRefine | AllDataParser.DataParserCheckerTimeMin | AllDataParser.DataParserCheckerTimeMax);

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.DataParserDate | 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.DataParserTime | 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.DataParserDateExtended | 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.DataParserTimeExtended | AllDataParserExtended.DataParserNilExtended | AllDataParserExtended.DataParserEmptyExtended | AllDataParserExtended.DataParserTemplateLiteralExtended | AllDataParserExtended.DataParserPipeExtended | AllDataParserExtended.DataParserNullableExtended | AllDataParserExtended.DataParserOptionalExtended | AllDataParserExtended.DataParserLazyExtended | AllDataParserExtended.DataParserUnknownExtended | AllDataParserExtended.DataParserRecordExtended | AllDataParserExtended.DataParserRecoverExtended);

package/dist/date/applyTimezone.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var createOrThrow = require('./createOrThrow.cjs');
+var getTimezoneOffset = require('./getTimezoneOffset.cjs');
+var toTimestamp = require('./toTimestamp.cjs');
+
+function applyTimezone(...args) {
+    if (args.length === 1) {
+        const [timeZone] = args;
+        return (theDate) => applyTimezone(theDate, timeZone);
+    }
+    const [theDate, timeZone] = args;
+    const timestamp = toTimestamp.toTimestamp(theDate);
+    return createOrThrow.createOrThrow(timestamp - getTimezoneOffset.getTimezoneOffset(theDate, timeZone));
+}
+
+exports.applyTimezone = applyTimezone;

package/dist/date/applyTimezone.d.ts

@@ -0,0 +1,4 @@
+import { type Timezone } from "./timezone";
+import { type TheDate } from "./types";
+export declare function applyTimezone(timeZone: Timezone): (theDate: TheDate) => TheDate;
+export declare function applyTimezone(theDate: TheDate, timeZone: Timezone): TheDate;

package/dist/date/applyTimezone.mjs

@@ -0,0 +1,15 @@
+import { createOrThrow } from './createOrThrow.mjs';
+import { getTimezoneOffset } from './getTimezoneOffset.mjs';
+import { toTimestamp } from './toTimestamp.mjs';
+
+function applyTimezone(...args) {
+    if (args.length === 1) {
+        const [timeZone] = args;
+        return (theDate) => applyTimezone(theDate, timeZone);
+    }
+    const [theDate, timeZone] = args;
+    const timestamp = toTimestamp(theDate);
+    return createOrThrow(timestamp - getTimezoneOffset(theDate, timeZone));
+}
+
+export { applyTimezone };

package/dist/date/constants.cjs

@@ -1,29 +1,39 @@
 'use strict';
 
 const minTimestamp = -864e13;
-const maxTimestamp = 8640000000000000;
+const maxTimestamp = 8_640_000_000_000_000;
+const minTimeValue = -9007199254740991;
+const maxTimeValue = 9_007_199_254_740_991;
 const millisecondInOneWeek = 604800000;
 const millisecondsInOneDay = 86400000;
 const millisecondInOneHour = 3600000;
 const millisecondInOneMinute = 60000;
+const millisecondsInOneSecond = 1000;
 const daysInOneWeek = 7;
 const monthsInOneYear = 12;
 const minutesInOneHour = 60;
 const secondsInOneMinute = 60;
-const millisecondsInOneSecond = 1000;
 const hoursInOneDay = 24;
-const theDateRegex = /^date(?<value>\d{1,16})(?<sign>[+-])$/;
+const theDateRegex = /^date-?(?<value>\d{1,16})(?<sign>[+-])$/;
+const isoDateRegex = /^(?<year>-?[0-9]{4})-(?<month>[0-9]{2})-(?<date>[0-9]{2})(?:T(?<hour>[0-9]{2}):(?<minute>[0-9]{2}):(?<second>[0-9]{2})(?:\.(?<millisecond>[0-9]{3}))?Z?)?$/;
+const theTimeRegex = /^time-?(?<value>\d{1,16})(?<sign>[+-])$/;
+const isoTimeRegex = /^(?<sign>[+-])?(?<hour>[0-9]{2}):(?<minute>[0-9]{2})(?::(?<second>[0-9]{2})(?:\.(?<millisecond>[0-9]{3}))?Z?)?$/;
 
 exports.daysInOneWeek = daysInOneWeek;
 exports.hoursInOneDay = hoursInOneDay;
+exports.isoDateRegex = isoDateRegex;
+exports.isoTimeRegex = isoTimeRegex;
+exports.maxTimeValue = maxTimeValue;
 exports.maxTimestamp = maxTimestamp;
 exports.millisecondInOneHour = millisecondInOneHour;
 exports.millisecondInOneMinute = millisecondInOneMinute;
 exports.millisecondInOneWeek = millisecondInOneWeek;
 exports.millisecondsInOneDay = millisecondsInOneDay;
 exports.millisecondsInOneSecond = millisecondsInOneSecond;
+exports.minTimeValue = minTimeValue;
 exports.minTimestamp = minTimestamp;
 exports.minutesInOneHour = minutesInOneHour;
 exports.monthsInOneYear = monthsInOneYear;
 exports.secondsInOneMinute = secondsInOneMinute;
 exports.theDateRegex = theDateRegex;
+exports.theTimeRegex = theTimeRegex;

package/dist/date/constants.d.ts

@@ -1,13 +1,18 @@
 export declare const minTimestamp = -8640000000000000;
 export declare const maxTimestamp = 8640000000000000;
+export declare const minTimeValue = -9007199254740991;
+export declare const maxTimeValue = 9007199254740991;
 export declare const millisecondInOneWeek = 604800000;
 export declare const millisecondsInOneDay = 86400000;
 export declare const millisecondInOneHour = 3600000;
 export declare const millisecondInOneMinute = 60000;
+export declare const millisecondsInOneSecond = 1000;
 export declare const daysInOneWeek = 7;
 export declare const monthsInOneYear = 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;
+export declare const isoDateRegex: RegExp;
+export declare const theTimeRegex: RegExp;
+export declare const isoTimeRegex: RegExp;

package/dist/date/constants.mjs

@@ -1,15 +1,20 @@
 const minTimestamp = -864e13;
-const maxTimestamp = 8640000000000000;
+const maxTimestamp = 8_640_000_000_000_000;
+const minTimeValue = -9007199254740991;
+const maxTimeValue = 9_007_199_254_740_991;
 const millisecondInOneWeek = 604800000;
 const millisecondsInOneDay = 86400000;
 const millisecondInOneHour = 3600000;
 const millisecondInOneMinute = 60000;
+const millisecondsInOneSecond = 1000;
 const daysInOneWeek = 7;
 const monthsInOneYear = 12;
 const minutesInOneHour = 60;
 const secondsInOneMinute = 60;
-const millisecondsInOneSecond = 1000;
 const hoursInOneDay = 24;
-const theDateRegex = /^date(?<value>\d{1,16})(?<sign>[+-])$/;
+const theDateRegex = /^date-?(?<value>\d{1,16})(?<sign>[+-])$/;
+const isoDateRegex = /^(?<year>-?[0-9]{4})-(?<month>[0-9]{2})-(?<date>[0-9]{2})(?:T(?<hour>[0-9]{2}):(?<minute>[0-9]{2}):(?<second>[0-9]{2})(?:\.(?<millisecond>[0-9]{3}))?Z?)?$/;
+const theTimeRegex = /^time-?(?<value>\d{1,16})(?<sign>[+-])$/;
+const isoTimeRegex = /^(?<sign>[+-])?(?<hour>[0-9]{2}):(?<minute>[0-9]{2})(?::(?<second>[0-9]{2})(?:\.(?<millisecond>[0-9]{3}))?Z?)?$/;
 
-export { daysInOneWeek, hoursInOneDay, maxTimestamp, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, minTimestamp, minutesInOneHour, monthsInOneYear, secondsInOneMinute, theDateRegex };
+export { daysInOneWeek, hoursInOneDay, isoDateRegex, isoTimeRegex, maxTimeValue, maxTimestamp, millisecondInOneHour, millisecondInOneMinute, millisecondInOneWeek, millisecondsInOneDay, millisecondsInOneSecond, minTimeValue, minTimestamp, minutesInOneHour, monthsInOneYear, secondsInOneMinute, theDateRegex, theTimeRegex };

package/dist/date/create.cjs

@@ -2,35 +2,27 @@
 
 var constants = require('./constants.cjs');
 var isSafeTimestamp = require('./isSafeTimestamp.cjs');
-var create$1 = require('../either/left/create.cjs');
-var create$2 = require('../either/right/create.cjs');
+var applyTimezone = require('./applyTimezone.cjs');
+var is = require('./is.cjs');
+var toNative = require('./toNative.cjs');
+var createTheDate = require('./createTheDate.cjs');
+var create$1 = require('../either/right/create.cjs');
+var is$1 = require('../either/left/is.cjs');
+var create$2 = require('../either/left/create.cjs');
+var unwrap = require('../common/unwrap.cjs');
+var when = require('../either/left/when.cjs');
+var safeCallback = require('../either/safeCallback.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 ? "-" : "+"}`);
+        return createFromTimestamp(input);
     }
-    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);
+    if (input instanceof Date) {
+        return createFromTimestamp(input.getTime());
+    }
+    if (typeof input === "string" && is.is(input)) {
+        return create$1.right("date-created", input);
     }
     const safeDateMatch = typeof input === "string" && input.match(safeDateRegex);
     if (safeDateMatch) {
@@ -38,13 +30,54 @@ function create(input, params) {
         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+";
+        return `date${Math.abs(timestamp)}${timestamp < 0 ? "-" : "+"}`;
+    }
+    if (typeof input === "object") {
+        let inputValueResult = undefined;
+        if (input.value instanceof Date) {
+            inputValueResult = createFromTimestamp(input.value.getTime());
         }
-        const isNegative = timestamp < 0;
-        return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+        else if (typeof input.value === "number") {
+            inputValueResult = createFromTimestamp(input.value);
+        }
+        else if (is.is(input.value)) {
+            inputValueResult = create$1.right("date-created", input.value);
+        }
+        else {
+            const isoDateMatch = input.value.match(constants.isoDateRegex);
+            if (isoDateMatch) {
+                const { year, month, date, hour, minute, second, millisecond } = isoDateMatch.groups;
+                inputValueResult = createFromTimestamp(Date.UTC(Number(year), Number(month) - 1, Number(date), Number(hour), Number(minute), Number(second), Number(millisecond)));
+            }
+        }
+        if (!inputValueResult || is$1.isLeft(inputValueResult)) {
+            return inputValueResult || create$2.left("date-created-error", null);
+        }
+        const date = toNative.toNative(unwrap.unwrap(inputValueResult));
+        void (input.year && date.setUTCFullYear(input.year));
+        void (input.month && date.setMonth(input.month));
+        void (input.day && date.setDate(input.day));
+        void (input.hour && date.setHours(input.hour));
+        void (input.minute && date.setMinutes(input.minute));
+        void (input.second && date.setSeconds(input.second));
+        void (input.millisecond && date.setMilliseconds(input.millisecond));
+        const result = createFromTimestamp(date.getTime());
+        if (is$1.isLeft(result)) {
+            return result;
+        }
+        const timezone = input.timezone;
+        if (!timezone) {
+            return result;
+        }
+        return when.whenIsLeft(safeCallback.safeCallback(() => create$1.right("date-created", applyTimezone.applyTimezone(unwrap.unwrap(result), timezone))), () => create$2.left("date-created-error", null));
+    }
+    return create$2.left("date-created-error", null);
+}
+function createFromTimestamp(input) {
+    if (!isSafeTimestamp.isSafeTimestamp(input)) {
+        return create$2.left("date-created-error", null);
     }
-    return create$1.left("date-created-error", null);
+    return create$1.right("date-created", createTheDate.createTheDate(input));
 }
 
 exports.create = create;

package/dist/date/create.d.ts

@@ -1,17 +1,20 @@
-import type { Hour, IsLeapYear, IsSafeYear, Millisecond, Minute, Second, TheDate } from "./types";
-import { type EitherLeft, type EitherRight } from "../either";
-import { type MonthWithDay } from "./types/month";
+import type { Hour, IsLeapYear, IsSafeYear, Millisecond, Minute, Second, TheDate, MonthWithDay, SpoolingDate } from "./types";
+import * as DEither from "../either";
 import type * as DString from "../string";
-export type MayBe = EitherRight<"date-created", TheDate> | EitherLeft<"date-created-error", null>;
+import { type And, type IsEqual, type Not, type IsExtends } from "../common";
+export type MayBe = DEither.EitherRight<"date-created", TheDate> | DEither.EitherLeft<"date-created-error", null>;
 type SafeDate = `${number}-${MonthWithDay}`;
 declare const SymbolForbiddenDate: unique symbol;
-type ForbiddenDate<GenericDate extends SafeDate> = ((DString.Includes<GenericDate, "."> extends true ? {
+type ForbiddenDate<GenericDate extends string> = And<[
+    IsExtends<GenericDate, SafeDate>,
+    Not<IsEqual<GenericDate, SafeDate>>
+]> extends true ? ((DString.Includes<GenericDate, "."> extends true ? {
     [SymbolForbiddenDate]: "Year can't be includes a float number.";
 } : GenericDate) & (GenericDate extends `${infer InferredYear extends number}-02-29` ? IsLeapYear<InferredYear> extends true ? GenericDate : {
     [SymbolForbiddenDate]: "Is not a leap year.";
 } : GenericDate) & (GenericDate extends `${infer InferredYear extends number}-${MonthWithDay}` ? IsSafeYear<InferredYear> extends true ? GenericDate : {
     [SymbolForbiddenDate]: "Support that the years between -271820 and 275759.";
-} : GenericDate));
+} : GenericDate)) : GenericDate;
 interface SafeDateParams {
     hour?: Hour;
     minute?: Minute;
@@ -19,5 +22,6 @@ interface SafeDateParams {
     millisecond?: Millisecond;
 }
 export declare function create<GenericInput extends TheDate | Date | number>(input: GenericInput): MayBe;
+export declare function create<GenericInput extends SpoolingDate>(input: GenericInput): MayBe;
 export declare function create<GenericInput extends SafeDate>(input: GenericInput & ForbiddenDate<GenericInput>, params?: SafeDateParams): TheDate;
 export {};

package/dist/date/create.mjs

@@ -1,33 +1,25 @@
-import { theDateRegex } from './constants.mjs';
+import { isoDateRegex } from './constants.mjs';
 import { isSafeTimestamp } from './isSafeTimestamp.mjs';
-import { left } from '../either/left/create.mjs';
+import { applyTimezone } from './applyTimezone.mjs';
+import { is } from './is.mjs';
+import { toNative } from './toNative.mjs';
+import { createTheDate } from './createTheDate.mjs';
 import { right } from '../either/right/create.mjs';
+import { isLeft } from '../either/left/is.mjs';
+import { left } from '../either/left/create.mjs';
+import { unwrap } from '../common/unwrap.mjs';
+import { whenIsLeft } from '../either/left/when.mjs';
+import { safeCallback } from '../either/safeCallback.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 ? "-" : "+"}`);
+        return createFromTimestamp(input);
     }
-    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);
-        }
+    if (input instanceof Date) {
+        return createFromTimestamp(input.getTime());
+    }
+    if (typeof input === "string" && is(input)) {
         return right("date-created", input);
     }
     const safeDateMatch = typeof input === "string" && input.match(safeDateRegex);
@@ -36,13 +28,54 @@ function create(input, params) {
         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+";
+        return `date${Math.abs(timestamp)}${timestamp < 0 ? "-" : "+"}`;
+    }
+    if (typeof input === "object") {
+        let inputValueResult = undefined;
+        if (input.value instanceof Date) {
+            inputValueResult = createFromTimestamp(input.value.getTime());
+        }
+        else if (typeof input.value === "number") {
+            inputValueResult = createFromTimestamp(input.value);
+        }
+        else if (is(input.value)) {
+            inputValueResult = right("date-created", input.value);
+        }
+        else {
+            const isoDateMatch = input.value.match(isoDateRegex);
+            if (isoDateMatch) {
+                const { year, month, date, hour, minute, second, millisecond } = isoDateMatch.groups;
+                inputValueResult = createFromTimestamp(Date.UTC(Number(year), Number(month) - 1, Number(date), Number(hour), Number(minute), Number(second), Number(millisecond)));
+            }
+        }
+        if (!inputValueResult || isLeft(inputValueResult)) {
+            return inputValueResult || left("date-created-error", null);
         }
-        const isNegative = timestamp < 0;
-        return `date${Math.abs(timestamp)}${isNegative ? "-" : "+"}`;
+        const date = toNative(unwrap(inputValueResult));
+        void (input.year && date.setUTCFullYear(input.year));
+        void (input.month && date.setMonth(input.month));
+        void (input.day && date.setDate(input.day));
+        void (input.hour && date.setHours(input.hour));
+        void (input.minute && date.setMinutes(input.minute));
+        void (input.second && date.setSeconds(input.second));
+        void (input.millisecond && date.setMilliseconds(input.millisecond));
+        const result = createFromTimestamp(date.getTime());
+        if (isLeft(result)) {
+            return result;
+        }
+        const timezone = input.timezone;
+        if (!timezone) {
+            return result;
+        }
+        return whenIsLeft(safeCallback(() => right("date-created", applyTimezone(unwrap(result), timezone))), () => left("date-created-error", null));
     }
     return left("date-created-error", null);
 }
+function createFromTimestamp(input) {
+    if (!isSafeTimestamp(input)) {
+        return left("date-created-error", null);
+    }
+    return right("date-created", createTheDate(input));
+}
 
 export { create };

package/dist/date/createOrThrow.cjs

@@ -9,7 +9,10 @@ var errorKindNamespace = require('../common/errorKindNamespace.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()}`]);
+        const value = typeof input === "object" && "value" in input
+            ? JSON.stringify(input)
+            : input.toString();
+        super({}, [`Invalid date input: ${value}`]);
         this.input = input;
     }
 }

package/dist/date/createOrThrow.d.ts

@@ -1,10 +1,11 @@
-import type { TheDate } from "./types";
+import type { TheDate, SpoolingDate } 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);
+    input: string | Date | number | SpoolingDate;
+    constructor(input: string | Date | number | SpoolingDate);
 }
-export declare function createOrThrow<GenericInput extends TheDate | Date | number>(input: GenericInput): `date${number}-` | `date${number}+`;
+export declare function createOrThrow<GenericInput extends TheDate | Date | number>(input: GenericInput): TheDate;
+export declare function createOrThrow<GenericInput extends SpoolingDate>(input: GenericInput): TheDate;
 export {};

package/dist/date/createOrThrow.mjs

@@ -7,7 +7,10 @@ import { createErrorKind } from '../common/errorKindNamespace.mjs';
 class CreateTheDateError extends kindHeritage("create-the-date-error", createErrorKind("create-the-date-error"), Error) {
     input;
     constructor(input) {
-        super({}, [`Invalid input: ${input.toString()}`]);
+        const value = typeof input === "object" && "value" in input
+            ? JSON.stringify(input)
+            : input.toString();
+        super({}, [`Invalid date input: ${value}`]);
         this.input = input;
     }
 }

package/dist/date/createTheDate.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var makeSafeTimestamp = require('./makeSafeTimestamp.cjs');
+
+function createTheDate(timestamp) {
+    const safeTimestamp = makeSafeTimestamp.makeSafeTimestamp(timestamp);
+    return `date${Math.abs(safeTimestamp)}${safeTimestamp < 0 ? "-" : "+"}`;
+}
+
+exports.createTheDate = createTheDate;

package/dist/date/createTheDate.d.ts

@@ -0,0 +1,2 @@
+import { type TheDate } from "./types";
+export declare function createTheDate(timestamp: number): TheDate;

package/dist/date/createTheDate.mjs

@@ -0,0 +1,8 @@
+import { makeSafeTimestamp } from './makeSafeTimestamp.mjs';
+
+function createTheDate(timestamp) {
+    const safeTimestamp = makeSafeTimestamp(timestamp);
+    return `date${Math.abs(safeTimestamp)}${safeTimestamp < 0 ? "-" : "+"}`;
+}
+
+export { createTheDate };

package/dist/date/createTheTime.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var makeSafeTimeValue = require('./makeSafeTimeValue.cjs');
+
+function createTheTime(timestamp) {
+    const safeTimestamp = makeSafeTimeValue.makeSafeTimeValue(timestamp);
+    return `time${Math.abs(safeTimestamp)}${safeTimestamp < 0 ? "-" : "+"}`;
+}
+
+exports.createTheTime = createTheTime;