@duplojs/utils 1.5.6 → 1.5.8

package/dist/clean/{unwrapEntity.d.ts → entity/unwrap.d.ts}

@@ -1,13 +1,14 @@
-import { type GetKindValue, type SimplifyTopLevel, type Kind, type Unwrap, type DeepReadonly, type TransformerFunction, type IsEqual, type Transformer } from "../common";
-import { entityKind, type Entity } from "./entity";
-import { flagKind } from "./flag";
-type ApplyTransformer<GenericValue extends unknown, GenericTransformer extends TransformerFunction> = IsEqual<GenericTransformer, never> extends true ? GenericValue : GenericTransformer extends TransformerFunction<infer InferredMethodName> ? Transformer<GenericValue, InferredMethodName> : never;
-type UnwrapArrayProperties<GenericValue extends readonly any[], GenericTransformer extends TransformerFunction> = GenericValue extends readonly [infer InferredFirst, ...infer InferredRest] ? (InferredRest extends readonly [] ? readonly [] : UnwrapArrayProperties<InferredRest, GenericTransformer>) extends infer InferredResult extends readonly any[] ? readonly [
-    ApplyTransformer<Unwrap<InferredFirst>, GenericTransformer>,
-    ...InferredResult
-] : never : readonly ApplyTransformer<Unwrap<GenericValue[number]>, GenericTransformer>[];
+import { type Unwrap, type WrappedValue, type IsEqual, type Transformer, type TransformerFunction, type SimplifyTopLevel, type DeepReadonly, type GetKindValue, type Kind } from "../../common";
+import { entityKind, type Entity } from ".";
+import { flagKind } from "../flag";
+export type UnwrapEntityProperty<GenericProperty extends unknown, GenericTransformer extends TransformerFunction = never> = GenericProperty extends WrappedValue ? IsEqual<GenericTransformer, never> extends true ? Unwrap<GenericProperty> : GenericTransformer extends TransformerFunction<infer InferredMethodName> ? Transformer<Unwrap<GenericProperty>, InferredMethodName> : never : GenericProperty extends null ? null : GenericProperty extends readonly [infer InferredFirst, ...infer InferredRest] ? readonly [
+    UnwrapEntityProperty<InferredFirst, GenericTransformer>,
+    ...UnwrapEntityProperty<InferredRest, GenericTransformer>
+] : GenericProperty extends readonly [] ? readonly [] : GenericProperty extends readonly unknown[] ? readonly UnwrapEntityProperty<GenericProperty[number], GenericTransformer>[] : GenericProperty extends Record<string, unknown> ? {
+    [Prop in keyof GenericProperty]: UnwrapEntityProperty<GenericProperty[Prop], GenericTransformer>;
+} : GenericProperty;
 export type UnwrapEntity<GenericEntity extends Entity, GenericTransformer extends TransformerFunction = never> = SimplifyTopLevel<DeepReadonly<{
-    [Prop in Extract<keyof GenericEntity, string>]: GenericEntity[Prop] extends readonly any[] ? UnwrapArrayProperties<GenericEntity[Prop], GenericTransformer> : ApplyTransformer<Unwrap<GenericEntity[Prop]>, GenericTransformer>;
+    [Prop in Extract<keyof GenericEntity, string>]: UnwrapEntityProperty<GenericEntity[Prop], GenericTransformer>;
 } & {
     [Prop in "_entityName"]: GetKindValue<typeof entityKind, GenericEntity>;
 } & (GenericEntity extends Kind<typeof flagKind.definition, any> ? {
@@ -59,7 +60,9 @@ export type UnwrapEntity<GenericEntity extends Entity, GenericTransformer extend
  * @namespace C
  * 
  */
+export declare function unwrapEntityProperty<GenericProperty extends unknown, GenericTransformer extends TransformerFunction = never>(property: GenericProperty, params?: {
+    transformer?: GenericTransformer;
+}): UnwrapEntityProperty<GenericProperty, GenericTransformer>;
 export declare function unwrapEntity<GenericEntity extends Entity, GenericTransformer extends TransformerFunction = never>(entity: GenericEntity, params?: {
     transformer?: GenericTransformer;
 }): UnwrapEntity<GenericEntity, GenericTransformer>;
-export {};

package/dist/clean/entity/unwrap.mjs

@@ -0,0 +1,55 @@
+import { entityKind } from './index.mjs';
+import { flagKind } from '../flag.mjs';
+import { isWrappedValue } from '../../common/wrapValue.mjs';
+import { unwrap } from '../../common/unwrap.mjs';
+
+/**
+ * {@include clean/unwrapEntity/index.md}
+ */
+function unwrapEntityProperty(property, params) {
+    if (isWrappedValue(property)) {
+        return params?.transformer
+            ? params.transformer(unwrap(property))
+            : unwrap(property);
+    }
+    else if (property === null) {
+        return property;
+    }
+    else if (property instanceof Array) {
+        const length = property.length;
+        const result = [];
+        for (let index = 0; index < length; index++) {
+            result[index] = unwrapEntityProperty(property[index], params);
+        }
+        return result;
+    }
+    else if (typeof property === "object"
+        && (!property.constructor
+            || property.constructor.name === "Object")) {
+        const result = {};
+        for (const key in property) {
+            result[key] = unwrapEntityProperty(property[key], params);
+        }
+        return result;
+    }
+    else {
+        return property;
+    }
+}
+function unwrapEntity(entity, params) {
+    const unwrapEntity = {};
+    for (const prop in entity) {
+        if (prop === entityKind.runTimeKey) {
+            unwrapEntity._entityName = entity[prop];
+        }
+        else if (prop === flagKind.runTimeKey) {
+            unwrapEntity._flags = entity[prop];
+        }
+        else {
+            unwrapEntity[prop] = unwrapEntityProperty(entity[prop], params);
+        }
+    }
+    return unwrapEntity;
+}
+
+export { unwrapEntity, unwrapEntityProperty };

package/dist/clean/index.cjs

@@ -2,12 +2,13 @@
 
 var kind = require('./kind.cjs');
 var newType = require('./newType.cjs');
-var entity = require('./entity.cjs');
+var index = require('./entity/index.cjs');
 var repository = require('./repository.cjs');
 var useCase = require('./useCase.cjs');
 var flag = require('./flag.cjs');
-var unwrapEntity = require('./unwrapEntity.cjs');
 var maybe = require('./maybe.cjs');
+var property = require('./entity/property.cjs');
+var unwrap = require('./entity/unwrap.cjs');
 var base = require('./constraint/base.cjs');
 var number = require('./constraint/defaultConstraint/number.cjs');
 var string = require('./constraint/defaultConstraint/string.cjs');
@@ -49,9 +50,9 @@ exports.CreateNewTypeError = newType.CreateNewTypeError;
 exports.createNewType = newType.createNewType;
 exports.newTypeHandlerKind = newType.newTypeHandlerKind;
 exports.newTypeKind = newType.newTypeKind;
-exports.CreateEntityError = entity.CreateEntityError;
-exports.createEntity = entity.createEntity;
-exports.entityKind = entity.entityKind;
+exports.CreateEntityError = index.CreateEntityError;
+exports.createEntity = index.createEntity;
+exports.entityKind = index.entityKind;
 exports.createRepository = repository.createRepository;
 exports.repositoryHandlerKind = repository.repositoryHandlerKind;
 exports.createUseCase = useCase.createUseCase;
@@ -59,9 +60,16 @@ exports.useCaseHandlerKind = useCase.useCaseHandlerKind;
 exports.useCaseInstances = useCase.useCaseInstances;
 exports.createFlag = flag.createFlag;
 exports.flagKind = flag.flagKind;
-exports.unwrapEntity = unwrapEntity.unwrapEntity;
 exports.none = maybe.none;
 exports.some = maybe.some;
+exports.entityPropertyArrayKind = property.entityPropertyArrayKind;
+exports.entityPropertyDefinitionToDataParser = property.entityPropertyDefinitionToDataParser;
+exports.entityPropertyDefinitionTools = property.entityPropertyDefinitionTools;
+exports.entityPropertyNullableKind = property.entityPropertyNullableKind;
+exports.entityPropertyStructureKind = property.entityPropertyStructureKind;
+exports.entityPropertyUnionKind = property.entityPropertyUnionKind;
+exports.unwrapEntity = unwrap.unwrapEntity;
+exports.unwrapEntityProperty = unwrap.unwrapEntityProperty;
 exports.CreateConstrainedTypeError = base.CreateConstrainedTypeError;
 exports.constrainedTypeKind = base.constrainedTypeKind;
 exports.constraintHandlerKind = base.constraintHandlerKind;

package/dist/clean/index.d.ts

@@ -32,5 +32,4 @@ export * from "./primitive";
 export * from "./repository";
 export * from "./useCase";
 export * from "./flag";
-export * from "./unwrapEntity";
 export * from "./maybe";

package/dist/clean/index.mjs

@@ -1,11 +1,12 @@
 export { createCleanKind } from './kind.mjs';
 export { CreateNewTypeError, createNewType, newTypeHandlerKind, newTypeKind } from './newType.mjs';
-export { CreateEntityError, createEntity, entityKind } from './entity.mjs';
+export { CreateEntityError, createEntity, entityKind } from './entity/index.mjs';
 export { createRepository, repositoryHandlerKind } from './repository.mjs';
 export { createUseCase, useCaseHandlerKind, useCaseInstances } from './useCase.mjs';
 export { createFlag, flagKind } from './flag.mjs';
-export { unwrapEntity } from './unwrapEntity.mjs';
 export { none, some } from './maybe.mjs';
+export { entityPropertyArrayKind, entityPropertyDefinitionToDataParser, entityPropertyDefinitionTools, entityPropertyNullableKind, entityPropertyStructureKind, entityPropertyUnionKind } from './entity/property.mjs';
+export { unwrapEntity, unwrapEntityProperty } from './entity/unwrap.mjs';
 export { CreateConstrainedTypeError, constrainedTypeKind, constraintHandlerKind, createConstraint } from './constraint/base.mjs';
 export { Int, Negative, NumberMax, NumberMin, Positive, PositiveInt } from './constraint/defaultConstraint/number.mjs';
 export { Email, StringMax, StringMin, Url } from './constraint/defaultConstraint/string.mjs';

package/dist/clean/maybe.cjs

@@ -1,14 +1,14 @@
 'use strict';
 
-var entity = require('./entity.cjs');
+var index = require('./entity/index.cjs');
 var create = require('../either/right/create.cjs');
 var create$1 = require('../either/left/create.cjs');
 
 /**
  * {@include clean/some/index.md}
  */
-function some(entity$1) {
-    return create.right(`some-${entity.entityKind.getValue(entity$1)}`, entity$1);
+function some(entity) {
+    return create.right(`some-${index.entityKind.getValue(entity)}`, entity);
 }
 /**
  * {@include clean/none/index.md}

package/dist/clean/maybe.mjs

@@ -1,4 +1,4 @@
-import { entityKind } from './entity.mjs';
+import { entityKind } from './entity/index.mjs';
 import { right } from '../either/right/create.mjs';
 import { left } from '../either/left/create.mjs';
 

package/dist/dataParser/extended/tuple.d.ts

@@ -1,4 +1,4 @@
-import { type FixDeepFunctionInfer, type Kind, type NeverCoalescing, type SimplifyTopLevel } from "../../common";
+import { type FixDeepFunctionInfer, type IsEqual, type Kind, type NeverCoalescing, type Or, type SimplifyTopLevel } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition, type DataParsers } from "../types";
 import * as dataParsers from "../parsers";
@@ -139,7 +139,11 @@ export interface DataParserTupleExtended<GenericDefinition extends dataParsers.D
  * 
  */
 export declare function tuple<GenericShape extends dataParsers.TupleShape, const GenericDefinition extends Partial<Omit<dataParsers.DataParserDefinitionTuple, "shape">> = never>(shape: GenericShape, definition?: GenericDefinition): DataParserTupleExtended<MergeDefinition<dataParsers.DataParserDefinitionTuple, NeverCoalescing<GenericDefinition, {}> & {
-    shape: GenericShape;
+    readonly shape: GenericShape;
+    readonly rest: Or<[
+        IsEqual<GenericDefinition["rest"], unknown>,
+        IsEqual<GenericDefinition, never>
+    ]> extends true ? undefined : GenericDefinition["rest"];
 }>>;
 export declare namespace tuple {
     var overrideHandler: import("../../common").OverrideHandler<DataParserTupleExtended<dataParsers.DataParserDefinitionTuple>>;

package/dist/date/computeTime.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var constants = require('./constants.cjs');
+var toTimeValue = require('./toTimeValue.cjs');
+
+const unitMapper = {
+    week: 1 / constants.millisecondInOneWeek,
+    day: 1 / constants.millisecondsInOneDay,
+    hour: 1 / constants.millisecondInOneHour,
+    minute: 1 / constants.millisecondInOneMinute,
+    second: 1 / constants.millisecondsInOneSecond,
+    millisecond: 1,
+};
+function computeTime(...args) {
+    if (args.length === 1) {
+        const [unit] = args;
+        return (input) => computeTime(input, unit);
+    }
+    const [input, unit] = args;
+    return toTimeValue.toTimeValue(input) * unitMapper[unit];
+}
+
+exports.computeTime = computeTime;

package/dist/date/computeTime.d.ts

@@ -0,0 +1,41 @@
+import type { TheTime } from "./theTime";
+import type { SerializedTheTime } from "./types";
+type ComputeTimeUnit = "week" | "day" | "hour" | "minute" | "second" | "millisecond";
+/**
+ * Converts a time value to a numeric value in the requested time unit.
+ * 
+ * **Supported call styles:**
+ * - Classic: `computeTime(input, unit)` → `number`
+ * - Curried: `computeTime(unit)` → `(input) => number`
+ * 
+ * `input` accepts `TheTime` or `SerializedTheTime`.
+ * `unit` accepts `week | day | hour | minute | second | millisecond`.
+ * 
+ * ```ts
+ * const input = D.createTime(7_200_000, "millisecond");
+ * 
+ * const hours = D.computeTime(input, "hour");
+ * // hours: number
+ * 
+ * const minutesFromSerialized = D.computeTime("time3600000-", "minute");
+ * // minutesFromSerialized: number
+ * 
+ * const days = pipe(
+ * 	D.createTime(172_800_000, "millisecond"),
+ * 	D.computeTime("day"),
+ * );
+ * // days: number
+ * 
+ * ```
+ * 
+ * @remarks
+ * - `computeTime` keeps the sign of the input value.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/computeTime
+ * 
+ * @namespace D
+ * 
+ */
+export declare function computeTime(unit: ComputeTimeUnit): (input: TheTime | SerializedTheTime) => number;
+export declare function computeTime(input: TheTime | SerializedTheTime, unit: ComputeTimeUnit): number;
+export {};

package/dist/date/computeTime.mjs

@@ -0,0 +1,21 @@
+import { millisecondsInOneSecond, millisecondInOneMinute, millisecondInOneHour, millisecondsInOneDay, millisecondInOneWeek } from './constants.mjs';
+import { toTimeValue } from './toTimeValue.mjs';
+
+const unitMapper = {
+    week: 1 / millisecondInOneWeek,
+    day: 1 / millisecondsInOneDay,
+    hour: 1 / millisecondInOneHour,
+    minute: 1 / millisecondInOneMinute,
+    second: 1 / millisecondsInOneSecond,
+    millisecond: 1,
+};
+function computeTime(...args) {
+    if (args.length === 1) {
+        const [unit] = args;
+        return (input) => computeTime(input, unit);
+    }
+    const [input, unit] = args;
+    return toTimeValue(input) * unitMapper[unit];
+}
+
+export { computeTime };

package/dist/date/getDifference.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var makeSafeTimeValue = require('./makeSafeTimeValue.cjs');
+var theTime = require('./theTime.cjs');
+var toTimestamp = require('./toTimestamp.cjs');
+
+function getDifference(...args) {
+    if (args.length === 1) {
+        const [reference] = args;
+        return (input) => getDifference(input, reference);
+    }
+    const inputTimestamp = toTimestamp.toTimestamp(args[0]);
+    const referenceTimestamp = toTimestamp.toTimestamp(args[1]);
+    return theTime.TheTime.new(makeSafeTimeValue.makeSafeTimeValue(inputTimestamp - referenceTimestamp));
+}
+
+exports.getDifference = getDifference;

package/dist/date/getDifference.d.ts

@@ -0,0 +1,44 @@
+import type { TheDate } from "./theDate";
+import { TheTime } from "./theTime";
+import type { SerializedTheDate } from "./types";
+/**
+ * Returns the time difference between two dates as `TheTime`.
+ * 
+ * **Supported call styles:**
+ * - Classic: `getDifference(input, reference)` → `TheTime`
+ * - Curried: `getDifference(reference)` → `(input) => TheTime`
+ * 
+ * The difference is computed as `input - reference` in milliseconds and returned as `TheTime`.
+ * 
+ * ```ts
+ * const input = D.create("2024-01-03");
+ * const reference = D.create("2024-01-01");
+ * 
+ * const difference = D.getDifference(input, reference);
+ * // difference: TheTime
+ * 
+ * const asMilliseconds = difference.toNative();
+ * // asMilliseconds: number
+ * 
+ * const withSerialized = D.getDifference(
+ * 	"date172800000+",
+ * 	"date86400000+",
+ * );
+ * // withSerialized: TheTime
+ * 
+ * pipe(
+ * 	input,
+ * 	D.getDifference(reference),
+ * ```
+ * 
+ * @remarks
+ * - `TheTime` supports negative values, so `getDifference` preserves the sign of `input - reference`.
+ * - Input accepts `TheDate` and `SerializedTheDate`.
+ * 
+ * @see https://utils.duplojs.dev/en/v1/api/date/getDifference
+ * 
+ * @namespace D
+ * 
+ */
+export declare function getDifference(reference: TheDate | SerializedTheDate): (input: TheDate | SerializedTheDate) => TheTime;
+export declare function getDifference(input: TheDate | SerializedTheDate, reference: TheDate | SerializedTheDate): TheTime;

package/dist/date/getDifference.mjs

@@ -0,0 +1,15 @@
+import { makeSafeTimeValue } from './makeSafeTimeValue.mjs';
+import { TheTime } from './theTime.mjs';
+import { toTimestamp } from './toTimestamp.mjs';
+
+function getDifference(...args) {
+    if (args.length === 1) {
+        const [reference] = args;
+        return (input) => getDifference(input, reference);
+    }
+    const inputTimestamp = toTimestamp(args[0]);
+    const referenceTimestamp = toTimestamp(args[1]);
+    return TheTime.new(makeSafeTimeValue(inputTimestamp - referenceTimestamp));
+}
+
+export { getDifference };

package/dist/date/index.cjs

@@ -9,6 +9,7 @@ var tomorrow = require('./tomorrow.cjs');
 var toNative = require('./toNative.cjs');
 var toTimestamp = require('./toTimestamp.cjs');
 var toTimeValue = require('./toTimeValue.cjs');
+var computeTime = require('./computeTime.cjs');
 var toISOString = require('./toISOString.cjs');
 var closestTo = require('./closestTo.cjs');
 var each = require('./each.cjs');
@@ -29,6 +30,7 @@ var getTimezoneOffset = require('./getTimezoneOffset.cjs');
 var applyTimezone = require('./applyTimezone.cjs');
 var format = require('./format.cjs');
 var formatTime = require('./formatTime.cjs');
+var getDifference = require('./getDifference.cjs');
 var makeSafeTimestamp = require('./makeSafeTimestamp.cjs');
 var createTime = require('./createTime.cjs');
 var createTimeOrThrow = require('./createTimeOrThrow.cjs');
@@ -113,6 +115,7 @@ exports.tomorrow = tomorrow.tomorrow;
 exports.toNative = toNative.toNative;
 exports.toTimestamp = toTimestamp.toTimestamp;
 exports.toTimeValue = toTimeValue.toTimeValue;
+exports.computeTime = computeTime.computeTime;
 exports.toISOString = toISOString.toISOString;
 exports.closestTo = closestTo.closestTo;
 exports.each = each.each;
@@ -134,6 +137,7 @@ exports.getTimezoneOffset = getTimezoneOffset.getTimezoneOffset;
 exports.applyTimezone = applyTimezone.applyTimezone;
 exports.format = format.format;
 exports.formatTime = formatTime.formatTime;
+exports.getDifference = getDifference.getDifference;
 exports.makeSafeTimestamp = makeSafeTimestamp.makeSafeTimestamp;
 exports.createTime = createTime.createTime;
 exports.CreateTheTimeError = createTimeOrThrow.CreateTheTimeError;

package/dist/date/index.d.ts

@@ -40,6 +40,7 @@ export * from "./tomorrow";
 export * from "./toNative";
 export * from "./toTimestamp";
 export * from "./toTimeValue";
+export * from "./computeTime";
 export * from "./getters";
 export * from "./toISOString";
 export * from "./operators";
@@ -63,6 +64,7 @@ export * from "./getTimezoneOffset";
 export * from "./applyTimezone";
 export * from "./format";
 export * from "./formatTime";
+export * from "./getDifference";
 export * from "./makeSafeTimestamp";
 export * from "./createTime";
 export * from "./createTimeOrThrow";

package/dist/date/index.mjs

@@ -7,6 +7,7 @@ export { tomorrow } from './tomorrow.mjs';
 export { toNative } from './toNative.mjs';
 export { toTimestamp } from './toTimestamp.mjs';
 export { toTimeValue } from './toTimeValue.mjs';
+export { computeTime } from './computeTime.mjs';
 export { toISOString } from './toISOString.mjs';
 export { closestTo } from './closestTo.mjs';
 export { each } from './each.mjs';
@@ -27,6 +28,7 @@ export { getTimezoneOffset } from './getTimezoneOffset.mjs';
 export { applyTimezone } from './applyTimezone.mjs';
 export { format } from './format.mjs';
 export { formatTime } from './formatTime.mjs';
+export { getDifference } from './getDifference.mjs';
 export { makeSafeTimestamp } from './makeSafeTimestamp.mjs';
 export { createTime } from './createTime.mjs';
 export { CreateTheTimeError, createTimeOrThrow } from './createTimeOrThrow.mjs';

package/dist/date/theTime.d.ts

@@ -1,9 +1,9 @@
-import { type SerializedTheTime } from "./types";
+import type { SerializedTheTime } from "./types";
 declare const TheTime_base: new (params?: {
     "@DuplojsUtilsDate/the-time"?: unknown;
 } | undefined) => import("../common/kind").Kind<import("../common/kind").KindDefinition<"the-time", unknown>, unknown> & import("../common/kind").Kind<import("../common/kind").KindDefinition<"@DuplojsUtilsDate/the-time", unknown>, unknown>;
 /**
- * Represents an immutable time value object (`TheTime`) stored in milliseconds.
+ * Represents an immutable signed time value object (`TheTime`) stored in milliseconds.
  * 
  * Signature: `TheTime` → immutable class-like value object
  * 
@@ -32,6 +32,7 @@ declare const TheTime_base: new (params?: {
  * 
  * @remarks
  * - `TheTime` is not a `number`, but it behaves as an immutable numeric time value.
+ * - `TheTime` supports negative values and is not an absolute value by default.
  * - Date unit operators (`addMinutes`, `subtractDays`, etc.) target `TheDate`; `TheTime` is used as a normalized duration value.
  * - Use `D.serialize(theTime)` to convert to `SerializedTheTime`.
  * - Use `D.createTime(...)` / `D.createTimeOrThrow(...)` to construct instances.

package/dist/date/toNative.cjs

@@ -1,17 +1,23 @@
 'use strict';
 
 var theDate = require('./theDate.cjs');
+var theTime = require('./theTime.cjs');
 var toTimestamp = require('./toTimestamp.cjs');
+var toTimeValue = require('./toTimeValue.cjs');
 
-/**
- * {@include date/toNative/index.md}
- */
 function toNative(input) {
     if (input instanceof theDate.TheDate) {
         return input.toNative();
     }
-    const timestamp = toTimestamp.toTimestamp(input);
-    return new Date(timestamp);
+    else if (input instanceof theTime.TheTime) {
+        return input.toNative();
+    }
+    else if (input.startsWith("date")) {
+        return new Date(toTimestamp.toTimestamp(input));
+    }
+    else {
+        return toTimeValue.toTimeValue(input);
+    }
 }
 
 exports.toNative = toNative;

package/dist/date/toNative.d.ts

@@ -1,28 +1,42 @@
 import { TheDate } from "./theDate";
-import type { SerializedTheDate } from "./types";
+import { TheTime } from "./theTime";
+import type { SerializedTheDate, SerializedTheTime } from "./types";
 /**
- * Converts a date value to native JavaScript `Date`.
+ * Converts a date or time value to native JavaScript representation.
  * 
- * Signature: `toNative(input)` → `Date`
+ * Signature: `toNative(input)` → `Date | number`
  * 
- * `input` accepts `TheDate` or `SerializedTheDate`.
+ * `input` accepts `TheDate`, `SerializedTheDate`, `TheTime`, or `SerializedTheTime`.
  * 
  * ```ts
- * const input = D.create("2024-06-20");
- * const nativeDate = D.toNative(input);
+ * const dateInput = D.create("2024-06-20");
+ * const nativeDate = D.toNative(dateInput);
  * // nativeDate: Date
  * 
  * const nativeDate2 = D.toNative("date1718841600000+");
  * // nativeDate2: Date
  * 
+ * const timeInput = D.createTime(90000, "millisecond");
+ * const timeValue = D.toNative(timeInput);
+ * // timeValue: number
+ * 
+ * const timeValue2 = D.toNative("time3600000-");
+ * // timeValue2: number
+ * 
  * pipe(
- * 	input,
+ * 	timeInput,
  * 	D.toNative,
+ * ); // number
  * ```
  * 
+ * @remarks
+ * - Returns `Date` for date inputs.
+ * - Returns `number` for time inputs.
+ * 
  * @see https://utils.duplojs.dev/en/v1/api/date/toNative
  * 
  * @namespace D
  * 
  */
 export declare function toNative<GenericInput extends TheDate | SerializedTheDate>(input: GenericInput): Date;
+export declare function toNative<GenericInput extends TheTime | SerializedTheTime>(input: GenericInput): number;

package/dist/date/toNative.mjs

@@ -1,15 +1,21 @@
 import { TheDate } from './theDate.mjs';
+import { TheTime } from './theTime.mjs';
 import { toTimestamp } from './toTimestamp.mjs';
+import { toTimeValue } from './toTimeValue.mjs';
 
-/**
- * {@include date/toNative/index.md}
- */
 function toNative(input) {
     if (input instanceof TheDate) {
         return input.toNative();
     }
-    const timestamp = toTimestamp(input);
-    return new Date(timestamp);
+    else if (input instanceof TheTime) {
+        return input.toNative();
+    }
+    else if (input.startsWith("date")) {
+        return new Date(toTimestamp(input));
+    }
+    else {
+        return toTimeValue(input);
+    }
 }
 
 export { toNative };

package/dist/date/types/serializedTheTime.d.ts

@@ -1,5 +1,5 @@
 /**
- * Represents an immutable time value object (`TheTime`) stored in milliseconds.
+ * Represents an immutable signed time value object (`TheTime`) stored in milliseconds.
  * 
  * Signature: `TheTime` → immutable class-like value object
  * 
@@ -28,6 +28,7 @@
  * 
  * @remarks
  * - `TheTime` is not a `number`, but it behaves as an immutable numeric time value.
+ * - `TheTime` supports negative values and is not an absolute value by default.
  * - Date unit operators (`addMinutes`, `subtractDays`, etc.) target `TheDate`; `TheTime` is used as a normalized duration value.
  * - Use `D.serialize(theTime)` to convert to `SerializedTheTime`.
  * - Use `D.createTime(...)` / `D.createTimeOrThrow(...)` to construct instances.