@augment-vir/common 29.2.0 → 30.0.0

package/dist/types/augments/common-string.d.ts

@@ -1,74 +0,0 @@
-import { PartialAndUndefined } from './object/object';
-import { AtLeastTuple } from './tuple';
-/**
- * Join elements into a string with commas separating each value. Add a conjunction before the final
- * item in the list. If the array has a length < 2, the conjunction is not added. If the list is
- * only of length 2, then no commas are added.
- *
- * @param list Array of items to be converted into strings. Works best if these are simply strings
- *   to begin with.
- * @param conjunction Defaults to 'and'. The conjunction to be used before the final element.
- */
-export declare function joinWithFinalConjunction(list: ReadonlyArray<any>, conjunction?: string): string;
-/** Wraps `value` on both sides with `wrapper`. */
-export declare function wrapString({ value, wrapper }: {
-    value: string;
-    wrapper: string;
-}): string;
-export declare function removeAnsiEscapeCodes(input: string): string;
-export declare const removeColor: typeof removeAnsiEscapeCodes;
-export declare function removeCommasFromNumberString(numberString: string): string;
-/** Collapse all consecutive white space into just one space and trim surrounding whitespace. */
-export declare function collapseWhiteSpace(input: string, { keepNewLines }?: PartialAndUndefined<{
-    keepNewLines: boolean;
-}>): string;
-/** Same as String.prototype.split but includes the delimiter to split by in the output array. */
-export declare function splitIncludeSplit(original: string, splitterInput: string | RegExp, caseSensitive: boolean): readonly string[];
-export type CasingOptions = {
-    capitalizeFirstLetter: boolean;
-};
-export declare function capitalizeFirstLetter<InputGeneric extends string>(input: InputGeneric): Capitalize<InputGeneric>;
-export declare function kebabCaseToCamelCase(rawKebabCase: string, casingOptions?: Partial<CasingOptions> | undefined): string;
-export declare enum StringCaseEnum {
-    Upper = "upper",
-    Lower = "lower"
-}
-/** Indicates whether the given string has different lower and upper case variants. */
-export declare function hasCase(input: string): boolean;
-export type IsCaseOptions = {
-    /**
-     * Block characters that don't have different upper and lower case versions (such as
-     * punctuation).
-     */
-    blockNoCaseCharacters: boolean;
-};
-/**
- * Checks if the given string is exclusively of the specific case.
- *
- * Note that some characters have no casing, such as punctuation (they have no difference between
- * upper and lower casings). By default, those letters always return `true` for this function,
- * regardless of which `caseType` is provided. To instead return `false` for any such characters,
- * pass in an options object and set blockNoCaseCharacters to true.
- */
-export declare function isCase(input: string, caseType: StringCaseEnum, options?: PartialAndUndefined<IsCaseOptions>): boolean;
-export declare function camelCaseToKebabCase(rawCamelCase: string): string;
-export declare function replaceStringAtIndex(originalString: string, start: number, newString: string, length?: number): string;
-/**
- * Escapes characters from the given string so that it can be used within a RegExp without being
- * parsed as RegExp syntax.
- */
-export declare function escapeStringForRegExp(input: string): string;
-export declare function getAllIndexesOf<IncludeLength extends boolean | undefined>({ searchIn, searchFor, caseSensitive, includeLength, }: {
-    searchIn: string;
-    searchFor: string | RegExp;
-    /**
-     * CaseSensitive only applies when the input is a string. Otherwise, the RegExp's "i" flag is
-     * used to determine case sensitivity.
-     */
-    caseSensitive: boolean;
-    includeLength?: IncludeLength;
-}): IncludeLength extends true ? {
-    index: number;
-    length: number;
-}[] : number[];
-export declare function typedSplit(input: string, splitString: string): AtLeastTuple<string, 1>;

package/dist/types/augments/debounce.d.ts

@@ -1,15 +0,0 @@
-export declare enum DebounceStyle {
-    /**
-     * Fires on the first call, then waits the given amount of milliseconds until a subsequent call
-     * can be made.
-     */
-    FirstThenWait = "first-then-wait",
-    /**
-     * Waits the given amount of milliseconds after the first call and then fires the latest
-     * assigned callback.
-     */
-    AfterWait = "after-wait"
-}
-export declare function createDebounce(debounceStyle: DebounceStyle, debounceDuration: {
-    milliseconds: number;
-}): (callback: () => void) => void;

package/dist/types/augments/environment.d.ts

@@ -1 +0,0 @@
-export declare function isBrowser(): boolean;

