date-vir 0.0.0 → 0.1.0

package/LICENSE-CC0

@@ -0,0 +1,121 @@
+CC0 1.0 Universal
+
+Creative Commons Legal Code
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 electrovir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,148 @@
+# date-vir
+
+Easy dates and times with explicit timezones (and typed timezones).
+
+`date-vir` revolves around the new `FullDate` type, which includes all the information you need to correctly pinpoint _and_ format a given point in time. Most notably, `FullDate` always includes a `timezone` property, so you _always_ know what timezone the date was originally defined in, or what timezone the date is intended to be used in:
+
+<!-- example-link: src/readme-examples/full-date.example.ts -->
+
+```TypeScript
+import {FullDate, timezones} from 'date-vir';
+
+const myDate: FullDate = {
+    year: 2023,
+    month: 6,
+    day: 5,
+
+    hour: 5,
+    minute: 23,
+    second: 27,
+    millisecond: 652,
+
+    timezone: timezones.UTC,
+};
+```
+
+# Creating a FullDate
+
+Several functions are available for creating `FullDate` objects, with `createFullDate` being the most commonly used:
+
+<!-- example-link: src/readme-examples/full-date-creation.example.ts -->
+
+```TypeScript
+import {
+    createFullDate,
+    getNowFullDate,
+    parseInputElementValue,
+    parseStrangeString,
+    timezones,
+} from 'date-vir';
+
+/**
+ * Creates a FullDate from a wide range of possible inputs. See TypeScript types for full details on
+ * available inputs.
+ */
+createFullDate('2023-06-05', timezones['Europe/Rome']);
+
+/** Get the current date and time right now in the given timezone. */
+getNowFullDate(timezones['America/Argentina/Buenos_Aires']);
+
+/**
+ * Parsed the value of an <input> element directly from the element itself. This is intended to be
+ * used for type="date" or type="time" <input> elements, but any input element with a valid date or
+ * time string will work.
+ */
+parseInputElementValue(document.querySelector('input'), timezones['Asia/Tokyo']);
+
+/**
+ * If you have a really oddly formatted date/time string and createFullDate does not suffice, you
+ * can have full parsing control using this function. Luxon is used under the hood for this parsing,
+ * so you can see all the formatString options in its docs:
+ * https://moment.github.io/luxon/#/parsing?id=table-of-tokens
+ */
+parseStrangeString({
+    dateString: '870-0-14-19 5 2023 6',
+    formatString: 'S-s-h-m d yyyy M',
+    timezone: timezones['America/Cancun'],
+});
+```
+
+# Outputs
+
+`FullDate` objects are easily converted into other formats (usually strings) with the included functions:
+
+<!-- example-link: src/readme-examples/full-date-conversions.example.ts -->
+
+```TypeScript
+import {
+    HtmlInputElementTypeEnum,
+    createFullDate,
+    formatPresets,
+    timezones,
+    toHtmlInputString,
+    toIsoString,
+    toLocaleString,
+    toTimestamp,
+} from 'date-vir';
+
+const myFullDate = createFullDate('2023-06-05T14:19:00.870Z', timezones['America/Chicago']);
+
+/**
+ * Converts the given FullDate into a UTC unix timestamp with milliseconds. Since the output is a
+ * UTC timestamp, the number will be the same even if you convert your FullDate to a different time
+ * zone.
+ */
+toTimestamp(myFullDate); // returns 1685974740870
+
+/**
+ * Converts the given FullDate into a UTC ISO string. Since the output is in UTC, even if your
+ * FullDate object is shifted to a different timezone, the output of this function will be the
+ * same.
+ */
+toIsoString(myFullDate); // returns '2023-06-05T14:19:00.870Z'
+
+/**
+ * Converts the given FullDate to a locale-based formatted string. The second argument, the options
+ * argument, is optional and contains many options therein.
+ */
+toLocaleString(myFullDate, formatPresets.DatetimeFull); // returns 'June 5, 2023 at 9:19 AM CDT' in the en-us locale
+
+/**
+ * Formats the given FullDate to a string so that it is ready to be assigned to the value attribute
+ * of an <input type="date" /> element.
+ */
+toHtmlInputString(myFullDate, HtmlInputElementTypeEnum.Date); // returns '2023-06-05'
+```
+
+# Timezone
+
+`date-vir` exposes a type-safe list of timezone names, including shortcuts for the user's timezone and the UTC timezone:
+
+<!-- example-link: src/readme-examples/timezones.example.ts -->
+
+```TypeScript
+import {timezones, userTimezone, utcTimezone} from 'date-vir';
+
+timezones['Africa/Abidjan'];
+timezones['America/Los_Angeles'];
+timezones['Etc/GMT+1'];
+
+utcTimezone;
+userTimezone;
+```
+
+Note that the current list of timezone names included in this package was generated from Firefox 106.0.2.
+
+# Luxon
+
+The parsing and timezone conversions in `date-vir` utilize the [`luxon`](https://www.npmjs.com/luxon) package under the hood. If you wish to gain full `luxon` control over a `FullDate` object, `date-vir` provides an easy conversion function:
+
+<!-- example-link: src/readme-examples/luxon-conversion.example.ts -->
+
+```TypeScript
+import {createFullDate, timezones, toLuxonDateTime} from 'date-vir';
+
+const myFullDate = createFullDate('2023-06-05T14:19:00.870Z', timezones['America/Chicago']);
+
+toLuxonDateTime(myFullDate);
+```

package/dist/cjs/full-date/calculate-relative-date.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateRelativeDate = void 0;
+const luxon_date_time_conversion_1 = require("./luxon-date-time-conversion");
+function calculateRelativeDate(fullDate, relativeCalculation) {
+    return (0, luxon_date_time_conversion_1.parseLuxonDateTime)((0, luxon_date_time_conversion_1.toLuxonDateTime)(fullDate).plus(relativeCalculation));
+}
+exports.calculateRelativeDate = calculateRelativeDate;

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

@@ -0,0 +1,67 @@
+"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 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");
+function createFullDateInUserTimezone(dateLike) {
+    return createFullDate(dateLike, timezones_1.userTimezone);
+}
+exports.createFullDateInUserTimezone = createFullDateInUserTimezone;
+function createUtcFullDate(dateLike) {
+    return createFullDate(dateLike, timezones_1.utcTimezone);
+}
+exports.createUtcFullDate = createUtcFullDate;
+/**
+ * Parses the given dateLike and then reads the fullDate properties from that parsed value as if it
+ * were in the given timezone.
+ */
+function createFullDate(
+/** The original date representation to be converted into a FullDate. */
+dateLike, 
+/** The timezone that this date/time is meant for / originated from. */
+timezone) {
+    const dateTime = convertDateLikeToLuxonDateTime(dateLike, timezone);
+    if (!dateTime || !dateTime.isValid) {
+        throw new Error(`Failed to parse date input '${dateLike}'`);
+    }
+    return (0, luxon_date_time_conversion_1.parseLuxonDateTime)(dateTime);
+}
+exports.createFullDate = createFullDate;
+/**
+ * Creates and returns a new FullDate object with its values shifted to be the same original time
+ * but represented in a new timezone.
+ */
+function toNewTimezone(fullDate, timezone) {
+    return createFullDate(fullDate, timezone);
+}
+exports.toNewTimezone = toNewTimezone;
+function convertDateLikeToLuxonDateTime(dateLike, timezone) {
+    if ((0, is_valid_full_date_1.isValidFullDate)(dateLike)) {
+        dateLike = (0, luxon_date_time_conversion_1.toLuxonDateTime)(dateLike).toMillis();
+    }
+    if (luxon_1.DateTime.isDateTime(dateLike)) {
+        return dateLike.setZone(timezone);
+    }
+    else if ((0, common_1.isRuntimeTypeOf)(dateLike, 'number')) {
+        return luxon_1.DateTime.fromMillis(dateLike, { zone: timezones_1.utcTimezone }).setZone(timezone);
+    }
+    else if ((0, common_1.isRuntimeTypeOf)(dateLike, 'string')) {
+        const dateTime = luxon_1.DateTime.fromISO(dateLike, { zone: timezone });
+        if (!dateTime.isValid) {
+            throw new Error(`Failed to parse date string '${dateLike}': unexpected string format. Please use parseStringToFullDate instead to have more control over the parsing format.`);
+        }
+        return dateTime;
+    }
+    else if (dateLike instanceof Date) {
+        const dateTime = luxon_1.DateTime.fromJSDate(dateLike);
+        return dateTime.setZone(timezone);
+    }
+    return undefined;
+}
+function getNowFullDate(timezone) {
+    return createFullDate(Date.now(), timezone);
+}
+exports.getNowFullDate = getNowFullDate;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/full-date/format-presets.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPresets = void 0;
+const luxon_1 = require("luxon");
+/**
+ * Format preset re-exported from luxon to be used with toLocaleString. To see examples of all
+ * presets, go here: https://moment.github.io/luxon/#/formatting?id=presets
+ */
+exports.formatPresets = {
+    DateShort: luxon_1.DateTime.DATE_SHORT,
+    DateMed: luxon_1.DateTime.DATE_MED,
+    DateMedWithWeekday: luxon_1.DateTime.DATE_MED_WITH_WEEKDAY,
+    DateFull: luxon_1.DateTime.DATE_FULL,
+    DateHuge: luxon_1.DateTime.DATE_HUGE,
+    TimeSimple: luxon_1.DateTime.TIME_SIMPLE,
+    TimeWithSeconds: luxon_1.DateTime.TIME_WITH_SECONDS,
+    TimeWithShortOffset: luxon_1.DateTime.TIME_WITH_SHORT_OFFSET,
+    TimeWithLongOffset: luxon_1.DateTime.TIME_WITH_LONG_OFFSET,
+    Time24Simple: luxon_1.DateTime.TIME_24_SIMPLE,
+    Time24WithSeconds: luxon_1.DateTime.TIME_24_WITH_SECONDS,
+    Time24WithShortOffset: luxon_1.DateTime.TIME_24_WITH_SHORT_OFFSET,
+    Time24WithLongOffset: luxon_1.DateTime.TIME_24_WITH_LONG_OFFSET,
+    DatetimeShort: luxon_1.DateTime.DATETIME_SHORT,
+    DatetimeShortWithSeconds: luxon_1.DateTime.DATETIME_SHORT_WITH_SECONDS,
+    DatetimeMed: luxon_1.DateTime.DATETIME_MED,
+    DatetimeMedWithSeconds: luxon_1.DateTime.DATETIME_MED_WITH_SECONDS,
+    DatetimeMedWithWeekday: luxon_1.DateTime.DATETIME_MED_WITH_WEEKDAY,
+    DatetimeFull: luxon_1.DateTime.DATETIME_FULL,
+    DatetimeFullWithSeconds: luxon_1.DateTime.DATETIME_FULL_WITH_SECONDS,
+    DatetimeHuge: luxon_1.DateTime.DATETIME_HUGE,
+    DatetimeHugeWithSeconds: luxon_1.DateTime.DATETIME_HUGE_WITH_SECONDS,
+};

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullDateShape = exports.dateOnlyShape = exports.timeOnlyShape = void 0;
+const object_shape_tester_1 = require("object-shape-tester");
+const timezones_1 = require("../timezone/timezones");
+exports.timeOnlyShape = (0, object_shape_tester_1.defineShape)({
+    /** Hour of the day in 24 time: 0-23 */
+    hour: 14,
+    /** Minute of the hour: 0-59 */
+    minute: 19,
+    /** Second of the minute: 0-59 */
+    second: 0,
+    /** Millisecond of the second: 0-999 */
+    millisecond: 870,
+    /** The timezone that this date/time is meant for / originated from. */
+    timezone: timezones_1.utcTimezone,
+});
+exports.dateOnlyShape = (0, object_shape_tester_1.defineShape)({
+    /**
+     * The full, four digit year.
+     *
+     * @example
+     *     2023;
+     */
+    year: 2023,
+    /** A month of the year: 1-12 */
+    month: 6,
+    /** A day of the month: 1-31 depending on the month */
+    day: 5,
+    /** The timezone that this date/time is meant for / originated from. */
+    timezone: timezones_1.utcTimezone,
+});
+exports.fullDateShape = (0, object_shape_tester_1.defineShape)((0, object_shape_tester_1.and)(exports.dateOnlyShape, exports.timeOnlyShape));

