complete-common 1.0.0 → 1.0.1

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright The Complete Contributors
+Copyright (c) 2024 The Complete Contributors
 
 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:
 

package/README.md

@@ -1,7 +1,7 @@
-# complete-common
+# `complete-common`
 
 [![npm version](https://img.shields.io/npm/v/complete-common.svg)](https://www.npmjs.com/package/complete-common)
 
-This package contains helper functions for a typical TypeScript project, such as [`iRange`](TODO).
+This package contains helper functions for a typical [TypeScript](https://www.typescriptlang.org/) project, such as [`iRange`](/complete-common/functions/utils#irange).
 
-For more information about `complete`, see the [official website](https://complete-ts.github.io/).
+Please see the [docs](https://complete-ts.github.io/complete-common) for more information.

package/dist/constants.d.cts

@@ -0,0 +1,7 @@
+/** Equal to 1000. */
+export declare const SECOND_IN_MILLISECONDS = 1000;
+/** Equal to 60,000. */
+export declare const MINUTE_IN_MILLISECONDS: number;
+/** Equal to 3,600,000. */
+export declare const HOUR_IN_MILLISECONDS: number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.mts

@@ -0,0 +1,7 @@
+/** Equal to 1000. */
+export declare const SECOND_IN_MILLISECONDS = 1000;
+/** Equal to 60,000. */
+export declare const MINUTE_IN_MILLISECONDS: number;
+/** Equal to 3,600,000. */
+export declare const HOUR_IN_MILLISECONDS: number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts

@@ -0,0 +1,7 @@
+/** Equal to 1000. */
+export declare const SECOND_IN_MILLISECONDS = 1000;
+/** Equal to 60,000. */
+export declare const MINUTE_IN_MILLISECONDS: number;
+/** Equal to 3,600,000. */
+export declare const HOUR_IN_MILLISECONDS: number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,qBAAqB;AACrB,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,uBAAuB;AACvB,eAAO,MAAM,sBAAsB,QAA8B,CAAC;AAElE,0BAA0B;AAC1B,eAAO,MAAM,oBAAoB,QAA8B,CAAC"}

package/dist/functions/array.d.cts

@@ -0,0 +1,83 @@
+/**
+ * Helper functions that have to do with arrays.
+ *
+ * @module
+ */
+import type { WidenLiteral } from "../index.js";
+/**
+ * Helper function to copy a two-dimensional array. Note that the sub-arrays will only be shallow
+ * copied (using the spread operator).
+ */
+export declare function arrayCopyTwoDimensional<T>(array: ReadonlyArray<readonly T[]>): T[][];
+/**
+ * Helper function for determining if two arrays contain the exact same elements. Note that this
+ * only performs a shallow comparison.
+ */
+export declare function arrayEquals<T>(array1: readonly T[], array2: readonly T[]): boolean;
+/**
+ * Builds a new array based on the original array without the specified element(s). Returns the new
+ * array. If the specified element(s) are not found in the array, it will simply return a shallow
+ * copy of the array.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ */
+export declare function arrayRemove<T>(originalArray: readonly T[], ...elementsToRemove: readonly T[]): T[];
+/**
+ * Removes the specified element(s) from the array. If the specified element(s) are not found in the
+ * array, this function will do nothing.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ *
+ * If there is more than one matching element in the array, this function will only remove the first
+ * matching element. If you want to remove all of the elements, use the `arrayRemoveAllInPlace`
+ * function instead.
+ *
+ * @returns The removed elements. This will be an empty array if no elements were removed.
+ */
+export declare function arrayRemoveInPlace<T>(array: T[], ...elementsToRemove: readonly T[]): T[];
+/** Helper function to remove all of the elements in an array in-place. */
+export declare function emptyArray<T>(array: T[]): void;
+/**
+ * Helper function to perform a filter and a map at the same time. Similar to `Array.map`, provide a
+ * function that transforms a value, but return `undefined` if the value should be skipped. (Thus,
+ * this function cannot be used in situations where `undefined` can be a valid array element.)
+ *
+ * This function is useful because the `Array.map` method will always produce an array with the same
+ * amount of elements as the original array.
+ *
+ * This is named `filterMap` after the Rust function:
+ * https://doc.rust-lang.org/std/iter/struct.FilterMap.html
+ */
+export declare function filterMap<OldT, NewT>(array: readonly OldT[], func: (element: OldT) => NewT | undefined): NewT[];
+/**
+ * Helper function to get a random element from the provided array.
+ *
+ * Note that this will only work with arrays that do not contain values of `undefined`, since the
+ * function uses `undefined` as an indication that the corresponding element does not exist.
+ *
+ * @param array The array to get an element from.
+ * @param exceptions Optional. An array of elements to skip over if selected.
+ */
+export declare function getRandomArrayElement<T>(array: readonly T[], exceptions?: readonly T[]): T;
+/**
+ * Helper function to get a random index from the provided array.
+ *
+ * @param array The array to get the index from.
+ * @param exceptions Optional. An array of indexes that will be skipped over when getting the random
+ *                   index. Default is an empty array.
+ */
+export declare function getRandomArrayIndex<T>(array: readonly T[], exceptions?: readonly number[]): number;
+/**
+ * Similar to the `Array.includes` method, but works on a widened version of the array.
+ *
+ * This is useful when the normal `Array.includes` produces a type error from an array that uses an
+ * `as const` assertion.
+ */
+export declare function includes<T, TupleElement extends WidenLiteral<T>>(array: readonly TupleElement[], searchElement: WidenLiteral<T>): searchElement is TupleElement;
+/** A wrapper around `Array.isArray` that narrows to `unknown[]` instead of `any[]`. */
+export declare function isArray(arg: unknown): arg is unknown[];
+/** Initializes an array with all elements containing the specified default value. */
+export declare function newArray<T>(length: number, value: T): T[];
+/** Helper function to sum every value in an array together. */
+export declare function sumArray(array: readonly number[]): number;
+//# sourceMappingURL=array.d.ts.map

package/dist/functions/array.d.mts

@@ -0,0 +1,83 @@
+/**
+ * Helper functions that have to do with arrays.
+ *
+ * @module
+ */
+import type { WidenLiteral } from "../index.js";
+/**
+ * Helper function to copy a two-dimensional array. Note that the sub-arrays will only be shallow
+ * copied (using the spread operator).
+ */
+export declare function arrayCopyTwoDimensional<T>(array: ReadonlyArray<readonly T[]>): T[][];
+/**
+ * Helper function for determining if two arrays contain the exact same elements. Note that this
+ * only performs a shallow comparison.
+ */
+export declare function arrayEquals<T>(array1: readonly T[], array2: readonly T[]): boolean;
+/**
+ * Builds a new array based on the original array without the specified element(s). Returns the new
+ * array. If the specified element(s) are not found in the array, it will simply return a shallow
+ * copy of the array.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ */
+export declare function arrayRemove<T>(originalArray: readonly T[], ...elementsToRemove: readonly T[]): T[];
+/**
+ * Removes the specified element(s) from the array. If the specified element(s) are not found in the
+ * array, this function will do nothing.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ *
+ * If there is more than one matching element in the array, this function will only remove the first
+ * matching element. If you want to remove all of the elements, use the `arrayRemoveAllInPlace`
+ * function instead.
+ *
+ * @returns The removed elements. This will be an empty array if no elements were removed.
+ */
+export declare function arrayRemoveInPlace<T>(array: T[], ...elementsToRemove: readonly T[]): T[];
+/** Helper function to remove all of the elements in an array in-place. */
+export declare function emptyArray<T>(array: T[]): void;
+/**
+ * Helper function to perform a filter and a map at the same time. Similar to `Array.map`, provide a
+ * function that transforms a value, but return `undefined` if the value should be skipped. (Thus,
+ * this function cannot be used in situations where `undefined` can be a valid array element.)
+ *
+ * This function is useful because the `Array.map` method will always produce an array with the same
+ * amount of elements as the original array.
+ *
+ * This is named `filterMap` after the Rust function:
+ * https://doc.rust-lang.org/std/iter/struct.FilterMap.html
+ */
+export declare function filterMap<OldT, NewT>(array: readonly OldT[], func: (element: OldT) => NewT | undefined): NewT[];
+/**
+ * Helper function to get a random element from the provided array.
+ *
+ * Note that this will only work with arrays that do not contain values of `undefined`, since the
+ * function uses `undefined` as an indication that the corresponding element does not exist.
+ *
+ * @param array The array to get an element from.
+ * @param exceptions Optional. An array of elements to skip over if selected.
+ */
+export declare function getRandomArrayElement<T>(array: readonly T[], exceptions?: readonly T[]): T;
+/**
+ * Helper function to get a random index from the provided array.
+ *
+ * @param array The array to get the index from.
+ * @param exceptions Optional. An array of indexes that will be skipped over when getting the random
+ *                   index. Default is an empty array.
+ */
+export declare function getRandomArrayIndex<T>(array: readonly T[], exceptions?: readonly number[]): number;
+/**
+ * Similar to the `Array.includes` method, but works on a widened version of the array.
+ *
+ * This is useful when the normal `Array.includes` produces a type error from an array that uses an
+ * `as const` assertion.
+ */
+export declare function includes<T, TupleElement extends WidenLiteral<T>>(array: readonly TupleElement[], searchElement: WidenLiteral<T>): searchElement is TupleElement;
+/** A wrapper around `Array.isArray` that narrows to `unknown[]` instead of `any[]`. */
+export declare function isArray(arg: unknown): arg is unknown[];
+/** Initializes an array with all elements containing the specified default value. */
+export declare function newArray<T>(length: number, value: T): T[];
+/** Helper function to sum every value in an array together. */
+export declare function sumArray(array: readonly number[]): number;
+//# sourceMappingURL=array.d.ts.map

package/dist/functions/array.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Helper functions that have to do with arrays.
+ *
+ * @module
+ */
+import type { WidenLiteral } from "../index.js";
+/**
+ * Helper function to copy a two-dimensional array. Note that the sub-arrays will only be shallow
+ * copied (using the spread operator).
+ */
+export declare function arrayCopyTwoDimensional<T>(array: ReadonlyArray<readonly T[]>): T[][];
+/**
+ * Helper function for determining if two arrays contain the exact same elements. Note that this
+ * only performs a shallow comparison.
+ */
+export declare function arrayEquals<T>(array1: readonly T[], array2: readonly T[]): boolean;
+/**
+ * Builds a new array based on the original array without the specified element(s). Returns the new
+ * array. If the specified element(s) are not found in the array, it will simply return a shallow
+ * copy of the array.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ */
+export declare function arrayRemove<T>(originalArray: readonly T[], ...elementsToRemove: readonly T[]): T[];
+/**
+ * Removes the specified element(s) from the array. If the specified element(s) are not found in the
+ * array, this function will do nothing.
+ *
+ * This function is variadic, meaning that you can specify N arguments to remove N elements.
+ *
+ * If there is more than one matching element in the array, this function will only remove the first
+ * matching element. If you want to remove all of the elements, use the `arrayRemoveAllInPlace`
+ * function instead.
+ *
+ * @returns The removed elements. This will be an empty array if no elements were removed.
+ */
+export declare function arrayRemoveInPlace<T>(array: T[], ...elementsToRemove: readonly T[]): T[];
+/** Helper function to remove all of the elements in an array in-place. */
+export declare function emptyArray<T>(array: T[]): void;
+/**
+ * Helper function to perform a filter and a map at the same time. Similar to `Array.map`, provide a
+ * function that transforms a value, but return `undefined` if the value should be skipped. (Thus,
+ * this function cannot be used in situations where `undefined` can be a valid array element.)
+ *
+ * This function is useful because the `Array.map` method will always produce an array with the same
+ * amount of elements as the original array.
+ *
+ * This is named `filterMap` after the Rust function:
+ * https://doc.rust-lang.org/std/iter/struct.FilterMap.html
+ */
+export declare function filterMap<OldT, NewT>(array: readonly OldT[], func: (element: OldT) => NewT | undefined): NewT[];
+/**
+ * Helper function to get a random element from the provided array.
+ *
+ * Note that this will only work with arrays that do not contain values of `undefined`, since the
+ * function uses `undefined` as an indication that the corresponding element does not exist.
+ *
+ * @param array The array to get an element from.
+ * @param exceptions Optional. An array of elements to skip over if selected.
+ */
+export declare function getRandomArrayElement<T>(array: readonly T[], exceptions?: readonly T[]): T;
+/**
+ * Helper function to get a random index from the provided array.
+ *
+ * @param array The array to get the index from.
+ * @param exceptions Optional. An array of indexes that will be skipped over when getting the random
+ *                   index. Default is an empty array.
+ */
+export declare function getRandomArrayIndex<T>(array: readonly T[], exceptions?: readonly number[]): number;
+/**
+ * Similar to the `Array.includes` method, but works on a widened version of the array.
+ *
+ * This is useful when the normal `Array.includes` produces a type error from an array that uses an
+ * `as const` assertion.
+ */
+export declare function includes<T, TupleElement extends WidenLiteral<T>>(array: readonly TupleElement[], searchElement: WidenLiteral<T>): searchElement is TupleElement;
+/** A wrapper around `Array.isArray` that narrows to `unknown[]` instead of `any[]`. */
+export declare function isArray(arg: unknown): arg is unknown[];
+/** Initializes an array with all elements containing the specified default value. */
+export declare function newArray<T>(length: number, value: T): T[];
+/** Helper function to sum every value in an array together. */
+export declare function sumArray(array: readonly number[]): number;
+//# sourceMappingURL=array.d.ts.map

package/dist/functions/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/functions/array.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAKhD;;;GAGG;AAEH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,EAAE,CAAC,GACjC,CAAC,EAAE,EAAE,CAQP;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,MAAM,EAAE,SAAS,CAAC,EAAE,EACpB,MAAM,EAAE,SAAS,CAAC,EAAE,GACnB,OAAO,CAST;AAED;;;;;;GAMG;AAEH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,aAAa,EAAE,SAAS,CAAC,EAAE,EAC3B,GAAG,gBAAgB,EAAE,SAAS,CAAC,EAAE,GAChC,CAAC,EAAE,CAWL;AAED;;;;;;;;;;;GAWG;AAEH,wBAAgB,kBAAkB,CAAC,CAAC,EAElC,KAAK,EAAE,CAAC,EAAE,EACV,GAAG,gBAAgB,EAAE,SAAS,CAAC,EAAE,GAChC,CAAC,EAAE,CAYL;AAED,0EAA0E;AAE1E,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI,CAE9C;AAED;;;;;;;;;;GAUG;AAEH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAClC,KAAK,EAAE,SAAS,IAAI,EAAE,EACtB,IAAI,EAAE,CAAC,OAAO,EAAE,IAAI,KAAK,IAAI,GAAG,SAAS,GACxC,IAAI,EAAE,CAWR;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,UAAU,GAAE,SAAS,CAAC,EAAO,GAC5B,CAAC,CAiBH;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,UAAU,GAAE,SAAS,MAAM,EAAO,GACjC,MAAM,CAQR;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,YAAY,SAAS,YAAY,CAAC,CAAC,CAAC,EAC9D,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,aAAa,EAAE,YAAY,CAAC,CAAC,CAAC,GAC7B,aAAa,IAAI,YAAY,CAG/B;AAED,uFAAuF;AACvF,wBAAgB,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,OAAO,EAAE,CAEtD;AAED,qFAAqF;AAErF,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,CAEzD;AAED,+DAA+D;AAC/D,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAEzD"}

package/dist/functions/assert.d.cts

@@ -0,0 +1,22 @@
+/**
+ * Helper functions that have to do with asserting.
+ *
+ * @module
+ */
+/**
+ * Helper function to throw an error if the provided value is equal to `undefined`.
+ *
+ * This is useful to have TypeScript narrow a `T | undefined` value to `T` in a concise way.
+ */
+export declare function assertDefined<T>(value: T, ...[msg]: [undefined] extends [T] ? [string] : [
+    "The assertion is useless because the provided value does not contain undefined."
+]): asserts value is Exclude<T, undefined>;
+/**
+ * Helper function to throw an error if the provided value is equal to `null`.
+ *
+ * This is useful to have TypeScript narrow a `T | null` value to `T` in a concise way.
+ */
+export declare function assertNotNull<T>(value: T, ...[msg]: [null] extends [T] ? [string] : [
+    "The assertion is useless because the provided value does not contain null."
+]): asserts value is Exclude<T, null>;
+//# sourceMappingURL=assert.d.ts.map

package/dist/functions/assert.d.mts

@@ -0,0 +1,22 @@
+/**
+ * Helper functions that have to do with asserting.
+ *
+ * @module
+ */
+/**
+ * Helper function to throw an error if the provided value is equal to `undefined`.
+ *
+ * This is useful to have TypeScript narrow a `T | undefined` value to `T` in a concise way.
+ */
+export declare function assertDefined<T>(value: T, ...[msg]: [undefined] extends [T] ? [string] : [
+    "The assertion is useless because the provided value does not contain undefined."
+]): asserts value is Exclude<T, undefined>;
+/**
+ * Helper function to throw an error if the provided value is equal to `null`.
+ *
+ * This is useful to have TypeScript narrow a `T | null` value to `T` in a concise way.
+ */
+export declare function assertNotNull<T>(value: T, ...[msg]: [null] extends [T] ? [string] : [
+    "The assertion is useless because the provided value does not contain null."
+]): asserts value is Exclude<T, null>;
+//# sourceMappingURL=assert.d.ts.map

package/dist/functions/assert.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Helper functions that have to do with asserting.
+ *
+ * @module
+ */
+/**
+ * Helper function to throw an error if the provided value is equal to `undefined`.
+ *
+ * This is useful to have TypeScript narrow a `T | undefined` value to `T` in a concise way.
+ */
+export declare function assertDefined<T>(value: T, ...[msg]: [undefined] extends [T] ? [string] : [
+    "The assertion is useless because the provided value does not contain undefined."
+]): asserts value is Exclude<T, undefined>;
+/**
+ * Helper function to throw an error if the provided value is equal to `null`.
+ *
+ * This is useful to have TypeScript narrow a `T | null` value to `T` in a concise way.
+ */
+export declare function assertNotNull<T>(value: T, ...[msg]: [null] extends [T] ? [string] : [
+    "The assertion is useless because the provided value does not contain null."
+]): asserts value is Exclude<T, null>;
+//# sourceMappingURL=assert.d.ts.map

package/dist/functions/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/functions/assert.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,CAAC,EACR,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,GAC7B,CAAC,MAAM,CAAC,GACR;IACE,iFAAiF;CAClF,GACJ,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,SAAS,CAAC,CAIxC;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC7B,KAAK,EAAE,CAAC,EACR,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,GACxB,CAAC,MAAM,CAAC,GACR;IACE,4EAA4E;CAC7E,GACJ,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,CAInC"}

package/dist/functions/enums.d.cts

@@ -0,0 +1,73 @@
+/**
+ * Helper functions that have to do with TypeScript enums.
+ *
+ * @module
+ */
+type TranspiledEnum = Record<string, string | number>;
+/**
+ * Helper function to get the entries of an enum.
+ *
+ * (By default, TypeScript will put the keys inside of the values of a number-based enum, so those
+ * have to be filtered out.)
+ *
+ * This function will work properly for both number and string enums.
+ */
+export declare function getEnumEntries<T extends TranspiledEnum>(transpiledEnum: T): ReadonlyArray<[key: string, value: T[keyof T]]>;
+/**
+ * Helper function to get the keys of an enum.
+ *
+ * (By default, TypeScript will put the keys inside of the values of a number-based enum, so those
+ * have to be filtered out.)
+ *
+ * This function will work properly for both number and string enums.
+ */
+export declare function getEnumKeys(transpiledEnum: TranspiledEnum): readonly string[];
+/**
+ * Helper function to get the only the values of an enum.
+ *
+ * (By default, TypeScript will put the keys inside of the values of a number-based enum, so those
+ * have to be filtered out.)
+ *
+ * This function will work properly for both number and string enums.
+ */
+export declare function getEnumValues<T extends TranspiledEnum>(transpiledEnum: T): ReadonlyArray<T[keyof T]>;
+/**
+ * Helper function to validate that an interface contains all of the keys of an enum. You must
+ * specify both generic parameters in order for this to work properly (i.e. the interface and then
+ * the enum).
+ *
+ * For example:
+ *
+ * ```ts
+ * enum MyEnum {
+ *   Value1,
+ *   Value2,
+ *   Value3,
+ * }
+ *
+ * interface MyEnumToType {
+ *   [MyEnum.Value1]: boolean;
+ *   [MyEnum.Value2]: number;
+ *   [MyEnum.Value3]: string;
+ * }
+ *
+ * interfaceSatisfiesEnum<MyEnumToType, MyEnum>();
+ * ```
+ *
+ * This function is only meant to be used with interfaces (i.e. types that will not exist at
+ * run-time). If you are generating an object that will contain all of the keys of an enum, use the
+ * `satisfies` operator with the `Record` type instead.
+ */
+export declare function interfaceSatisfiesEnum<T extends Record<Enum, unknown>, Enum extends string | number>(): void;
+/**
+ * Helper function to validate that a particular value exists inside of an enum.
+ *
+ * @param value The value to check.
+ * @param transpiledEnum The enum to check against.
+ * @param set Optional. A set that contains all of the values of an enum. If provided, this function
+ *            will check for existence using the set (instead of the enum itself). Using a set
+ *            should be more performant for enums with around 52 or more elements.
+ */
+export declare function isEnumValue<T extends TranspiledEnum>(value: number | string, transpiledEnum: T, set?: ReadonlySet<string | number>): value is T[keyof T];
+export {};
+//# sourceMappingURL=enums.d.ts.map

package/dist/functions/enums.d.mts

@@ -0,0 +1,73 @@
+/**
+ * Helper functions that have to do with TypeScript enums.
+ *
+ * @module
+ */
+type TranspiledEnum = Record<string, string | number>;
+/**
+ * Helper function to get the entries of an enum.
+ *
+ * (By default, TypeScript will put the keys inside of the values of a number-based enum, so those
+ * have to be filtered out.)
+ *
+ * This function will work properly for both number and string enums.
+ */
+export declare function getEnumEntries<T extends TranspiledEnum>(transpiledEnum: T): ReadonlyArray<[key: string, value: T[keyof T]]>;
+/**
+ * Helper function to get the keys of an enum.
+ *
+ * (By default, TypeScript will put the keys inside of the values of a number-based enum, so those
+ * have to be filtered out.)
+ *
+ * This function will work properly for both number and string enums.
+ */
+export declare function getEnumKeys(transpiledEnum: TranspiledEnum): readonly string[];
+/**
+ * Helper function to get the only the values of an enum.
+ *
+ * (By default, TypeScript will put the keys inside of the values of a number-based enum, so those
+ * have to be filtered out.)
+ *
+ * This function will work properly for both number and string enums.
+ */
+export declare function getEnumValues<T extends TranspiledEnum>(transpiledEnum: T): ReadonlyArray<T[keyof T]>;
+/**
+ * Helper function to validate that an interface contains all of the keys of an enum. You must
+ * specify both generic parameters in order for this to work properly (i.e. the interface and then
+ * the enum).
+ *
+ * For example:
+ *
+ * ```ts
+ * enum MyEnum {
+ *   Value1,
+ *   Value2,
+ *   Value3,
+ * }
+ *
+ * interface MyEnumToType {
+ *   [MyEnum.Value1]: boolean;
+ *   [MyEnum.Value2]: number;
+ *   [MyEnum.Value3]: string;
+ * }
+ *
+ * interfaceSatisfiesEnum<MyEnumToType, MyEnum>();
+ * ```
+ *
+ * This function is only meant to be used with interfaces (i.e. types that will not exist at
+ * run-time). If you are generating an object that will contain all of the keys of an enum, use the
+ * `satisfies` operator with the `Record` type instead.
+ */
+export declare function interfaceSatisfiesEnum<T extends Record<Enum, unknown>, Enum extends string | number>(): void;
+/**
+ * Helper function to validate that a particular value exists inside of an enum.
+ *
+ * @param value The value to check.
+ * @param transpiledEnum The enum to check against.
+ * @param set Optional. A set that contains all of the values of an enum. If provided, this function
+ *            will check for existence using the set (instead of the enum itself). Using a set
+ *            should be more performant for enums with around 52 or more elements.
+ */
+export declare function isEnumValue<T extends TranspiledEnum>(value: number | string, transpiledEnum: T, set?: ReadonlySet<string | number>): value is T[keyof T];
+export {};
+//# sourceMappingURL=enums.d.ts.map

package/dist/functions/enums.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Helper functions that have to do with TypeScript enums.
+ *
+ * @module
+ */
+type TranspiledEnum = Record<string, string | number>;
+/**
+ * Helper function to get the entries of an enum.
+ *
+ * (By default, TypeScript will put the keys inside of the values of a number-based enum, so those
+ * have to be filtered out.)
+ *
+ * This function will work properly for both number and string enums.
+ */
+export declare function getEnumEntries<T extends TranspiledEnum>(transpiledEnum: T): ReadonlyArray<[key: string, value: T[keyof T]]>;
+/**
+ * Helper function to get the keys of an enum.
+ *
+ * (By default, TypeScript will put the keys inside of the values of a number-based enum, so those
+ * have to be filtered out.)
+ *
+ * This function will work properly for both number and string enums.
+ */
+export declare function getEnumKeys(transpiledEnum: TranspiledEnum): readonly string[];
+/**
+ * Helper function to get the only the values of an enum.
+ *
+ * (By default, TypeScript will put the keys inside of the values of a number-based enum, so those
+ * have to be filtered out.)
+ *
+ * This function will work properly for both number and string enums.
+ */
+export declare function getEnumValues<T extends TranspiledEnum>(transpiledEnum: T): ReadonlyArray<T[keyof T]>;
+/**
+ * Helper function to validate that an interface contains all of the keys of an enum. You must
+ * specify both generic parameters in order for this to work properly (i.e. the interface and then
+ * the enum).
+ *
+ * For example:
+ *
+ * ```ts
+ * enum MyEnum {
+ *   Value1,
+ *   Value2,
+ *   Value3,
+ * }
+ *
+ * interface MyEnumToType {
+ *   [MyEnum.Value1]: boolean;
+ *   [MyEnum.Value2]: number;
+ *   [MyEnum.Value3]: string;
+ * }
+ *
+ * interfaceSatisfiesEnum<MyEnumToType, MyEnum>();
+ * ```
+ *
+ * This function is only meant to be used with interfaces (i.e. types that will not exist at
+ * run-time). If you are generating an object that will contain all of the keys of an enum, use the
+ * `satisfies` operator with the `Record` type instead.
+ */
+export declare function interfaceSatisfiesEnum<T extends Record<Enum, unknown>, Enum extends string | number>(): void;
+/**
+ * Helper function to validate that a particular value exists inside of an enum.
+ *
+ * @param value The value to check.
+ * @param transpiledEnum The enum to check against.
+ * @param set Optional. A set that contains all of the values of an enum. If provided, this function
+ *            will check for existence using the set (instead of the enum itself). Using a set
+ *            should be more performant for enums with around 52 or more elements.
+ */
+export declare function isEnumValue<T extends TranspiledEnum>(value: number | string, transpiledEnum: T, set?: ReadonlySet<string | number>): value is T[keyof T];
+export {};
+//# sourceMappingURL=enums.d.ts.map

package/dist/functions/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../src/functions/enums.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;AAEtD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,cAAc,EACrD,cAAc,EAAE,CAAC,GAChB,aAAa,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CASjD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,cAAc,EAAE,cAAc,GAAG,SAAS,MAAM,EAAE,CAG7E;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,cAAc,EACpD,cAAc,EAAE,CAAC,GAChB,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAG3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CAEpC,CAAC,SAAS,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,EAC/B,IAAI,SAAS,MAAM,GAAG,MAAM,KACzB,IAAI,CAAG;AAEZ;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,cAAc,EAClD,KAAK,EAAE,MAAM,GAAG,MAAM,EACtB,cAAc,EAAE,CAAC,EACjB,GAAG,CAAC,EAAE,WAAW,CAAC,MAAM,GAAG,MAAM,CAAC,GACjC,KAAK,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAOrB"}

package/dist/functions/map.d.cts

@@ -0,0 +1,52 @@
+/**
+ * Helper functions that have to do with
+ * [maps](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map).
+ *
+ * @module
+ */
+/**
+ * Helper function to get the values in a `Map` that match an arbitrary condition. Similar to the
+ * `Array.map` method, but works for maps.
+ *
+ * This is efficient such that it avoids converting the map values into an array.
+ *
+ * If you want to perform a filter and a map at the same time on an array, use the `filterMap`
+ * helper function instead.
+ */
+export declare function mapFilter<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V) => boolean): V[];
+/**
+ * Helper function to find a value in a `Map`. Similar to the `Array.find` method, but works for
+ * maps.
+ *
+ * This is efficient such that it avoids converting the map values into an array.
+ */
+export declare function mapFind<K, V>(map: ReadonlyMap<K, V>, predicate: (value: V) => boolean): V | undefined;
+/**
+ * Helper function to convert an object to a map.
+ *
+ * This is useful when you need to construct a type safe object with the `satisfies` operator, but
+ * then later on you need to query it in a way where you expect the return value to be T or
+ * undefined. In this situation, by converting the object to a map, you can avoid unsafe type
+ * assertions.
+ *
+ * Note that the map values will be inserted in a random order, due to how `pairs` works under the
+ * hood.
+ *
+ * Also see the `objectToReadonlyMap` function.
+ */
+export declare function objectToMap<K extends string | number | symbol, V>(object: Record<K, V>): Map<K, V>;
+/**
+ * Helper function to convert an object to a read-only map.
+ *
+ * This is useful when you need to construct a type safe object with the `satisfies` operator, but
+ * then later on you need to query it in a way where you expect the return value to be T or
+ * undefined. In this situation, by converting the object to a map, you can avoid unsafe type
+ * assertions.
+ *
+ * Note that the map values will be inserted in a random order, due to how `pairs` works under the
+ * hood.
+ *
+ * Also see the `objectToMap` function.
+ */
+export declare function objectToReadonlyMap<K extends string | number | symbol, V>(object: Record<K, V>): ReadonlyMap<K, V>;
+//# sourceMappingURL=map.d.ts.map