package/dist/types/augments/error.d.ts

@@ -1,9 +0,0 @@
-import { AtLeastTuple } from './tuple';
-export declare function combineErrors(errors: AtLeastTuple<Error, 1>): Error;
-export declare function combineErrors(errors: ReadonlyArray<never>): undefined;
-export declare function combineErrors(errors: ReadonlyArray<Error>): Error | undefined;
-export declare function combineErrors(errors?: undefined): undefined;
-export declare function combineErrorMessages(errors?: ReadonlyArray<Error | string | undefined> | undefined): string;
-export declare function extractErrorMessage(maybeError: unknown): string;
-export declare function ensureError(maybeError: unknown): Error;
-export declare function ensureErrorAndPrependMessage(maybeError: unknown, prependMessage: string): Error;

package/dist/types/augments/function.d.ts

@@ -1,25 +0,0 @@
-import { ArrayElement } from './type';
-export type AnyFunction<ReturnGeneric = any> = (...args: any[]) => ReturnGeneric;
-export type NoInputsFunction<ReturnGeneric = any> = () => ReturnGeneric;
-/**
- * Accepts an "Arguments" and "Return" generic to quickly make a function type. If "Arguments" is an
- * array, it is spread into the full function's Parameters list. If any argument should be an array,
- * instead of a rest parameter, put it inside of a tuple. If no arguments should be possible, pass
- * void to "Arguments". If you need an optional argument, pass it inside of a tuple.
- *
- * @example
- *     TypedFunction<string, number>; // (input: string) => number
- *
- * @example
- *     TypedFunction<string[], number>; // (...inputs: string[]) => number
- *
- * @example
- *     TypedFunction<[string[]], number>; // (input: string[]) => number
- *
- * @example
- *     TypedFunction<[string, number], number>; // (input1: string, input2: number) => number
- *
- * @example
- *     TypedFunction<[string | undefined], number>; // (input1: string|undefined) => number
- */
-export type TypedFunction<Arguments, Return> = Arguments extends readonly any[] ? number extends Arguments['length'] ? (...args: ArrayElement<Arguments>[]) => Return : (...args: Arguments) => Return : void extends Arguments ? () => Return : (arg: Arguments) => Return;

package/dist/types/augments/json.d.ts

@@ -1,9 +0,0 @@
-import { JsonCompatibleValue } from './json-compatible';
-import { WrapInTryOptions } from './wrap-in-try';
-export declare function parseJson<ParsedJsonGeneric>({ jsonString, errorHandler, }: {
-    jsonString: string;
-    errorHandler?: (error: unknown) => never | ParsedJsonGeneric;
-}): ParsedJsonGeneric;
-export declare function stringifyJson(jsonValue: JsonCompatibleValue, { whitespace, ...tryOptions }?: {
-    whitespace?: number;
-} & WrapInTryOptions<string>): string;

package/dist/types/augments/object/any-object.d.ts

@@ -1,2 +0,0 @@
-export type AnyObject = Record<PropertyKey, any>;
-export type UnknownObject = Record<PropertyKey, unknown>;

package/dist/types/augments/object/enum.d.ts

@@ -1,8 +0,0 @@
-export type EnumBaseType = Record<string, number | string>;
-export declare function getEnumTypedKeys<T extends EnumBaseType>(input: T): (keyof T)[];
-export declare function getEnumTypedValues<T extends EnumBaseType>(input: T): T[keyof T][];
-/** Check if the given value is within the given enum. */
-export declare function isEnumValue<T extends EnumBaseType>(input: unknown, checkEnum: T): input is T[keyof T];
-/** Interpret a primitive as an enum value with type safety. */
-export declare function ensureEnum<const ValueType extends `${EnumType[keyof EnumType]}`, const EnumType extends EnumBaseType>(value: ValueType, checkEnum: EnumType): EnumType[keyof EnumType];
-export declare function filterToEnumValues<T extends EnumBaseType>(inputs: ReadonlyArray<unknown>, checkEnum: T, caseInsensitive?: boolean): T[keyof T][];

package/dist/types/augments/object/filter-object.d.ts

@@ -1,4 +0,0 @@
-import { PropertyValueType } from './object';
-export declare function filterObject<ObjectGeneric>(inputObject: ObjectGeneric, callback: (key: keyof ObjectGeneric, value: PropertyValueType<ObjectGeneric>, fullObject: ObjectGeneric) => boolean): Partial<ObjectGeneric>;
-export declare function omitObjectKeys<ObjectGeneric, KeyGeneric extends keyof ObjectGeneric>(inputObject: Readonly<ObjectGeneric>, omitTheseKeys: ReadonlyArray<KeyGeneric>): Omit<ObjectGeneric, KeyGeneric>;
-export declare function pickObjectKeys<ObjectGeneric, KeyGeneric extends keyof ObjectGeneric>(inputObject: Readonly<ObjectGeneric>, pickTheseKeys: ReadonlyArray<KeyGeneric>): Pick<ObjectGeneric, KeyGeneric>;