package/dist/cjs/full-date/is-valid-full-date.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidFullDate = exports.assertIsValidFullDate = void 0;
+const object_shape_tester_1 = require("object-shape-tester");
+const timezone_checks_1 = require("../timezone/timezone-checks");
+const full_date_shape_1 = require("./full-date-shape");
+const luxon_date_time_conversion_1 = require("./luxon-date-time-conversion");
+function assertIsValidFullDate(input) {
+    (0, object_shape_tester_1.assertValidShape)(input, full_date_shape_1.fullDateShape);
+    (0, timezone_checks_1.assertValidTimezone)(input.timezone);
+    /** Check that the input can be converted to a luxon date correctly. */
+    (0, luxon_date_time_conversion_1.toLuxonDateTime)(input);
+}
+exports.assertIsValidFullDate = assertIsValidFullDate;
+function isValidFullDate(input) {
+    try {
+        assertIsValidFullDate(input);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.isValidFullDate = isValidFullDate;

package/dist/cjs/full-date/luxon-date-time-conversion.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLuxonDateTime = exports.toLuxonDateTime = void 0;
+const common_1 = require("@augment-vir/common");
+const luxon_1 = require("luxon");
+/**
+ * Converts a FullDate object into a Luxon DateTime library. This is only needed if you need complex
+ * operations on dates. It does, however, internally power a lot of the date-vir functionality as it
+ * uses the Luxon library for conversions between timezones.
+ */
+function toLuxonDateTime(fullDateInput) {
+    const dateTime = luxon_1.DateTime.fromObject((0, common_1.omitObjectKeys)(fullDateInput, ['timezone']), {
+        zone: fullDateInput.timezone,
+    });
+    /** Ignore this edge case in coverage cause idk how to trigger it. */
+    /* c8 ignore next 3 */
+    if (!dateTime.isValid) {
+        throw new Error(dateTime.invalidExplanation ?? undefined);
+    }
+    return dateTime;
+}
+exports.toLuxonDateTime = toLuxonDateTime;
+/**
+ * Convert a Luxon DateTime object into a DateTime object. Used internally inside of date-vir, but
+ * could be helpful if you need it. Usually you should prefer using the createFullDate function
+ * instead.
+ */
+function parseLuxonDateTime(dateTimeInput) {
+    if (!dateTimeInput.isValid) {
+        throw new Error(`Invalid input: '${dateTimeInput.toISO()}'`);
+    }
+    return {
+        day: dateTimeInput.day,
+        month: dateTimeInput.month,
+        year: dateTimeInput.year,
+        hour: dateTimeInput.hour,
+        minute: dateTimeInput.minute,
+        second: dateTimeInput.second,
+        millisecond: dateTimeInput.millisecond,
+        timezone: dateTimeInput.zoneName,
+    };
+}
+exports.parseLuxonDateTime = parseLuxonDateTime;

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

@@ -0,0 +1,43 @@
+"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 create_full_date_1 = require("./create-full-date");
+const luxon_date_time_conversion_1 = require("./luxon-date-time-conversion");
+/**
+ * Parses any strangely formatted dateString using the given formatString and timezone.
+ *
+ * This is much more flexible than createFullDate but createFullDate should be preferred in
+ * situations where it works.
+ *
+ * The formatString input is passed to Luxon. All format options are listed here:
+ * https://moment.github.io/luxon/#/parsing?id=table-of-tokens
+ */
+function parseStrangeString({ dateString, formatString, timezone, }) {
+    try {
+        const dateTime = luxon_1.DateTime.fromFormat(dateString, formatString, {
+            zone: timezone,
+            setZone: true,
+        });
+        return (0, luxon_date_time_conversion_1.parseLuxonDateTime)(dateTime);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse string '${dateString}' with format '${formatString}'`);
+    }
+}
+exports.parseStrangeString = parseStrangeString;
+/**
+ * Read either an HTMLInputElement's value directly, or the value string retrieved from an
+ * HTMLInputElement. Handles both type="date" and type="time" <input> elements.
+ */
+function parseInputElementValue(elementOrValue, timezone) {
+    if (!elementOrValue) {
+        throw new Error('Cannot parse an empty element.');
+    }
+    const value = (0, common_1.isRuntimeTypeOf)(elementOrValue, 'string')
+        ? elementOrValue
+        : elementOrValue.value;
+    return (0, create_full_date_1.createFullDate)(value, timezone);
+}
+exports.parseInputElementValue = parseInputElementValue;

package/dist/cjs/full-date/primitive-conversions.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHtmlInputString = exports.HtmlInputElementTypeEnum = exports.toFormattedString = exports.toLocaleString = exports.toIsoString = exports.toTimestamp = void 0;
+const common_1 = require("@augment-vir/common");
+const locales_1 = require("../locales");
+const timezones_1 = require("../timezone/timezones");
+const luxon_date_time_conversion_1 = require("./luxon-date-time-conversion");
+/** Convert a FullDate into a unix timestamp with milliseconds. */
+function toTimestamp(fullDate) {
+    return (0, luxon_date_time_conversion_1.toLuxonDateTime)(fullDate).toMillis();
+}
+exports.toTimestamp = toTimestamp;
+/** Convert a FullDate into an ISO string in UTC; always ends in Z. */
+function toIsoString(fullDate) {
+    const isoString = (0, luxon_date_time_conversion_1.toLuxonDateTime)(fullDate).setZone(timezones_1.utcTimezone).toISO();
+    /** Ignore this edge case in the types and idk how to trigger it. */
+    /* c8 ignore next 3 */
+    if (!isoString) {
+        throw new Error(`Unable to get ISO string for '${JSON.stringify(fullDate)}'`);
+    }
+    return isoString;
+}
+exports.toIsoString = toIsoString;
+/** Converts the given FullDate into a string in the user's locale, or the given localeOverride. */
+function toLocaleString(fullDate, formatOptions) {
+    return (0, luxon_date_time_conversion_1.toLuxonDateTime)(fullDate).toLocaleString({
+        ...formatOptions,
+    }, {
+        locale: formatOptions?.locale ?? locales_1.userLocale,
+    });
+}
+exports.toLocaleString = toLocaleString;
+/**
+ * Provides arbitrary date formatting using Luxon. For full details on the options for the format
+ * string input, see https://moment.github.io/luxon/#/formatting?id=table-of-tokens
+ *
+ * You probably should **prefer toLocaleString** so your users see the format they expect. It
+ * already has many formatting options.
+ */
+function toFormattedString(fullDate, format, localeOverride = locales_1.userLocale) {
+    return (0, luxon_date_time_conversion_1.toLuxonDateTime)(fullDate).toFormat(format, { locale: localeOverride });
+}
+exports.toFormattedString = toFormattedString;
+/**
+ * The different options for the "type" attribute in an <input> element that require specific
+ * formatting relevant to dates.
+ */
+var HtmlInputElementTypeEnum;
+(function (HtmlInputElementTypeEnum) {
+    HtmlInputElementTypeEnum["Date"] = "date";
+    HtmlInputElementTypeEnum["Time"] = "time";
+})(HtmlInputElementTypeEnum = exports.HtmlInputElementTypeEnum || (exports.HtmlInputElementTypeEnum = {}));
+function toHtmlInputString(fullDate, inputType, includeSeconds) {
+    if (inputType === HtmlInputElementTypeEnum.Date) {
+        const dateParts = [
+            fullDate.year,
+            String(fullDate.month).padStart(2, '0'),
+            String(fullDate.day).padStart(2, '0'),
+        ];
+        return dateParts.join('-');
+    }
+    else if (inputType === HtmlInputElementTypeEnum.Time) {
+        const timeParts = [
+            String(fullDate.hour).padStart(2, '0'),
+            String(fullDate.minute).padStart(2, '0'),
+            includeSeconds ? String(fullDate.second).padStart(2, '0') : undefined,
+        ].filter((entry) => entry != undefined);
+        return timeParts.join(':');
+    }
+    else {
+        throw new Error(`Unexpected inputTyped: '${inputType}'. Expected usage of HtmlInputElementTypeEnum or one of ${(0, common_1.getEnumTypedValues)(HtmlInputElementTypeEnum).join(', ')}.`);
+    }
+}
+exports.toHtmlInputString = toHtmlInputString;

package/dist/cjs/full-date/string-format-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./full-date/create-full-date"), exports);
+__exportStar(require("./full-date/date-like"), exports);
+__exportStar(require("./full-date/format-presets"), exports);
+__exportStar(require("./full-date/full-date-shape"), exports);
+__exportStar(require("./full-date/is-valid-full-date"), exports);
+__exportStar(require("./full-date/luxon-date-time-conversion"), exports);
+__exportStar(require("./full-date/parsing"), exports);
+__exportStar(require("./full-date/primitive-conversions"), exports);
+__exportStar(require("./full-date/string-format-types"), exports);
+__exportStar(require("./locales"), exports);
+__exportStar(require("./timezone/timezone-checks"), exports);
+__exportStar(require("./timezone/timezone-names"), exports);
+__exportStar(require("./timezone/timezones"), exports);

package/dist/cjs/locales.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userLocale = void 0;
+const luxon_1 = require("luxon");
+exports.userLocale = luxon_1.Settings.defaultLocale;