@augment-vir/common 29.3.0 → 30.0.1

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/esm-path.d.ts

@@ -1,4 +0,0 @@
-export declare function getEsmPath(importMeta: ImportMeta): {
-    filePath: string;
-    dirPath: string;
-};

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-compatible.d.ts

@@ -1,22 +0,0 @@
-import { Jsonify, Primitive } from 'type-fest';
-/**
- * These are similar in purpose, name, and structure to type-fest's JsonValue types but these are
- * permissive. The goal here is to allow any types that do not get serialized into just empty
- * objects. (For example, JSON.stringify(new Map()) returns "{}", so we don't want to allow that
- * type.)
- */
-export type JsonCompatiblePrimitiveValue = Jsonify<Primitive> | undefined;
-export type JsonCompatibleObject = Partial<{
-    readonly [key: string | number]: JsonCompatibleValue | Readonly<JsonCompatibleValue>;
-}> | Partial<{
-    [key: string | number]: JsonCompatibleValue | Readonly<JsonCompatibleValue>;
-}>;
-export type JsonCompatibleArray = JsonCompatibleValue[]
-/**
- * This weird readonly with object syntax for an array type is so that TypeScript doesn't
- * complain about JsonCompatibleArray circularly referencing itself
- */
- | ({
-    readonly [P in number]: JsonCompatibleValue;
-} & ReadonlyArray<any>);
-export type JsonCompatibleValue = JsonCompatiblePrimitiveValue | JsonCompatibleObject | JsonCompatibleArray;

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/key-count.d.ts

@@ -1,13 +0,0 @@
-import { UnionToIntersection } from '../union';
-import { AnyObject } from './any-object';
-/**
- * This is not exported because its order is not stable but it's okay for our simple use case where
- * we simply want to count the size of the union.
- */
-type UnionToTuple<T> = UnionToIntersection<T extends any ? (t: T) => T : never> extends (args: any) => infer W ? [...UnionToTuple<Exclude<T, W>>, W] : [];
-/**
- * Counts the number of unique keys in an object type. Note that a key of just `string` will count
- * as 1.
- */
-export type KeyCount<T extends AnyObject> = UnionToTuple<keyof T>['length'];
-export {};

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

@@ -1,20 +0,0 @@
-import { PropertyValueType } from './object';
-export type InnerMappedValues<EntireInputGeneric extends object, MappedValueGeneric> = {
-    [MappedProp in keyof EntireInputGeneric]: MappedValueGeneric;
-};
-export type MappedValues<EntireInputGeneric extends object, MappedValueGeneric> = MappedValueGeneric extends PromiseLike<unknown> ? Promise<InnerMappedValues<EntireInputGeneric, Awaited<MappedValueGeneric>>> : InnerMappedValues<EntireInputGeneric, Awaited<MappedValueGeneric>>;
-/**
- * Map an object's keys to new values synchronously. This is different from plain mapObjectValues in
- * that this will not wrap the return value in a promise if any of the new object values are
- * promises. This function also requires currying in order to get the types correct. This allows you
- * to explicitly state the return type.
- *
- * @example
- *     mapObjectValuesSync({objectToIterateOver: 'initial value'})(callback);
- */
-export declare function mapObjectValuesSync<EntireInputGeneric extends object>(inputObject: EntireInputGeneric): <OutputObjectGeneric extends object>(mapCallback: (inputKey: keyof EntireInputGeneric, keyValue: Required<EntireInputGeneric>[typeof inputKey], fullObject: EntireInputGeneric) => never extends PropertyValueType<OutputObjectGeneric> ? any : PropertyValueType<OutputObjectGeneric>) => OutputObjectGeneric;
-/**
- * Creates a new object with the same properties as the input object, but with values set to the
- * result of mapCallback for each property.
- */
-export declare function mapObjectValues<EntireInputGeneric extends object, MappedValueGeneric>(inputObject: EntireInputGeneric, mapCallback: (inputKey: keyof EntireInputGeneric, keyValue: Required<EntireInputGeneric>[typeof inputKey], fullObject: EntireInputGeneric) => MappedValueGeneric): MappedValues<EntireInputGeneric, MappedValueGeneric>;

package/dist/types/augments/object/merge-property-arrays.d.ts

@@ -1 +0,0 @@
-export declare function mergePropertyArrays<T extends Record<PropertyKey, unknown[]>>(...inputs: ReadonlyArray<Readonly<T>>): T;

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,37 +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 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/regexp.d.ts

@@ -1,3 +0,0 @@
-export declare function deDupeRegExFlags(flags: string): string;
-export declare function addRegExpFlags(originalRegExp: RegExp, flags: string): RegExp;
-export declare function safeMatch(input: string, regExp: RegExp): string[];

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

@@ -1,9 +0,0 @@
-export type WithPrefix<Prefix extends string> = `${Prefix}${string}`;
-export declare function addPrefix<const Prefix extends string>({ value, prefix, }: {
-    value: unknown;
-    prefix: Prefix;
-}): WithPrefix<Prefix>;
-export declare function removePrefix<const Prefix extends string>({ value, prefix, }: {
-    value: WithPrefix<Prefix> | string;
-    prefix: Prefix;
-}): 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,5 +0,0 @@
-export type UuidV4 = ReturnType<typeof createUuid>;
-/** Checks if the input string is a valid v4 UUID. */
-export declare function isUuid(maybeUuid: string): boolean;
-/** Creates a cryptographically secure v4 UUID using `crypto.randomUUID`. */
-export declare function createUuid(): `${string}-${string}-${string}-${string}-${string}`;

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/truncate-number.d.ts

@@ -1,19 +0,0 @@
-/**
- * This truncates a number such that is will at a max have 6 characters including suffix, decimal
- * point, or comma.
- *
- * Default suffixes are:
- *
- *     'k', // thousand
- *     'M', // million
- *     'B', // billion
- *     'T', // trillion
- *     'P', // peta-, quadrillion
- *     'E', // exa- quintillion
- *     'Z', // zetta- sextillion
- *     'Y', // yotta- septillion
- */
-export declare function truncateNumber(originalValue: Readonly<unknown>, { customSuffixes, maxLength, }?: Partial<{
-    customSuffixes: ReadonlyArray<string> | undefined;
-    maxLength: number | undefined;
-}>): string;

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 {};