package/dist/types/augments/object/get-or-set.d.ts

@@ -1,26 +0,0 @@
-import { MaybePromise } from '../promise/promise';
-/**
- * Get a value from a map or call the callback and return its result and store the result in the
- * map.
- */
-export declare function getOrSetFromMap<MapKey extends object, MapValue>(map: WeakMap<MapKey, MapValue>, key: MapKey, createNewValueCallback: () => MapValue): MapValue;
-export declare function getOrSetFromMap<MapKey, MapValue>(map: Map<MapKey, MapValue>, key: MapKey, createNewValueCallback: () => MapValue): MapValue;
-/**
- * Given an object, tries to get the given key in that object. If the key is not in that object,
- * then the given `createCallback` is used to create a new value which is then stored in the given
- * object and returned. Automatically handles `createCallback` returning a promise, if it does.
- *
- * @example
- *     // instead of doing this
- *     if (!myObject[myKey]) {
- *         myObject[myKey] = myValue;
- *     }
- *     // notice the not null assertion here
- *     retrievedValue![nextKey] = 'some value';
- *
- *     // do this
- *     getOrSetInObject(myObject, myKey, () => myValue);
- */
-export declare function getOrSet<OriginalObject extends object, Key extends keyof OriginalObject>(originalObject: OriginalObject, key: Key, createCallback: () => OriginalObject[Key]): Required<OriginalObject>[Key];
-export declare function getOrSet<OriginalObject extends object, Key extends keyof OriginalObject>(originalObject: OriginalObject, key: Key, createCallback: () => Promise<OriginalObject[Key]>): Promise<Required<OriginalObject>[Key]>;
-export declare function getOrSet<OriginalObject extends object, Key extends keyof OriginalObject>(originalObject: OriginalObject, key: Key, createCallback: () => MaybePromise<OriginalObject[Key]>): MaybePromise<Required<OriginalObject>[Key]>;

package/dist/types/augments/object/has-key.d.ts

@@ -1 +0,0 @@
-export declare function hasKey<ParentType>(parent: ParentType, property: PropertyKey): property is keyof ParentType;

package/dist/types/augments/object/jsonify.d.ts

@@ -1,2 +0,0 @@
-import { Jsonify } from 'type-fest';
-export declare function jsonify<InputGeneric>(input: InputGeneric): Jsonify<InputGeneric>;

package/dist/types/augments/object/object-entries.d.ts

@@ -1,8 +0,0 @@
-import { RemovePartial } from './object';
-/** @deprecated This is the same as hasKey */
-export declare function isKeyof<ObjectGeneric>(key: PropertyKey, object: ObjectGeneric): key is keyof ObjectGeneric;
-export declare function getObjectTypedKeys<ObjectGeneric>(input: ObjectGeneric): Array<keyof ObjectGeneric>;
-export declare function getObjectTypedValues<ObjectGeneric>(input: ObjectGeneric): RemovePartial<ObjectGeneric>[keyof RemovePartial<ObjectGeneric>][];
-export declare function getObjectTypedEntries<ObjectGeneric>(input: ObjectGeneric): [keyof ObjectGeneric, RemovePartial<ObjectGeneric>[keyof RemovePartial<ObjectGeneric>]][];
-export declare function getEntriesSortedByKey(input: object): [string, unknown][];
-export declare function typedObjectFromEntries<KeyType extends PropertyKey, ValueType>(entries: ReadonlyArray<Readonly<[KeyType, ValueType]>>): Record<KeyType, ValueType>;

package/dist/types/augments/object/object.d.ts

