@amazon/vinyl-util 1.0.0

package/dist/types/current/util/collection/array.js

@@ -0,0 +1,403 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { compare } from '../../util/comparison/compare';
+import { IllegalArgumentError } from '../../error/IllegalArgumentError';
+import { createTaskQueue } from '../../util/async/TaskQueue';
+/**
+ * indexOf on ArrayLike objects.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf
+ */
+export function indexOf(arrayLike, element) {
+    return Array.prototype.indexOf.call(arrayLike, element);
+}
+/**
+ * lastIndexOf on ArrayLike objects.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
+ */
+export function lastIndexOf(arrayLike, element) {
+    return Array.prototype.lastIndexOf.call(arrayLike, element);
+}
+/**
+ * filter on ArrayLike objects.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
+ */
+export function filter(arrayLike, predicate, thisArg) {
+    return Array.prototype.filter.call(arrayLike, predicate, thisArg);
+}
+/**
+ * Filter an ArrayLike with an asynchronous predicate.
+ *
+ * Runs the predicate across all elements, then filters the elements by the booleans
+ * resolved by the predicate.
+ *
+ * @param arrayLike The array-like object to filter
+ * @param predicate Async function that tests each element
+ * @param options Optional configuration object
+ * @param options.simultaneous Maximum number of predicates to run simultaneously (default: 1)
+ */
+export async function filterAsync(arrayLike, predicate, options) {
+    const results = await mapAsync(arrayLike, predicate, options);
+    return filter(await arrayLike, (_, index) => results[index]);
+}
+/**
+ * map on ArrayLike objects.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map
+ */
+export function map(arrayLike, transform, thisArg) {
+    return Array.prototype.map.call(arrayLike, transform, thisArg);
+}
+/**
+ * Map on ArrayLike objects with an asynchronous transformer.
+ *
+ * @param arrayLike The array-like object to transform
+ * @param transform Async function that transforms each element
+ * @param options Optional configuration object
+ * @param options.simultaneous Maximum number of transforms to run simultaneously (default: 1)
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map
+ */
+export async function mapAsync(arrayLike, transform, options) {
+    const resolvedArray = await arrayLike;
+    const { simultaneous = 1 } = options || {};
+    if (simultaneous >= resolvedArray.length) {
+        return Promise.all(map(resolvedArray, transform));
+    }
+    const results = new Array(resolvedArray.length);
+    const queue = createTaskQueue();
+    queue.simultaneous = simultaneous;
+    const tasks = map(resolvedArray, (value, index) => queue.enqueue(() => transform(value, index, resolvedArray).then((result) => {
+        results[index] = result;
+    })));
+    await Promise.all(tasks);
+    return results;
+}
+/**
+ * Determines whether all the members of an array satisfy the specified test.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every
+ */
+export function every(arrayLike, predicate, thisArg) {
+    return Array.prototype.every.call(arrayLike, predicate, thisArg);
+}
+/**
+ * Determines whether any the members of an array satisfy the specified test.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some
+ */
+export function some(arrayLike, predicate, thisArg) {
+    return Array.prototype.some.call(arrayLike, predicate, thisArg);
+}
+/**
+ * Determines whether all the members of an array satisfy the specified asynchronous test.
+ *
+ * @param arrayLike The array-like object to test
+ * @param predicate Async function that tests each element
+ * @param options Optional configuration object
+ * @param options.simultaneous Maximum number of predicates to run simultaneously (default: 1)
+ */
+export async function everyAsync(arrayLike, predicate, options) {
+    const resolvedArray = await arrayLike;
+    const chunks = chunk(resolvedArray, options?.simultaneous ?? 1);
+    let index = 0;
+    for (const chunkArray of chunks) {
+        const chunkPromises = chunkArray.map((value, chunkIndex) => predicate(value, index + chunkIndex, resolvedArray));
+        const chunkResults = await Promise.all(chunkPromises);
+        if (chunkResults.some((result) => !result)) {
+            return false;
+        }
+        index += chunkArray.length;
+    }
+    return true;
+}
+/**
+ * Determines whether any the members of an array satisfy the specified asynchronous test.
+ *
+ * @param arrayLike The array-like object to test
+ * @param predicate Async function that tests each element
+ * @param options Optional configuration object
+ * @param options.simultaneous Maximum number of predicates to run simultaneously (default: 1)
+ */
+export async function someAsync(arrayLike, predicate, options) {
+    return !(await everyAsync(arrayLike, async (value, index, array) => !(await predicate(value, index, array)), options));
+}
+/**
+ * forEach on ArrayLike objects.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach
+ */
+export function forEach(arrayLike, action, thisArg) {
+    return Array.prototype.forEach.call(arrayLike, action, thisArg);
+}
+/**
+ * Executes an asynchronous function on each element in an array.
+ *
+ * @param arrayLike The array-like object to iterate over
+ * @param executor Async function to execute for each element
+ * @param options Optional configuration object
+ * @param options.simultaneous Maximum number of executors to run simultaneously (default: 1)
+ */
+export function forEachAsync(arrayLike, executor, options) {
+    return mapAsync(arrayLike, executor, options).then();
+}
+/**
+ * find on ArrayLike objects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find
+ */
+export function find(arrayLike, predicate, thisArg) {
+    return Array.prototype.find.call(arrayLike, predicate, thisArg);
+}
+/**
+ * findIndex on ArrayLike objects
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex
+ */
+export function findIndex(arrayLike, predicate, thisArg) {
+    return Array.prototype.findIndex.call(arrayLike, predicate, thisArg);
+}
+/**
+ * Returns the first element of an ArrayLike.
+ */
+export function first(arrayLike) {
+    if (!arrayLike)
+        return undefined;
+    return arrayLike[0];
+}
+/**
+ * Returns the last element of an ArrayLike.
+ */
+export function last(arrayLike) {
+    if (!arrayLike)
+        return undefined;
+    return arrayLike[arrayLike.length - 1];
+}
+/**
+ * Returns the first `count` elements of an ArrayLike.
+ * @param arrayLike
+ * @param count
+ */
+export function takeFirst(arrayLike, count) {
+    if (count <= 0)
+        return [];
+    return Array.prototype.slice.call(arrayLike, 0, count);
+}
+/**
+ * Returns the last `count` elements of an ArrayLike.
+ *
+ * @param arrayLike
+ * @param count
+ */
+export function takeLast(arrayLike, count) {
+    if (count <= 0)
+        return [];
+    return Array.prototype.slice.call(arrayLike, -count);
+}
+/**
+ * Returns a subsection of an array-like.
+ * For both start and end, a negative index can be used to indicate an offset from the end of
+ * the array.
+ * For example, -2 refers to the second to last element of the array.
+ *
+ * @param arrayLike An ArrayLike to copy.
+ * @param start The beginning index of the array-like. Default: 0
+ * @param end The end index of the specified portion of the array-like (exclusive). Default: length
+ */
+export function slice(arrayLike, start, end) {
+    return Array.prototype.slice.call(arrayLike, start, end);
+}
+/**
+ * Removes an element from the array, returning true if it was found.
+ */
+export function remove(array, element) {
+    const index = array.indexOf(element);
+    if (index === -1)
+        return false;
+    array.splice(index, 1);
+    return true;
+}
+/**
+ * Removes an element from the array at the given index, returning the removed element if the index
+ * was within range.
+ * @param array The Array to update.
+ * @param index If negative, will remove from the end of the list (-1 is last element), if
+ * greater than or equal to the list length, undefined will be returned.
+ */
+export function removeAt(array, index) {
+    return array.splice(index, 1)[0];
+}
+/**
+ * Returns the index of the first element in the given array with the highest value according to
+ * the comparator.
+ * @param array
+ * @param comparator
+ */
+export function indexOfHighest(array, comparator) {
+    if (array.length === 0)
+        return -1;
+    let highestIndex = 0;
+    let highest = array[highestIndex];
+    for (let i = 1; i < array.length; i++) {
+        const current = array[i];
+        if (comparator(current, highest) > 0) {
+            highest = current;
+            highestIndex = i;
+        }
+    }
+    return highestIndex;
+}
+/**
+ * Returns the index of the last element in the given array with the highest value according to
+ * the comparator.
+ * To find the index of the lowest value, use `util.comparator.reversed`
+ * @param array
+ * @param comparator
+ */
+export function lastIndexOfHighest(array, comparator) {
+    if (array.length === 0)
+        return -1;
+    let highestIndex = array.length - 1;
+    let highest = array[highestIndex];
+    for (let i = array.length - 2; i >= 0; i--) {
+        const current = array[i];
+        if (comparator(current, highest) > 0) {
+            highest = current;
+            highestIndex = i;
+        }
+    }
+    return highestIndex;
+}
+/**
+ * Given an array using the given comparator function, finds the insertion index of an element.
+ *
+ * @param array An array sorted using the comparator.
+ * @param element The element to compare against array elements.
+ * @param comparator A function where given the return value of `comparator(element, array[i])`
+ * if less than zero the returned index will be before i, otherwise after.
+ * @param start The starting index (inclusive). Default: 0
+ * @param end The ending index (exclusive). Default: array.length
+ */
+export function sortedInsertionIndex(array, element, comparator, start = 0, end = array.length) {
+    let indexA = start;
+    let indexB = end;
+    while (indexA < indexB) {
+        const midIndex = (indexA + indexB) >>> 1;
+        const comparison = comparator(element, array[midIndex]);
+        if (comparison < 0) {
+            indexB = midIndex;
+        }
+        else {
+            indexA = midIndex + 1;
+        }
+    }
+    return indexA;
+}
+/**
+ * Creates an iterator for an ArrayLike.
+ * If the given ArrayLike is iterable, then use its provided iterator.
+ *
+ * @param arrayLike
+ */
+export function createArrayLikeIterator(arrayLike) {
+    if (Symbol.iterator in arrayLike)
+        return arrayLike[Symbol.iterator]();
+    let currentIndex = 0;
+    return {
+        [Symbol.iterator]() {
+            return createArrayLikeIterator(arrayLike);
+        },
+        next: () => {
+            if (currentIndex >= arrayLike.length) {
+                return {
+                    value: undefined,
+                    done: true,
+                };
+            }
+            return {
+                value: arrayLike[currentIndex++],
+                done: false,
+            };
+        },
+    };
+}
+/**
+ * Gets the element in the ArrayLike at the given index, or throws an IllegalArgumentError if out of range.
+ */
+export function getElementAt(array, index) {
+    const n = array.length;
+    if (index >= 0 && index < n) {
+        return array[index];
+    }
+    throw new IllegalArgumentError(`index ${index} is out of range 0-${n}`);
+}
+/**
+ * Gets the element in the ArrayLike at the given index, or returns the provided default value.
+ */
+export function getElementOrDefault(array, index, defaultValue) {
+    const n = array.length;
+    if (index >= 0 && index < n) {
+        return array[index];
+    }
+    return defaultValue;
+}
+/**
+ * Counts the number of elements in an array that return true when passed to a predicate function.
+ *
+ * @param array
+ * @param predicate
+ */
+export function countElements(array, predicate) {
+    let count = 0;
+    const n = array.length;
+    for (let i = 0; i < n; i++) {
+        if (predicate(array[i], i, array)) {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Splits an array into chunks of the specified size.
+ *
+ * @param array The array to chunk
+ * @param chunkSize Maximum size of each chunk
+ * @returns Array of chunks
+ */
+export function chunk(array, chunkSize) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += chunkSize) {
+        chunks.push(slice(array, i, i + chunkSize));
+    }
+    return chunks;
+}
+/**
+ * Finds the minimum value in an array of comparable elements.
+ * @param arrayLike The array-like object to search
+ * @param comparator Optional comparator function
+ */
+export function min(arrayLike, comparator) {
+    if (arrayLike.length === 0)
+        return undefined;
+    let minValue = arrayLike[0];
+    if (!comparator)
+        comparator = compare;
+    for (let i = 1; i < arrayLike.length; i++) {
+        if (comparator(arrayLike[i], minValue) < 0) {
+            minValue = arrayLike[i];
+        }
+    }
+    return minValue;
+}
+/**
+ * Finds the maximum value in an array of comparable elements.
+ * @param arrayLike The array-like object to search
+ * @param comparator Optional comparator function
+ */
+export function max(arrayLike, comparator) {
+    if (arrayLike.length === 0)
+        return undefined;
+    let maxValue = arrayLike[0];
+    if (!comparator)
+        comparator = compare;
+    for (let i = 1; i < arrayLike.length; i++) {
+        if (comparator(arrayLike[i], maxValue) > 0) {
+            maxValue = arrayLike[i];
+        }
+    }
+    return maxValue;
+}

package/dist/types/current/util/collection/typedArray.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Array views of a data buffer.
+ */
+export type TypedArray = Float32Array | Float64Array | Int16Array | Int32Array | Int8Array | Uint16Array | Uint32Array | Uint8Array | Uint8ClampedArray;
+/**
+ * Creates a new typed array with identical contents as the source.
+ *
+ * @param array
+ */
+export declare function cloneTypedArray<T extends TypedArray>(array: T): T;
+/**
+ * Returns true if the given value is an instance of one of the typed array types.
+ *
+ * @param value
+ */
+export declare function isTypedArray(value: any): value is TypedArray;
+//# sourceMappingURL=typedArray.d.ts.map

package/dist/types/current/util/collection/typedArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedArray.d.ts","sourceRoot":"","sources":["../../../../../src/util/collection/typedArray.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,MAAM,UAAU,GAChB,YAAY,GACZ,YAAY,GACZ,UAAU,GACV,UAAU,GACV,SAAS,GACT,WAAW,GACX,WAAW,GACX,UAAU,GACV,iBAAiB,CAAA;AAEvB;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,UAAU,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAGjE;AAcD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,UAAU,CAE5D"}

package/dist/types/current/util/collection/typedArray.js

@@ -0,0 +1,32 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Creates a new typed array with identical contents as the source.
+ *
+ * @param array
+ */
+export function cloneTypedArray(array) {
+    // typed array slice() is not supported on Comcast OTT device.
+    return new array.constructor(array);
+}
+const typedArrayTypes = [
+    Float32Array,
+    Float64Array,
+    Int16Array,
+    Int32Array,
+    Int8Array,
+    Uint16Array,
+    Uint32Array,
+    Uint8Array,
+    Uint8ClampedArray,
+];
+/**
+ * Returns true if the given value is an instance of one of the typed array types.
+ *
+ * @param value
+ */
+export function isTypedArray(value) {
+    return typedArrayTypes.some((type) => value instanceof type);
+}

package/dist/types/current/util/comparison/compare.d.ts

@@ -0,0 +1,33 @@
+import type { Maybe, Primitive } from '../../util/type';
+/**
+ * A function that can be used as a comparator for sorting.
+ * Return > 0 if `a` is greater than `b`
+ * Return = 0 if `a` equals `b`
+ * Return < 0 if `a` is less than `b
+ */
+export type Comparator<A, B = A> = (a: A, b: B) => number;
+/**
+ * Provides a primitive value plucked from an element. Used in {@link compareBy} for building a comparator.
+ */
+export type CompareBySelector<T> = (value: T) => Exclude<Primitive, symbol>;
+/**
+ * Creates a comparator for objects of type T by using a selector to pick a primitive value.
+ *
+ * @param selectors
+ */
+export declare function compareBy<T>(...selectors: CompareBySelector<T>[]): Comparator<Maybe<T>>;
+/**
+ * Reverses the order of a comparator.
+ *
+ * @param comparator
+ */
+export declare function reversed<A, B>(comparator: Comparator<A, B>): Comparator<A, B>;
+/**
+ * Compares two primitive values.
+ *
+ * Return 1 if `a` is greater than `b`
+ * Return 0 if `a` equals `b`
+ * Return -1 if `a` is less than `b
+ */
+export declare function compare<T extends Exclude<Primitive, symbol>>(a: T | null, b: T | null): number;
+//# sourceMappingURL=compare.d.ts.map

package/dist/types/current/util/comparison/compare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare.d.ts","sourceRoot":"","sources":["../../../../../src/util/comparison/compare.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAA;AAEzD;;GAEG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;AAE3E;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EACvB,GAAG,SAAS,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,GACrC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAWtB;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAE7E;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,OAAO,CAAC,SAAS,EAAE,MAAM,CAAC,EACxD,CAAC,EAAE,CAAC,GAAG,IAAI,EACX,CAAC,EAAE,CAAC,GAAG,IAAI,GACZ,MAAM,CAOR"}

package/dist/types/current/util/comparison/compare.js

@@ -0,0 +1,53 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Creates a comparator for objects of type T by using a selector to pick a primitive value.
+ *
+ * @param selectors
+ */
+export function compareBy(...selectors) {
+    return (a, b) => {
+        if (a == null && b == null)
+            return 0;
+        if (a == null)
+            return -1;
+        if (b == null)
+            return 1;
+        for (const selector of selectors) {
+            const comparison = compare(selector(a), selector(b));
+            if (comparison !== 0)
+                return comparison;
+        }
+        return 0;
+    };
+}
+/**
+ * Reverses the order of a comparator.
+ *
+ * @param comparator
+ */
+export function reversed(comparator) {
+    return (a, b) => -comparator(a, b);
+}
+/**
+ * Compares two primitive values.
+ *
+ * Return 1 if `a` is greater than `b`
+ * Return 0 if `a` equals `b`
+ * Return -1 if `a` is less than `b
+ */
+export function compare(a, b) {
+    if (a == null && b == null)
+        return 0;
+    if (a == null)
+        return -1;
+    if (b == null)
+        return 1;
+    if (a > b)
+        return 1;
+    if (a < b)
+        return -1;
+    return 0;
+}

package/dist/types/current/util/config/ValueProvider.d.ts

@@ -0,0 +1,17 @@
+import type { MaybePromise } from '../../util/type';
+/**
+ * A value of type T, a function returning T, or an async function returning a Promise<T>.
+ * To be used with `resolveValueProvider`.
+ */
+export type ValueProvider<T> = T | (() => MaybePromise<T>);
+/**
+ * Resolves a ValueProvider to its underlying value.
+ *
+ * Handles all three ValueProvider forms: direct values, synchronous functions,
+ * and async functions, returning a Promise that resolves to the value.
+ *
+ * @param valueProvider - The value, function, or async function to resolve
+ * @returns A Promise resolving to the provided value of type T
+ */
+export declare function resolveValueProvider<T>(valueProvider: ValueProvider<T>): Promise<T>;
+//# sourceMappingURL=ValueProvider.d.ts.map

package/dist/types/current/util/config/ValueProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValueProvider.d.ts","sourceRoot":"","sources":["../../../../../src/util/config/ValueProvider.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C;;;GAGG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;AAE1D;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAClC,aAAa,EAAE,aAAa,CAAC,CAAC,CAAC,GAChC,OAAO,CAAC,CAAC,CAAC,CAMZ"}

package/dist/types/current/util/config/ValueProvider.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Resolves a ValueProvider to its underlying value.
+ *
+ * Handles all three ValueProvider forms: direct values, synchronous functions,
+ * and async functions, returning a Promise that resolves to the value.
+ *
+ * @param valueProvider - The value, function, or async function to resolve
+ * @returns A Promise resolving to the provided value of type T
+ */
+export function resolveValueProvider(valueProvider) {
+    return Promise.resolve(typeof valueProvider === 'function'
+        ? valueProvider()
+        : valueProvider);
+}

package/dist/types/current/util/date/date.d.ts

@@ -0,0 +1,32 @@
+import type { ReadonlyDate } from '../../util/object/readonlyType';
+/**
+ * Returns the signed time difference of end - start, in seconds.
+ *
+ * @param start The beginning date
+ * @param end The later date
+ */
+export declare function timeDelta(start: ReadonlyDate, end: ReadonlyDate): number;
+/**
+ * A type alias to clarify that a number represents a unix timestamp
+ * (milliseconds from 1970-1-1 00:00).
+ */
+export type Timestamp = number;
+/**
+ * Parses a string into a unix Timestamp using `Date.parse`, if the date is invalid, throws a
+ * `ValidationError`
+ * @param str
+ */
+export declare function parseTimestamp(str: string): Timestamp;
+/**
+ * Parses a string into a date using `Date.parse`, if the date is invalid, throws a
+ * `ValidationError`
+ * @param str
+ */
+export declare function parseDate(str: string): Date;
+/**
+ * Returns the iso 8601 string representation of a `Date` value.
+ *
+ * @param value
+ */
+export declare function stringifyDate(value: ReadonlyDate): string;
+//# sourceMappingURL=date.d.ts.map

package/dist/types/current/util/date/date.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.d.ts","sourceRoot":"","sources":["../../../../../src/util/date/date.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAW9D;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,YAAY,EAAE,GAAG,EAAE,YAAY,GAAG,MAAM,CAExE;AAED;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAA;AAE9B;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAQrD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAE3C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAEzD"}

package/dist/types/current/util/date/date.js

@@ -0,0 +1,49 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorOrigin } from '../../error/ErrorOrigin';
+import { substitute } from '../../util/string/string';
+import { ValidationError } from '../../error/ValidationError';
+/**
+ * @private
+ */
+const locale = {
+    invalidDateError: `"{value}" is an invalid date`,
+};
+/**
+ * Returns the signed time difference of end - start, in seconds.
+ *
+ * @param start The beginning date
+ * @param end The later date
+ */
+export function timeDelta(start, end) {
+    return (end.getTime() - start.getTime()) / 1000;
+}
+/**
+ * Parses a string into a unix Timestamp using `Date.parse`, if the date is invalid, throws a
+ * `ValidationError`
+ * @param str
+ */
+export function parseTimestamp(str) {
+    const timestamp = Date.parse(str);
+    if (Number.isNaN(timestamp))
+        throw new ValidationError(substitute(locale.invalidDateError, { value: str }), ErrorOrigin.PARSING);
+    return timestamp;
+}
+/**
+ * Parses a string into a date using `Date.parse`, if the date is invalid, throws a
+ * `ValidationError`
+ * @param str
+ */
+export function parseDate(str) {
+    return new Date(parseTimestamp(str));
+}
+/**
+ * Returns the iso 8601 string representation of a `Date` value.
+ *
+ * @param value
+ */
+export function stringifyDate(value) {
+    return value.toISOString();
+}