date-vir 4.1.0 → 5.0.0

package/dist/cjs/date-operations/diff-dates.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDateAfter = exports.diffDatesAllUnits = exports.diffDates = void 0;
+exports.isDateAfter = exports.diffDates = exports.DiffType = void 0;
 const common_1 = require("@augment-vir/common");
 const duration_1 = require("../duration");
 const luxon_date_time_conversion_1 = require("../full-date/luxon-date-time-conversion");
+const accuracyPriority = {
+    longterm: 1,
+    casual: 0,
+};
 const conversionAccuracies = {
     [duration_1.DurationUnit.Years]: 'longterm',
     [duration_1.DurationUnit.Quarters]: 'longterm',
@@ -15,57 +19,86 @@ const conversionAccuracies = {
     [duration_1.DurationUnit.Seconds]: 'casual',
     [duration_1.DurationUnit.Milliseconds]: 'casual',
 };
-/**
- * Diffs two dates and returns the diff in the specific unit.
- *
- * Note: when years, quarters, or months are used for the unit then "long term" durations are used
- * to calculate the diff. See more details here:
- * https://moment.github.io/luxon/#/math?id=casual-vs-longterm-conversion-accuracy
- */
-function diffDates({ start, end, unit, }) {
+function getHighestPriorityConversionAccuracy(units) {
+    const currentConversionAccuracies = units.map((unit) => conversionAccuracies[unit]);
+    const highestPriorityAccuracy = currentConversionAccuracies.reduce((priorityAccuracy, currentAccuracy) => {
+        if (accuracyPriority[currentAccuracy] > accuracyPriority[priorityAccuracy]) {
+            return currentAccuracy;
+        }
+        else {
+            return priorityAccuracy;
+        }
+    });
+    return highestPriorityAccuracy;
+}
+var DiffType;
+(function (DiffType) {
+    /**
+     * Causes the diffDates function to output the diff split between each unit provided. To get the
+     * full duration, each output unit needs to be added together.
+     */
+    DiffType["AdditiveUnits"] = "additive-units";
+    /**
+     * Causes the diffDates function to output the diff in each unit provided with each unit being
+     * equivalent in value. Meaning, each unit will be the same duration of time converted into that
+     * unit.
+     */
+    DiffType["EquivalentUnits"] = "equivalent-units";
+})(DiffType || (exports.DiffType = DiffType = {}));
+function diffDates({ start, end, units: unitsInput, unit: unitInput, diffType: diffTypeInput, decimalCount, }) {
     const luxonDateStart = (0, luxon_date_time_conversion_1.toLuxonDateTime)(start);
     const luxonDateEnd = (0, luxon_date_time_conversion_1.toLuxonDateTime)(end);
-    const diff = luxonDateEnd
-        .diff(luxonDateStart, unit, {
-        conversionAccuracy: conversionAccuracies[unit],
-    })
-        .toObject();
-    return diff;
-}
-exports.diffDates = diffDates;
-/**
- * Diffs two dates and returns that diff in each unit. Note that the unit in the returned object are
- * not meant to be added together, each unit is instead the same value but calculated in that given
- * unit.
- *
- * Note: when years, quarters, or months are used for the unit then "long term" durations are used
- * to calculate the diff. See more details here:
- * https://moment.github.io/luxon/#/math?id=casual-vs-longterm-conversion-accuracy
- */
-function diffDatesAllUnits({ start, end }) {
-    const allUnitDiffEntries = duration_1.orderedDurationUnits.map((durationUnit) => {
-        const diff = diffDates({
-            start,
-            end,
-            unit: durationUnit,
+    const units = (unitsInput ?? [unitInput]);
+    const diffType = units.length === 1
+        ? /**
+           * When only one unit is provided, it doesn't matter which diff type we use so lets just use this
+           * one.
+           */
+            DiffType.EquivalentUnits
+        : diffTypeInput;
+    if (!diffType) {
+        throw new Error('Failed to diff dates: no diffType was provided.');
+    }
+    if (diffType === DiffType.AdditiveUnits) {
+        const conversionAccuracy = getHighestPriorityConversionAccuracy(units);
+        const additiveDiff = luxonDateEnd
+            .diff(luxonDateStart, (0, common_1.makeWritable)(units), {
+            conversionAccuracy,
+        })
+            .toObject();
+        return (0, duration_1.roundDuration)(additiveDiff, decimalCount);
+    }
+    else if (diffType === DiffType.EquivalentUnits) {
+        const allUnitDiffEntries = units.map((durationUnit) => {
+            const diff = luxonDateEnd
+                .diff(luxonDateStart, durationUnit, {
+                conversionAccuracy: conversionAccuracies[durationUnit],
+            })
+                .toObject();
+            const duration = diff[durationUnit];
+            /** Ignore this edge case in coverage cause its for type guarding. */
+            /* c8 ignore next 5 */
+            if (duration == undefined) {
+                throw new Error(`Internal date-vir error: failed to find duration for '${durationUnit}'`);
+            }
+            return [
+                durationUnit,
+                duration,
+            ];
         });
-        const duration = diff[durationUnit];
-        /** Ignore this edge case in coverage cause its for type guarding. */
-        /* c8 ignore next 5 */
-        if (duration == undefined) {
-            throw new Error(`Internal date-vir error: failed to find duration for '${durationUnit}'`);
-        }
-        return [
-            durationUnit,
-            duration,
-        ];
-    });
-    const allDurations = (0, common_1.typedObjectFromEntries)(allUnitDiffEntries);
-    return allDurations;
+        const equivalentDiff = (0, common_1.typedObjectFromEntries)(allUnitDiffEntries);
+        return (0, duration_1.roundDuration)(equivalentDiff, decimalCount);
+    }
+    else {
+        throw new Error(`Failed to diff dates: provided diffType is invalid: '${diffType}'`);
+    }
 }
-exports.diffDatesAllUnits = diffDatesAllUnits;
+exports.diffDates = diffDates;
 function isDateAfter({ relativeTo, fullDate, }) {
-    return (diffDates({ start: relativeTo, end: fullDate, unit: duration_1.DurationUnit.Milliseconds })
-        .milliseconds >= 0);
+    return (diffDates({
+        start: relativeTo,
+        end: fullDate,
+        unit: duration_1.DurationUnit.Milliseconds,
+    }).milliseconds >= 0);
 }
 exports.isDateAfter = isDateAfter;

package/dist/cjs/duration.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.orderedDurationUnits = exports.singularDurationUnitNames = exports.DurationUnit = void 0;
+exports.roundDuration = exports.orderedDurationUnits = exports.singularDurationUnitNames = exports.DurationUnit = void 0;
+const common_1 = require("@augment-vir/common");
+const run_time_assertions_1 = require("run-time-assertions");
 var DurationUnit;
 (function (DurationUnit) {
     DurationUnit["Years"] = "years";
@@ -39,3 +41,14 @@ exports.orderedDurationUnits = [
     DurationUnit.Quarters,
     DurationUnit.Years,
 ];
+function roundDuration(duration, decimalCount) {
+    return (0, common_1.mapObjectValues)(duration, (key, value) => {
+        if (decimalCount == undefined || !(0, run_time_assertions_1.isRunTimeType)(value, 'number')) {
+            return value;
+        }
+        else {
+            return (0, common_1.round)({ number: value, digits: decimalCount });
+        }
+    });
+}
+exports.roundDuration = roundDuration;

package/dist/cjs/formatting/relative-string.js

@@ -17,9 +17,11 @@ const maxDurations = {
 };
 function toRelativeString({ fullDate, relativeTo, options = {}, }) {
     const roundingDigits = options.decimalDigitCount || 0;
-    const allUnitDiffs = (0, diff_dates_1.diffDatesAllUnits)({
+    const allUnitDiffs = (0, diff_dates_1.diffDates)({
         start: fullDate,
         end: relativeTo,
+        units: duration_1.orderedDurationUnits,
+        diffType: diff_dates_1.DiffType.EquivalentUnits,
     });
     const unitsWithinBounds = (0, common_1.mapObjectValues)(allUnitDiffs, (durationUnit, duration) => {
         const roundedDuration = Math.floor(Math.abs((0, common_1.round)({ digits: 1, number: duration })));

package/dist/cjs/full-date/create-full-date.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getNowFullDate = exports.toNewTimezone = exports.createFullDate = exports.createUtcFullDate = exports.createFullDateInUserTimezone = void 0;
-const common_1 = require("@augment-vir/common");
 const luxon_1 = require("luxon");
+const run_time_assertions_1 = require("run-time-assertions");
 const timezones_1 = require("../timezone/timezones");
 const is_valid_full_date_1 = require("./is-valid-full-date");
 const luxon_date_time_conversion_1 = require("./luxon-date-time-conversion");
@@ -58,10 +58,10 @@ function convertDateLikeToLuxonDateTime(dateLike, timezone) {
     if (luxon_1.DateTime.isDateTime(dateLike)) {
         return dateLike.setZone(timezone);
     }
-    else if ((0, common_1.isRuntimeTypeOf)(dateLike, 'number')) {
+    else if ((0, run_time_assertions_1.isRunTimeType)(dateLike, 'number')) {
         return luxon_1.DateTime.fromMillis(dateLike, { zone: timezones_1.utcTimezone }).setZone(timezone);
     }
-    else if ((0, common_1.isRuntimeTypeOf)(dateLike, 'string')) {
+    else if ((0, run_time_assertions_1.isRunTimeType)(dateLike, 'string')) {
         const dateTime = luxon_1.DateTime.fromISO(dateLike, { zone: timezone });
         if (!dateTime.isValid) {
             return lastDitchConversion(dateLike);

package/dist/cjs/full-date/parsing.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseInputElementValue = exports.parseStrangeString = void 0;
-const common_1 = require("@augment-vir/common");
 const luxon_1 = require("luxon");
+const run_time_assertions_1 = require("run-time-assertions");
 const create_full_date_1 = require("./create-full-date");
 const luxon_date_time_conversion_1 = require("./luxon-date-time-conversion");
 /**
@@ -35,7 +35,7 @@ function parseInputElementValue(elementOrValue, timezone) {
     if (!elementOrValue) {
         return undefined;
     }
-    const value = (0, common_1.isRuntimeTypeOf)(elementOrValue, 'string')
+    const value = (0, run_time_assertions_1.isRunTimeType)(elementOrValue, 'string')
         ? elementOrValue
         : elementOrValue.value;
     try {

package/dist/esm/date-operations/diff-dates.d.ts

@@ -1,5 +1,19 @@
-import { AllDurations, Duration, DurationUnit } from '../duration';
+import { ArrayElement } from '@augment-vir/common';
+import { Duration, DurationUnit } from '../duration';
 import { FullDate } from '../full-date/full-date-shape';
+export declare enum DiffType {
+    /**
+     * Causes the diffDates function to output the diff split between each unit provided. To get the
+     * full duration, each output unit needs to be added together.
+     */
+    AdditiveUnits = "additive-units",
+    /**
+     * Causes the diffDates function to output the diff in each unit provided with each unit being
+     * equivalent in value. Meaning, each unit will be the same duration of time converted into that
+     * unit.
+     */
+    EquivalentUnits = "equivalent-units"
+}
 /**
  * Diffs two dates and returns the diff in the specific unit.
  *
@@ -7,25 +21,45 @@ import { FullDate } from '../full-date/full-date-shape';
  * to calculate the diff. See more details here:
  * https://moment.github.io/luxon/#/math?id=casual-vs-longterm-conversion-accuracy
  */
-export declare function diffDates<const ChosenDurationKey extends DurationUnit>({ start, end, unit, }: {
-    start: FullDate;
-    end: FullDate;
-    unit: ChosenDurationKey;
-}): Duration<ChosenDurationKey>;
-/**
- * Diffs two dates and returns that diff in each unit. Note that the unit in the returned object are
- * not meant to be added together, each unit is instead the same value but calculated in that given
- * unit.
- *
- * Note: when years, quarters, or months are used for the unit then "long term" durations are used
- * to calculate the diff. See more details here:
- * https://moment.github.io/luxon/#/math?id=casual-vs-longterm-conversion-accuracy
- */
-export declare function diffDatesAllUnits({ start, end }: {
-    start: FullDate;
-    end: FullDate;
-}): AllDurations;
+export declare function diffDates<const ChosenDurationUnits extends DurationUnit>(params: {
+    start: Readonly<FullDate>;
+    end: Readonly<FullDate>;
+    /** The unit which the output should contain. */
+    unit: ChosenDurationUnits;
+    /**
+     * Determine the diff type calculation. See DiffType values for explanations on each one.
+     * Optional when only one unit is provided, as the diffType will not change the output either
+     * way.
+     */
+    diffType?: DiffType | undefined;
+    /** How many decimals to round the outputs to. Leave undefined to skip rounding entirely. */
+    decimalCount?: number | undefined;
+}): Duration<ChosenDurationUnits>;
+export declare function diffDates<const ChosenDurationUnits extends Readonly<[DurationUnit]>>(params: {
+    start: Readonly<FullDate>;
+    end: Readonly<FullDate>;
+    /** Which units the output should contain. */
+    units: ChosenDurationUnits;
+    /**
+     * Determine the diff type calculation. See DiffType values for explanations on each one.
+     * Optional when only one unit is provided, as the diffType will not change the output either
+     * way.
+     */
+    diffType?: DiffType | undefined;
+    /** How many decimals to round the outputs to. Leave undefined to skip rounding entirely. */
+    decimalCount?: number | undefined;
+}): Duration<ArrayElement<ChosenDurationUnits>>;
+export declare function diffDates<const ChosenDurationUnits extends ReadonlyArray<DurationUnit>>(params: {
+    start: Readonly<FullDate>;
+    end: Readonly<FullDate>;
+    /** Which units the output should contain. */
+    units: ChosenDurationUnits;
+    /** Determine the diff type calculation. See DiffType values for explanations on each one. */
+    diffType: DiffType;
+    /** How many decimals to round the outputs to. Leave undefined to skip rounding entirely. */
+    decimalCount?: number | undefined;
+}): Duration<ArrayElement<ChosenDurationUnits>>;
 export declare function isDateAfter({ relativeTo, fullDate, }: {
-    relativeTo: FullDate;
-    fullDate: FullDate;
+    relativeTo: Readonly<FullDate>;
+    fullDate: Readonly<FullDate>;
 }): boolean;

package/dist/esm/date-operations/diff-dates.js

@@ -1,6 +1,10 @@
-import { typedObjectFromEntries } from '@augment-vir/common';
-import { DurationUnit, orderedDurationUnits } from '../duration';
+import { makeWritable, typedObjectFromEntries } from '@augment-vir/common';
+import { DurationUnit, roundDuration } from '../duration';
 import { toLuxonDateTime } from '../full-date/luxon-date-time-conversion';
+const accuracyPriority = {
+    longterm: 1,
+    casual: 0,
+};
 const conversionAccuracies = {
     [DurationUnit.Years]: 'longterm',
     [DurationUnit.Quarters]: 'longterm',
@@ -12,54 +16,84 @@ const conversionAccuracies = {
     [DurationUnit.Seconds]: 'casual',
     [DurationUnit.Milliseconds]: 'casual',
 };
-/**
- * Diffs two dates and returns the diff in the specific unit.
- *
- * Note: when years, quarters, or months are used for the unit then "long term" durations are used
- * to calculate the diff. See more details here:
- * https://moment.github.io/luxon/#/math?id=casual-vs-longterm-conversion-accuracy
- */
-export function diffDates({ start, end, unit, }) {
+function getHighestPriorityConversionAccuracy(units) {
+    const currentConversionAccuracies = units.map((unit) => conversionAccuracies[unit]);
+    const highestPriorityAccuracy = currentConversionAccuracies.reduce((priorityAccuracy, currentAccuracy) => {
+        if (accuracyPriority[currentAccuracy] > accuracyPriority[priorityAccuracy]) {
+            return currentAccuracy;
+        }
+        else {
+            return priorityAccuracy;
+        }
+    });
+    return highestPriorityAccuracy;
+}
+export var DiffType;
+(function (DiffType) {
+    /**
+     * Causes the diffDates function to output the diff split between each unit provided. To get the
+     * full duration, each output unit needs to be added together.
+     */
+    DiffType["AdditiveUnits"] = "additive-units";
+    /**
+     * Causes the diffDates function to output the diff in each unit provided with each unit being
+     * equivalent in value. Meaning, each unit will be the same duration of time converted into that
+     * unit.
+     */
+    DiffType["EquivalentUnits"] = "equivalent-units";
+})(DiffType || (DiffType = {}));
+export function diffDates({ start, end, units: unitsInput, unit: unitInput, diffType: diffTypeInput, decimalCount, }) {
     const luxonDateStart = toLuxonDateTime(start);
     const luxonDateEnd = toLuxonDateTime(end);
-    const diff = luxonDateEnd
-        .diff(luxonDateStart, unit, {
-        conversionAccuracy: conversionAccuracies[unit],
-    })
-        .toObject();
-    return diff;
-}
-/**
- * Diffs two dates and returns that diff in each unit. Note that the unit in the returned object are
- * not meant to be added together, each unit is instead the same value but calculated in that given
- * unit.
- *
- * Note: when years, quarters, or months are used for the unit then "long term" durations are used
- * to calculate the diff. See more details here:
- * https://moment.github.io/luxon/#/math?id=casual-vs-longterm-conversion-accuracy
- */
-export function diffDatesAllUnits({ start, end }) {
-    const allUnitDiffEntries = orderedDurationUnits.map((durationUnit) => {
-        const diff = diffDates({
-            start,
-            end,
-            unit: durationUnit,
+    const units = (unitsInput ?? [unitInput]);
+    const diffType = units.length === 1
+        ? /**
+           * When only one unit is provided, it doesn't matter which diff type we use so lets just use this
+           * one.
+           */
+            DiffType.EquivalentUnits
+        : diffTypeInput;
+    if (!diffType) {
+        throw new Error('Failed to diff dates: no diffType was provided.');
+    }
+    if (diffType === DiffType.AdditiveUnits) {
+        const conversionAccuracy = getHighestPriorityConversionAccuracy(units);
+        const additiveDiff = luxonDateEnd
+            .diff(luxonDateStart, makeWritable(units), {
+            conversionAccuracy,
+        })
+            .toObject();
+        return roundDuration(additiveDiff, decimalCount);
+    }
+    else if (diffType === DiffType.EquivalentUnits) {
+        const allUnitDiffEntries = units.map((durationUnit) => {
+            const diff = luxonDateEnd
+                .diff(luxonDateStart, durationUnit, {
+                conversionAccuracy: conversionAccuracies[durationUnit],
+            })
+                .toObject();
+            const duration = diff[durationUnit];
+            /** Ignore this edge case in coverage cause its for type guarding. */
+            /* c8 ignore next 5 */
+            if (duration == undefined) {
+                throw new Error(`Internal date-vir error: failed to find duration for '${durationUnit}'`);
+            }
+            return [
+                durationUnit,
+                duration,
+            ];
         });
-        const duration = diff[durationUnit];
-        /** Ignore this edge case in coverage cause its for type guarding. */
-        /* c8 ignore next 5 */
-        if (duration == undefined) {
-            throw new Error(`Internal date-vir error: failed to find duration for '${durationUnit}'`);
-        }
-        return [
-            durationUnit,
-            duration,
-        ];
-    });
-    const allDurations = typedObjectFromEntries(allUnitDiffEntries);
-    return allDurations;
+        const equivalentDiff = typedObjectFromEntries(allUnitDiffEntries);
+        return roundDuration(equivalentDiff, decimalCount);
+    }
+    else {
+        throw new Error(`Failed to diff dates: provided diffType is invalid: '${diffType}'`);
+    }
 }
 export function isDateAfter({ relativeTo, fullDate, }) {
-    return (diffDates({ start: relativeTo, end: fullDate, unit: DurationUnit.Milliseconds })
-        .milliseconds >= 0);
+    return (diffDates({
+        start: relativeTo,
+        end: fullDate,
+        unit: DurationUnit.Milliseconds,
+    }).milliseconds >= 0);
 }

package/dist/esm/duration.d.ts

@@ -1,4 +1,5 @@
 import { RequiredAndNotNull } from '@augment-vir/common';
+import { IsUnknown, UnionToIntersection } from 'type-fest';
 export declare enum DurationUnit {
     Years = "years",
     Quarters = "quarters",
@@ -52,4 +53,5 @@ export type AllDurations = RequiredAndNotNull<AnyDuration>;
  * dates, or add offsets to an existing date, or describe a single time duration. Usually only one
  * property is set on this at any given time.
  */
-export type Duration<DurationKeys extends DurationUnit = DurationUnit> = DurationUnit extends DurationKeys ? AnyDuration : Pick<AllDurations, `${DurationKeys}`>;
+export type Duration<DurationKeys extends DurationUnit | unknown> = UnionToIntersection<IsUnknown<DurationKeys> extends true ? AnyDuration : DurationKeys extends DurationUnit ? Pick<AllDurations, `${DurationKeys}`> : never>;
+export declare function roundDuration<InputDuration extends AnyDuration>(duration: Readonly<InputDuration>, decimalCount: number | undefined): InputDuration;

package/dist/esm/duration.js

@@ -1,3 +1,5 @@
+import { mapObjectValues, round } from '@augment-vir/common';
+import { isRunTimeType } from 'run-time-assertions';
 export var DurationUnit;
 (function (DurationUnit) {
     DurationUnit["Years"] = "years";
@@ -36,3 +38,13 @@ export const orderedDurationUnits = [
     DurationUnit.Quarters,
     DurationUnit.Years,
 ];
+export function roundDuration(duration, decimalCount) {
+    return mapObjectValues(duration, (key, value) => {
+        if (decimalCount == undefined || !isRunTimeType(value, 'number')) {
+            return value;
+        }
+        else {
+            return round({ number: value, digits: decimalCount });
+        }
+    });
+}

package/dist/esm/formatting/relative-string.js

@@ -1,5 +1,5 @@
 import { areJsonEqual, mapObjectValues, round } from '@augment-vir/common';
-import { diffDatesAllUnits } from '../date-operations/diff-dates';
+import { DiffType, diffDates } from '../date-operations/diff-dates';
 import { DurationUnit, orderedDurationUnits, singularDurationUnitNames } from '../duration';
 const maxDurations = {
     [DurationUnit.Milliseconds]: 1000,
@@ -14,9 +14,11 @@ const maxDurations = {
 };
 export function toRelativeString({ fullDate, relativeTo, options = {}, }) {
     const roundingDigits = options.decimalDigitCount || 0;
-    const allUnitDiffs = diffDatesAllUnits({
+    const allUnitDiffs = diffDates({
         start: fullDate,
         end: relativeTo,
+        units: orderedDurationUnits,
+        diffType: DiffType.EquivalentUnits,
     });
     const unitsWithinBounds = mapObjectValues(allUnitDiffs, (durationUnit, duration) => {
         const roundedDuration = Math.floor(Math.abs(round({ digits: 1, number: duration })));

package/dist/esm/full-date/create-full-date.js

@@ -1,5 +1,5 @@
-import { isRuntimeTypeOf } from '@augment-vir/common';
 import { DateTime } from 'luxon';
+import { isRunTimeType } from 'run-time-assertions';
 import { userTimezone, utcTimezone } from '../timezone/timezones';
 import { isValidFullDate } from './is-valid-full-date';
 import { parseLuxonDateTime, toLuxonDateTime } from './luxon-date-time-conversion';
@@ -51,10 +51,10 @@ function convertDateLikeToLuxonDateTime(dateLike, timezone) {
     if (DateTime.isDateTime(dateLike)) {
         return dateLike.setZone(timezone);
     }
-    else if (isRuntimeTypeOf(dateLike, 'number')) {
+    else if (isRunTimeType(dateLike, 'number')) {
         return DateTime.fromMillis(dateLike, { zone: utcTimezone }).setZone(timezone);
     }
-    else if (isRuntimeTypeOf(dateLike, 'string')) {
+    else if (isRunTimeType(dateLike, 'string')) {
         const dateTime = DateTime.fromISO(dateLike, { zone: timezone });
         if (!dateTime.isValid) {
             return lastDitchConversion(dateLike);

package/dist/esm/full-date/parsing.js

@@ -1,5 +1,5 @@
-import { isRuntimeTypeOf } from '@augment-vir/common';
 import { DateTime } from 'luxon';
+import { isRunTimeType } from 'run-time-assertions';
 import { createFullDate } from './create-full-date';
 import { parseLuxonDateTime } from './luxon-date-time-conversion';
 /**
@@ -31,7 +31,7 @@ export function parseInputElementValue(elementOrValue, timezone) {
     if (!elementOrValue) {
         return undefined;
     }
-    const value = isRuntimeTypeOf(elementOrValue, 'string')
+    const value = isRunTimeType(elementOrValue, 'string')
         ? elementOrValue
         : elementOrValue.value;
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "date-vir",
-    "version": "4.1.0",
+    "version": "5.0.0",
     "description": "Easy and explicit dates and times",
     "keywords": [
         "date",
@@ -41,45 +41,41 @@
         "test:watch": "web-test-runner --watch --color --config configs/web-test-runner.config.mjs"
     },
     "dependencies": {
-        "@augment-vir/common": "^21.6.0",
-        "@types/luxon": "^3.3.4",
+        "@augment-vir/common": "^22.1.0",
+        "@types/luxon": "^3.3.6",
         "luxon": "^3.4.4",
-        "object-shape-tester": "^1.0.1",
-        "type-fest": "^4.7.1"
+        "object-shape-tester": "^1.0.2",
+        "type-fest": "^4.8.2"
     },
     "devDependencies": {
-        "@augment-vir/browser": "^21.6.0",
-        "@augment-vir/browser-testing": "^21.6.0",
+        "@augment-vir/browser": "^22.1.0",
+        "@augment-vir/browser-testing": "^22.1.0",
         "@open-wc/testing": "^4.0.0",
-        "@types/chai": "^4.3.10",
-        "@types/mocha": "^10.0.4",
-        "@web/dev-server-esbuild": "^1.0.0",
+        "@types/chai": "^4.3.11",
+        "@types/mocha": "^10.0.6",
+        "@web/dev-server-esbuild": "^1.0.1",
         "@web/test-runner": "^0.18.0",
         "@web/test-runner-commands": "^0.9.0",
         "@web/test-runner-playwright": "^0.11.0",
         "@web/test-runner-visual-regression": "^0.9.0",
-        "cspell": "^8.0.0",
-        "dependency-cruiser": "^15.3.0",
-        "element-vir": "^16.5.2",
-        "esbuild": "^0.19.5",
-        "istanbul-smart-text-reporter": "^1.1.2",
-        "markdown-code-example-inserter": "^0.3.2",
+        "cspell": "^8.1.0",
+        "dependency-cruiser": "^15.5.0",
+        "element-vir": "^17.0.3",
+        "esbuild": "^0.19.8",
+        "istanbul-smart-text-reporter": "^1.1.3",
+        "markdown-code-example-inserter": "^0.3.3",
         "npm-check-updates": "~16.12.3",
         "prettier": "^3.1.0",
-        "prettier-plugin-interpolated-html-tags": "^1.0.2",
+        "prettier-plugin-interpolated-html-tags": "^1.0.3",
         "prettier-plugin-jsdoc": "^1.1.1",
-        "prettier-plugin-multiline-arrays": "^3.0.0",
+        "prettier-plugin-multiline-arrays": "^3.0.1",
         "prettier-plugin-organize-imports": "^3.2.4",
         "prettier-plugin-packagejson": "^2.4.6",
         "prettier-plugin-sort-json": "^3.1.0",
-        "prettier-plugin-toml": "^1.0.0",
-        "run-time-assertions": "^0.1.3",
-        "typedoc": "^0.25.3",
-        "typescript": "^5.2.2",
-        "virmator": "^11.1.0"
-    },
-    "overrides": {
-        "@open-wc/scoped-elements": "2.2.3",
-        "@open-wc/testing-helpers": "2.3.1"
+        "prettier-plugin-toml": "^2.0.1",
+        "run-time-assertions": "^0.2.1",
+        "typedoc": "^0.25.4",
+        "typescript": "^5.3.2",
+        "virmator": "^11.1.4"
     }
 }