@@ -1,21 +0,0 @@
-import { RequireAtLeastOne, Writable } from 'type-fest';
-export type PartialAndNullable<T extends object> = {
-    [Prop in keyof T]?: T[Prop] | null | undefined;
-};
-export type PartialAndUndefined<T extends object> = {
-    [Prop in keyof T]?: T[Prop] | undefined;
-};
-/** Checks if the input is non-null and an object. Includes arrays. */
-export declare function isObject(input: any): input is NonNullable<object>;
-/** The input here must be serializable otherwise JSON parsing errors will be thrown */
-export declare function copyThroughJson<T>(input: Readonly<T>): Writable<T>;
-export type PropertyValueType<T> = T[keyof T];
-export type ExtractKeysWithMatchingValues<OriginalObject extends object, Matcher> = keyof {
-    [Prop in keyof OriginalObject as OriginalObject[Prop] extends Matcher ? Prop : never]: Prop;
-};
-export type ExcludeKeysWithMatchingValues<OriginalObject extends object, Matcher> = keyof {
-    [Prop in keyof OriginalObject as OriginalObject[Prop] extends Matcher ? never : Prop]: Prop;
-};
-export type RemovePartial<Input> = Input extends Partial<Record<infer K extends PropertyKey, infer V>> ? Required<Record<K, V>> : Required<Input>;
-/** Excludes empty objects from a union. */
-export type ExcludeEmpty<T> = T extends RequireAtLeastOne<T> ? T : never;

package/dist/types/augments/object/pick-deep.d.ts

@@ -1,14 +0,0 @@
-import { OptionalKeysOf, RequiredKeysOf } from 'type-fest';
-import { AnyFunction } from '../function';
-import { ArrayElement } from '../type';
-import { TsRecurse, TsRecursionStart, TsRecursionTracker } from '../type-recursion';
-import { AnyObject } from './any-object';
-export type InnerPickDeep<OriginalObject extends AnyObject, DeepKeys extends any[], Depth extends TsRecursionTracker> = DeepKeys extends [infer CurrentLevelPick, ...infer RemainingKeys] ? Extract<CurrentLevelPick, keyof OriginalObject> extends never ? OriginalObject : {
-    [CurrentProp in Extract<CurrentLevelPick, RequiredKeysOf<OriginalObject>>]: InnerPickDeepValue<OriginalObject, CurrentProp, RemainingKeys, Depth>;
-} & {
-    [CurrentProp in Extract<CurrentLevelPick, OptionalKeysOf<OriginalObject>>]?: InnerPickDeepValue<OriginalObject, CurrentProp, RemainingKeys, Depth>;
-} : DeepKeys extends [] ? OriginalObject : DeepKeys extends [infer CurrentLevelPick] ? CurrentLevelPick extends keyof OriginalObject ? Pick<OriginalObject, CurrentLevelPick> : never : never;
-type InnerPickDeepValue<OriginalObject, CurrentProp extends keyof OriginalObject, RemainingKeys extends any[], Depth extends TsRecursionTracker> = AnyFunction extends Extract<OriginalObject[CurrentProp], AnyFunction> ? OriginalObject[CurrentProp] | Exclude<OriginalObject[CurrentProp], AnyFunction> : Array<any> extends Extract<OriginalObject[CurrentProp], Array<any>> ? Array<InnerPickDeep<ArrayElement<Extract<OriginalObject[CurrentProp], Array<any>>>, RemainingKeys, TsRecurse<Depth>>> | Exclude<OriginalObject[CurrentProp], Array<any>> : ReadonlyArray<any> extends Extract<OriginalObject[CurrentProp], ReadonlyArray<any>> ? ReadonlyArray<InnerPickDeep<ArrayElement<Extract<OriginalObject[CurrentProp], ReadonlyArray<any>>>, RemainingKeys, TsRecurse<Depth>>> | Exclude<OriginalObject[CurrentProp], ReadonlyArray<any>> : Extract<OriginalObject[CurrentProp], Record<any, any>> extends never ? OriginalObject[CurrentProp] : InnerPickDeep<Extract<OriginalObject[CurrentProp], Record<any, any>>, RemainingKeys, TsRecurse<Depth>> | Exclude<OriginalObject[CurrentProp], Record<any, any>>;
-/** Pick nested keys. */
-export type PickDeep<OriginalObject extends object, DeepKeys extends PropertyKey[]> = InnerPickDeep<OriginalObject, DeepKeys, TsRecursionStart>;
-export {};

package/dist/types/augments/object/selection-set.d.ts

@@ -1,27 +0,0 @@
-import { IsAny, IsNever, Primitive } from 'type-fest';
-import { TsRecurse, TsRecursionStart, TsRecursionTracker, TsTooMuchRecursion } from '../type-recursion';
-import { UnionToIntersection } from '../union';
-import { AnyObject } from './any-object';
-import { KeyCount } from './key-count';
-import { ExcludeEmpty, PropertyValueType } from './object';
-/** All types that won't be recursed into when defining a {@link SelectionSet}. */
-export type SelectionTypesToPreserve = Primitive | RegExp | Promise<any>;
-/** A generic selection set without specific keys. */
-export type GenericSelectionSet = {
-    [Key in PropertyKey]: boolean | GenericSelectionSet | unknown;
-};
-/** Masks an object value with the given {@link SelectionSet}. */
-export type PickSelection<Full extends Readonly<AnyObject>, Selection extends GenericSelectionSet, Depth extends TsRecursionTracker = TsRecursionStart> = Depth extends TsTooMuchRecursion ? ['Error: recursive object depth is too deep.'] : Full extends ReadonlyArray<infer Element extends any> ? (PickSelection<Extract<Element, AnyObject>, Selection, TsRecurse<Depth>> | Exclude<Element, AnyObject>)[] : {
-    -readonly [Key in keyof Selection as Selection[Key] extends false ? never : Key extends keyof Full ? Key : never]: (Selection[Key] extends GenericSelectionSet ? PickSelection<NonNullable<Extract<Full[Key], AnyObject>>, Selection[Key], TsRecurse<Depth>> : Full[Key]) | Exclude<Full[Key], AnyObject>;
-};
-/**
- * Collapses a selected value to the first part of the selection that contains more than 1 key or
- * that is not an object.
- */
-export type PickCollapsedSelection<Full extends Readonly<AnyObject>, Selection extends GenericSelectionSet, Depth extends TsRecursionTracker = TsRecursionStart> = Depth extends TsTooMuchRecursion ? 'Error: recursive object depth is too deep.' : KeyCount<ExcludeEmpty<NonNullable<PickSelection<Full, Selection, Depth>>>> extends 1 ? Selection[keyof PickSelection<Full, Selection, Depth>] extends GenericSelectionSet ? PickCollapsedSelection<NonNullable<Full[keyof PickSelection<Full, Selection, Depth>]>, Selection[keyof PickSelection<Full, Selection, Depth>], TsRecurse<Depth>> | Extract<Full[keyof PickSelection<Full, Selection, Depth>], undefined | null> : PropertyValueType<PickSelection<Full, Selection, Depth>> : PickSelection<Full, Selection, Depth>;
-/** Defines a selection set for the given object. */
-export type SelectionSet<Full extends Readonly<AnyObject>, Depth extends TsRecursionTracker = TsRecursionStart> = IsAny<Full> extends true ? any : Depth extends TsTooMuchRecursion ? boolean : Full extends ReadonlyArray<infer FullChild extends AnyObject> ? SelectionSet<FullChild, TsRecurse<Depth>> : Partial<{
-    [Key in keyof Full]: IsNever<Exclude<Full[Key], SelectionTypesToPreserve>> extends true ? boolean : UnionToIntersection<SelectionSet<NonNullable<Required<Full>[Key]>, TsRecurse<Depth>>> | boolean;
-}>;
-export declare function selectFrom<Full extends AnyObject, const Selection extends SelectionSet<NoInfer<Full>>>(originalObject: Readonly<Full>, selectionSet: Readonly<Selection>): PickSelection<Full, Selection>;
-export declare function selectCollapsedFrom<Full extends AnyObject, const Selection extends SelectionSet<NoInfer<Full>>>(originalObject: Readonly<Full>, selectionSet: Readonly<Selection>): PickCollapsedSelection<Full, Selection>;

package/dist/types/augments/object/typed-has-property.d.ts

@@ -1,7 +0,0 @@
-import { RequiredBy } from '../type';
-type ExtractValue<KeyGeneric extends PropertyKey, ParentGeneric> = KeyGeneric extends keyof ParentGeneric ? RequiredBy<ParentGeneric, KeyGeneric>[KeyGeneric] : KeyGeneric extends keyof Extract<ParentGeneric, Record<KeyGeneric, any>> ? RequiredBy<Extract<ParentGeneric, Record<KeyGeneric, any>>, KeyGeneric>[KeyGeneric] : never;
-type CombinedParentValue<KeyGeneric extends PropertyKey, ParentGeneric> = ExtractValue<KeyGeneric, ParentGeneric> extends never ? unknown : ExtractValue<KeyGeneric, ParentGeneric>;
-type CombineTypeWithKey<KeyGeneric extends PropertyKey, ParentGeneric> = ParentGeneric & Record<KeyGeneric, CombinedParentValue<KeyGeneric, ParentGeneric>>;
-export declare function typedHasProperty<KeyGeneric extends PropertyKey, ParentGeneric>(inputObject: ParentGeneric, inputKey: KeyGeneric): inputObject is CombineTypeWithKey<KeyGeneric, ParentGeneric>;
-export declare function typedHasProperties<KeyGeneric extends PropertyKey, ParentGeneric>(inputObject: ParentGeneric, inputKeys: ReadonlyArray<KeyGeneric>): inputObject is CombineTypeWithKey<KeyGeneric, ParentGeneric>;
-export {};

package/dist/types/augments/promise/deferred-promise.d.ts

@@ -1,8 +0,0 @@
-/** A promise which can be resolved or rejected by external code. */
-export type DeferredPromiseWrapper<T> = {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-    isSettled: () => boolean;
-};
-export declare function createDeferredPromiseWrapper<T = void>(): DeferredPromiseWrapper<T>;

package/dist/types/augments/promise/promise.d.ts

@@ -1,15 +0,0 @@
-export declare function isPromiseLike<T>(input: T | unknown): input is T extends PromiseLike<infer ValueType> ? PromiseLike<ValueType> : PromiseLike<unknown>;
-export type MaybePromise<T> = Promise<T> | T;
-export declare class PromiseTimeoutError extends Error {
-    readonly durationMs: number;
-    readonly message: string;
-    readonly name = "PromiseTimeoutError";
-    constructor(durationMs: number, message?: string);
-}
-export declare function wrapPromiseInTimeout<PromiseValueType>(durationMs: number, originalPromise: PromiseLike<PromiseValueType>): Promise<PromiseValueType>;
-/**
- * Call a function asynchronously without interrupting current synchronous execution, even if the
- * function was originally synchronous.
- */
-export declare function callAsynchronously<T>(callback: () => MaybePromise<T>): Promise<T>;
-export declare function executeWithRetries<T>(retryCount: number, callback: () => T): Promise<T>;

package/dist/types/augments/promise/wait.d.ts

@@ -1,18 +0,0 @@
-import { FalsyTypes } from '../boolean';
-export declare function wait(delayMs: number): Promise<void>;
-export declare function waitValue<ResolutionValue>(delayMs: number, returnValue: ResolutionValue): Promise<ResolutionValue>;
-export type WaitUntilTruthyOptions = {
-    interval: {
-        milliseconds: number;
-    };
-    timeout: {
-        milliseconds: number;
-    };
-};
-export declare const defaultWaitUntilDefinedOptions: WaitUntilTruthyOptions;
-/**
- * Runs the predicate until it returns a truthy value, then returns that value. Use the options
- * input to modify the timeout and interval durations. Automatically catches errors and handles
- * async predicates.
- */
-export declare function waitUntilTruthy<Value>(predicate: () => Value | Promise<Value> | FalsyTypes, failureMessage?: string | undefined, optionsInput?: Partial<WaitUntilTruthyOptions>): Promise<Awaited<Value>>;

package/dist/types/augments/random.d.ts

@@ -1,39 +0,0 @@
-/**
- * Creates a random integer (decimal points are all cut off) between the given min and max
- * (inclusive).
- *
- * This function uses cryptographically secure randomness.
- */
-export declare function randomInteger({ min: rawMin, max: rawMax }: {
-    min: number;
-    max: number;
-}): number;
-/**
- * Returns true at rate of the percentLikelyToBeTrue input. Inputs should be whole numbers which
- * will be treated like percents. Anything outside of 0-100 inclusively will be clamped. An input 0
- * will always return true. An input of 100 will always return true. Decimals on the input will be
- * chopped off, use whole numbers.
- *
- * This function uses cryptographically secure randomness.
- *
- * @example
- *     randomBoolean(50); // 50% chance to return true
- *
- * @example
- *     randomBoolean(0); // always false, 0% chance of being true
- *
- * @example
- *     randomBoolean(100); // always true, 100% chance of being true
- *
- * @example
- *     randomBoolean(59.67; // 59% chance of being true
- */
-export declare function randomBoolean(percentLikelyToBeTrue?: number): boolean;
-/** Creates a cryptographically secure uuid. */
-export declare function createUuid(): `${string}-${string}-${string}-${string}-${string}`;
-/**
- * Creates a random string (including letters and numbers) of a given length.
- *
- * This function uses cryptographically secure randomness.
- */
-export declare function randomString(inputLength?: number): string;

package/dist/types/augments/string/suffixes.d.ts

@@ -1,17 +0,0 @@
-export type WithSuffix<Suffix extends string> = `${string}${Suffix}`;
-export declare const percentSuffix: "%";
-export declare const pxSuffix: "px";
-export type WithPx = WithSuffix<typeof pxSuffix>;
-export type WithPercent = WithSuffix<typeof percentSuffix>;
-export declare function addPx(input: number | string): WithPx;
-export declare function removePx(input: string): number;
-export declare function addPercent(input: number | string): WithPercent;
-export declare function removePercent(input: string): number;
-export declare function addSuffix<const Suffix extends string>({ value, suffix, }: {
-    value: unknown;
-    suffix: Suffix;
-}): WithSuffix<Suffix>;
-export declare function removeSuffix<const Suffix extends string>({ value, suffix, }: {
-    value: WithSuffix<Suffix> | string;
-    suffix: Suffix;
-}): string;

package/dist/types/augments/string/uuid.d.ts

@@ -1 +0,0 @@
-export declare function isUuid(maybeUuid: string): boolean;

package/dist/types/augments/time.d.ts

@@ -1,14 +0,0 @@
-/**
- * Measures how long (in milliseconds) the given callback takes to run to completion. Automatically
- * switches to async mode and awaits callbacks if they return a promise (otherwise this function is
- * purely synchronous).
- */
-export declare function timeCallback<T>(callback: () => T): T extends Promise<any> ? Promise<number> : number;
-/**
- * Measures how long (in milliseconds) the given callback takes to run to completion. Automatically
- * switches to async mode and awaits callbacks if they return a promise (otherwise this function is
- * purely synchronous).
- *
- * Alias of timeCallback.
- */
-export declare const measureCallbackDuration: typeof timeCallback;

package/dist/types/augments/tuple.d.ts

@@ -1,17 +0,0 @@
-export type Tuple<ArrayElementGeneric, LengthGeneric extends number> = LengthGeneric extends LengthGeneric ? number extends LengthGeneric ? ArrayElementGeneric[] : _TupleOf<ArrayElementGeneric, LengthGeneric, []> : never;
-type _TupleOf<ArrayElementGeneric, LengthGeneric extends number, FullArrayGeneric extends unknown[]> = FullArrayGeneric['length'] extends LengthGeneric ? FullArrayGeneric : _TupleOf<ArrayElementGeneric, LengthGeneric, [ArrayElementGeneric, ...FullArrayGeneric]>;
-export type AtLeastTuple<ArrayElementGeneric, LengthGeneric extends number> = readonly [
-    ...Tuple<ArrayElementGeneric, LengthGeneric>,
-    ...ArrayElementGeneric[]
-];
-export declare function isLengthAtLeast<ArrayElementGeneric, LengthGeneric extends number>(array: ReadonlyArray<ArrayElementGeneric | undefined>, length: LengthGeneric): array is AtLeastTuple<ArrayElementGeneric, LengthGeneric>;
-export declare function assertLengthAtLeast<ArrayElementGeneric, LengthGeneric extends number>(array: ReadonlyArray<ArrayElementGeneric | undefined>, length: LengthGeneric, arrayName?: string): asserts array is AtLeastTuple<ArrayElementGeneric, LengthGeneric>;
-export type MappedTuple<Tuple extends ReadonlyArray<any>, NewValueType> = {
-    [I in keyof Tuple]: NewValueType;
-};
-export type MaybeTuple<T> = T | AtLeastTuple<T, 1>;
-export type RemoveFirstTupleEntry<T extends ReadonlyArray<unknown>> = T extends readonly [
-    firstArg: unknown,
-    ...theRest: infer TheRest
-] ? TheRest : T;
-export {};

package/dist/types/augments/type.d.ts

@@ -1,69 +0,0 @@
-import { Except, Simplify } from 'type-fest';
-/** Makes all properties in an object writable. This is the opposite of Readonly<> */
-export type Writeable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-/** Makes all property values in an object also readonly. Can cause issues on primitive. */
-export type DeepWriteable<T> = {
-    -readonly [P in keyof T]: DeepWriteable<T[P]>;
-};
-/** Replace properties in T with properties in U. */
-export type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
-/**
- * Require that the NonVoid parameter is not void. If it is void, the ErrorType or an error string
- * type is returned. If it not void, the given SuccessType is returned.
- */
-export type RequireNonVoid<NonVoid, SuccessType, ErrorType = 'Input should not be void'> = void extends NonVoid ? (NonVoid extends void ? ErrorType : SuccessType) : SuccessType;
-/** Extract the element type out of an array type. */
-export type ArrayElement<ArrayType extends ReadonlyArray<any>> = ArrayType[number];
-/**
- * Same as the Required<> built-in type helper but this requires that each property be present and
- * be not null.
- */
-export type RequiredAndNotNull<T> = {
-    [P in keyof T]-?: NonNullable<T[P]>;
-};
-export type SetOptionalAndNullable<OriginalObjectGeneric, OptionalKeysGeneric extends keyof OriginalObjectGeneric> = Simplify<Except<OriginalObjectGeneric, OptionalKeysGeneric> & {
-    [PropKey in OptionalKeysGeneric]?: OriginalObjectGeneric[PropKey] | null | undefined;
-}>;
-/** Require only a subset of object properties. */
-export type RequiredBy<T, K extends keyof T> = Overwrite<T, Required<Pick<T, K>>>;
-export declare function makeWritable<T>(input: T): Writeable<T>;
-export declare function makeReadonly<T>(input: T): Readonly<T>;
-/**
- * Require only a subset of object properties and require that they be not null. This is
- * particularly useful in conjunction with the "exactOptionalPropertyTypes" tsconfig flag.
- */
-export type RequiredAndNotNullBy<T, K extends keyof T> = Omit<T, K> & Required<{
-    [PropertyName in K]: NonNullable<T[PropertyName]>;
-}>;
-/** If type T = type U, then type Y. Else type N. */
-export type IfEquals<T, U, Y = unknown, N = never> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? Y : N;
-/**
- * This function returns another function that simply returns whatever input it's given. However, it
- * also checks that the input matches the original wrapNarrowTypeWithTypeCheck's generic, while
- * maintaining strict "const" like typing.
- *
- * Use like this: wrapNarrowTypeWithTypeCheck<EnforcedTypeHere>()(valueToEnforceTypeOn as const)
- *
- * Sometimes "as const" isn't required, usually it is for any object or array though.
- */
-export declare function wrapNarrowTypeWithTypeCheck<P>(): <T extends P>(input: T) => Readonly<T>;
-/**
- * This type helper is useful for forcing function generics to be explicitly provided, rather than
- * inferring them from the given inputs. See the test file for examples.
- */
-export type NoInfer<T> = [T][T extends any ? 0 : never];
-/**
- * This is a type helper that ensures the given input matches the given generic type. The generic is
- * setup in such a way that if it is omitted (which is typically allowed in TypeScript, resulting in
- * the generic being inferred from the inputs), there will actually be a type error. This forces
- * each usage of this function to explicitly specify the generic, thus giving us type safety for the
- * input.
- */
-export declare function ensureType<ExpectedType = never>(input: NoInfer<ExpectedType>): NoInfer<ExpectedType>;
-/** Picks only the public properties of a type. */
-export type Public<T> = {
-    [P in keyof T]: T[P];
-};
-export type Digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;

package/dist/types/augments/union.d.ts

@@ -1,5 +0,0 @@
-/**
- * This is the version of UnionToIntersection from type-fest v4.3.3. In version 4.4.0 type-fest
- * changed this type helper and it broke how we're using it.
- */
-export type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : never;

package/dist/types/index.d.ts

@@ -1,44 +0,0 @@
-export * from './augments/ansi';
-export * from './augments/array/array';
-export * from './augments/array/remove-duplicates';
-export * from './augments/async';
-export * from './augments/boolean';
-export * from './augments/common-number';
-export * from './augments/common-string';
-export * from './augments/debounce';
-export * from './augments/environment';
-export * from './augments/error';
-export * from './augments/esm-path';
-export * from './augments/function';
-export * from './augments/json';
-export * from './augments/json-compatible';
-export * from './augments/object/any-object';
-export * from './augments/object/enum';
-export * from './augments/object/filter-object';
-export * from './augments/object/get-or-set';
-export * from './augments/object/has-key';
-export * from './augments/object/jsonify';
-export * from './augments/object/key-count';
-export * from './augments/object/map-object';
-export * from './augments/object/merge-deep';
-export * from './augments/object/merge-property-arrays';
-export * from './augments/object/object';
-export * from './augments/object/object-entries';
-export * from './augments/object/pick-deep';
-export * from './augments/object/selection-set';
-export * from './augments/object/typed-has-property';
-export * from './augments/promise/deferred-promise';
-export * from './augments/promise/promise';
-export * from './augments/promise/wait';
-export * from './augments/random';
-export * from './augments/regexp';
-export * from './augments/string/prefixes';
-export * from './augments/string/suffixes';
-export * from './augments/string/uuid';
-export * from './augments/time';
-export * from './augments/truncate-number';
-export * from './augments/tuple';
-export * from './augments/type';
-export * from './augments/type-recursion';
-export * from './augments/union';
-export * from './augments/wrap-in-try';