@stryke/types 0.10.23 → 0.10.25

package/dist/array.d.cts

@@ -1,2 +1,122 @@
-import { a as Arrayable, c as StaticPartOfArray, d as UnknownArrayOrTuple, f as VariablePartOfArray, i as ArrayValues, l as TypedArray, n as ArrayIndices, o as FirstArrayElement, r as ArrayLength, s as LastArrayElement, t as ArrayElement, u as UnknownArray } from "./array-DtIKbcDr.cjs";
-export { ArrayElement, ArrayIndices, ArrayLength, ArrayValues, Arrayable, FirstArrayElement, LastArrayElement, StaticPartOfArray, TypedArray, UnknownArray, UnknownArrayOrTuple, VariablePartOfArray };
+//#region src/array.d.ts
+/**
+ * Matches any array or array-like object.
+ */
+type Arrayable<T> = T | T[];
+type UnknownArray = readonly unknown[];
+/**
+ * Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
+ */
+type TypedArray = BigInt64Array | BigUint64Array | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
+/**
+ * Infer the length of the given array `<T>`.
+ *
+ * Check out {@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f | this article} for more information.
+ */
+type ArrayLength<T extends readonly unknown[]> = T extends {
+  readonly length: infer L;
+} ? L : never;
+/**
+ * Extract the element of an array that also works for array union.
+ *
+ * Returns `never` if T is not an array.
+ *
+ * It creates a type-safe way to access the element type of `unknown` type.
+ */
+type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
+/**
+ * Provides all values for a constant array or tuple.
+ *
+ * Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety with their values.
+ *
+ * @example
+ * ```
+ * import type {ArrayValues, ArrayIndices} from 'type-fest';
+ *
+ * const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+ *
+ * type WeekdayName = ArrayValues<typeof weekdays>;
+ * type Weekday = ArrayIndices<typeof weekdays>;
+ *
+ * const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+ * ```
+ *
+ * @see {@link ArrayIndices}
+ */
+type ArrayValues<T extends readonly unknown[]> = T[number];
+/**
+ * Provides valid indices for a constant array or tuple.
+ *
+ * Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety for accessing elements by their indices.
+ *
+ * @example
+ * ```
+ * import type {ArrayIndices, ArrayValues} from 'type-fest';
+ *
+ * const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+ *
+ * type Weekday = ArrayIndices<typeof weekdays>;
+ * type WeekdayName = ArrayValues<typeof weekdays>;
+ *
+ * const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+ * ```
+ *
+ * @see {@link ArrayValues}
+ */
+type ArrayIndices<Element extends readonly unknown[]> = Exclude<Partial<Element>["length"], Element["length"]>;
+/**
+ * Matches any unknown array or tuple.
+ */
+type UnknownArrayOrTuple = readonly [...unknown[]];
+/**
+ * Extracts the type of the first element of an array or tuple.
+ */
+type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray extends readonly [infer THead, ...unknown[]] ? THead : never;
+/**
+ * Extracts the type of the last element of an array.
+ *
+ * Use-case: Defining the return type of functions that extract the last element of an array, for example [`lodash.last`](https://lodash.com/docs/4.17.15#last).
+ *
+ * @example
+ * ```
+ * import type {LastArrayElement} from 'type-fest';
+ *
+ * declare function lastOf<V extends readonly any[]>(array: V): LastArrayElement<V>;
+ *
+ * const array = ['foo', 2];
+ *
+ * typeof lastOf(array);
+ * //=> number
+ *
+ * const array = ['foo', 2] as const;
+ *
+ * typeof lastOf(array);
+ * //=> 2
+ * ```
+ */
+type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> = Elements extends readonly [] ? ElementBeforeTailingSpreadElement : Elements extends readonly [...infer _U, infer V] ? V : Elements extends readonly [infer U, ...infer V] ? LastArrayElement<V, U> : Elements extends readonly (infer U)[] ? ElementBeforeTailingSpreadElement | U : never;
+/**
+ * Returns the static, fixed-length portion of the given array, excluding variable-length parts.
+ *
+ * @example
+ * ```
+ * type A = [string, number, boolean, ...string[]];
+ * type B = StaticPartOfArray<A>;
+ * //=> [string, number, boolean]
+ * ```
+ */
+type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> = T extends unknown ? number extends T["length"] ? T extends readonly [infer U, ...infer V] ? StaticPartOfArray<V, [...Result, U]> : Result : T : never;
+/**
+ * Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
+ *
+ * @example
+ * ```
+ * type A = [string, number, boolean, ...string[]];
+ * type B = VariablePartOfArray<A>;
+ * //=> string[]
+ * ```
+ */
+type VariablePartOfArray<T extends UnknownArray> = T extends unknown ? T extends readonly [...StaticPartOfArray<T>, ...infer U] ? U : [] : never;
+//#endregion
+export { ArrayElement, ArrayIndices, ArrayLength, ArrayValues, Arrayable, FirstArrayElement, LastArrayElement, StaticPartOfArray, TypedArray, UnknownArray, UnknownArrayOrTuple, VariablePartOfArray };
+//# sourceMappingURL=array.d.cts.map

package/dist/array.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.cts","names":[],"sources":["../src/array.ts"],"sourcesContent":[],"mappings":";;AAqBA;AAEA;AAKY,KAPA,SAOU,CAAA,CAAA,CAAA,GAPK,CAOL,GAPS,CAOT,EAAA;AAClB,KANQ,YAAA,GAMR,SAAA,OAAA,EAAA;;;;AAIA,KALQ,UAAA,GACR,aAIA,GAHA,cAGA,GAFA,YAEA,GADA,YACA,GAAA,SAAA,GACA,UADA,GAEA,UAFA,GAGA,UAHA,GAIA,iBAJA,GAKA,WALA,GAMA,WANA;;;;;;AAMA,KAOQ,WAPR,CAAA,UAAA,SAAA,OAAA,EAAA,CAAA,GAOoD,CAPpD,SAAA;EAAW,SAAA,MAAA,EAAA,KAAA,EAAA;AAOf,CAAA,GAAY,CAAA,GAAA,KAAA;AAaZ;AAqBA;AAqBA;;;;;AAAsE,KA1C1D,YA0C0D,CAAA,CAAA,CAAA,GA1CxC,CA0CwC,SAAA,SAAA,OAAA,EAAA,GA1CT,CA0CS,CAAA,CAAA,CAAA,GAAA,KAAA;AAQtE;AAKA;AAyBA;;;;;;;;;;;;AA2BA;;;;;AAKM,KA3FM,WA2FN,CAAA,UAAA,SAAA,OAAA,EAAA,CAAA,GA3FkD,CA2FlD,CAAA,MAAA,CAAA;;;;;;;;AAgBN;;;;;;;;;;;;KAtFY,mDAAmD,QAC7D,QAAQ,oBACR;;;;KAMU,mBAAA;;;;KAKA,iCAAiC,uBAC3C;;;;;;;;;;;;;;;;;;;;;;;KAwBU,mGAKV,+BACI,oCACA,uDAEE,kDAGE,iBAAiB,GAAG,KACpB,wCACE,oCAAoC;;;;;;;;;;;KAapC,4BACA,6BACK,qBACb,mCACe,cACb,2CACE,kBAAkB,OAAO,QAAQ,MACjC,SACF;;;;;;;;;;;KAaM,8BAA8B,gBAAgB,oBACtD,uBAAuB,kBAAkB"}

package/dist/array.d.mts

@@ -1,2 +1,122 @@
-import { a as Arrayable, c as StaticPartOfArray, d as UnknownArrayOrTuple, f as VariablePartOfArray, i as ArrayValues, l as TypedArray, n as ArrayIndices, o as FirstArrayElement, r as ArrayLength, s as LastArrayElement, t as ArrayElement, u as UnknownArray } from "./array-DVtfX_TI.mjs";
-export { ArrayElement, ArrayIndices, ArrayLength, ArrayValues, Arrayable, FirstArrayElement, LastArrayElement, StaticPartOfArray, TypedArray, UnknownArray, UnknownArrayOrTuple, VariablePartOfArray };
+//#region src/array.d.ts
+/**
+ * Matches any array or array-like object.
+ */
+type Arrayable<T> = T | T[];
+type UnknownArray = readonly unknown[];
+/**
+ * Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
+ */
+type TypedArray = BigInt64Array | BigUint64Array | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
+/**
+ * Infer the length of the given array `<T>`.
+ *
+ * Check out {@link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f | this article} for more information.
+ */
+type ArrayLength<T extends readonly unknown[]> = T extends {
+  readonly length: infer L;
+} ? L : never;
+/**
+ * Extract the element of an array that also works for array union.
+ *
+ * Returns `never` if T is not an array.
+ *
+ * It creates a type-safe way to access the element type of `unknown` type.
+ */
+type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
+/**
+ * Provides all values for a constant array or tuple.
+ *
+ * Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety with their values.
+ *
+ * @example
+ * ```
+ * import type {ArrayValues, ArrayIndices} from 'type-fest';
+ *
+ * const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+ *
+ * type WeekdayName = ArrayValues<typeof weekdays>;
+ * type Weekday = ArrayIndices<typeof weekdays>;
+ *
+ * const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+ * ```
+ *
+ * @see {@link ArrayIndices}
+ */
+type ArrayValues<T extends readonly unknown[]> = T[number];
+/**
+ * Provides valid indices for a constant array or tuple.
+ *
+ * Use-case: This type is useful when working with constant arrays or tuples and you want to enforce type-safety for accessing elements by their indices.
+ *
+ * @example
+ * ```
+ * import type {ArrayIndices, ArrayValues} from 'type-fest';
+ *
+ * const weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] as const;
+ *
+ * type Weekday = ArrayIndices<typeof weekdays>;
+ * type WeekdayName = ArrayValues<typeof weekdays>;
+ *
+ * const getWeekdayName = (day: Weekday): WeekdayName => weekdays[day];
+ * ```
+ *
+ * @see {@link ArrayValues}
+ */
+type ArrayIndices<Element extends readonly unknown[]> = Exclude<Partial<Element>["length"], Element["length"]>;
+/**
+ * Matches any unknown array or tuple.
+ */
+type UnknownArrayOrTuple = readonly [...unknown[]];
+/**
+ * Extracts the type of the first element of an array or tuple.
+ */
+type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray extends readonly [infer THead, ...unknown[]] ? THead : never;
+/**
+ * Extracts the type of the last element of an array.
+ *
+ * Use-case: Defining the return type of functions that extract the last element of an array, for example [`lodash.last`](https://lodash.com/docs/4.17.15#last).
+ *
+ * @example
+ * ```
+ * import type {LastArrayElement} from 'type-fest';
+ *
+ * declare function lastOf<V extends readonly any[]>(array: V): LastArrayElement<V>;
+ *
+ * const array = ['foo', 2];
+ *
+ * typeof lastOf(array);
+ * //=> number
+ *
+ * const array = ['foo', 2] as const;
+ *
+ * typeof lastOf(array);
+ * //=> 2
+ * ```
+ */
+type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> = Elements extends readonly [] ? ElementBeforeTailingSpreadElement : Elements extends readonly [...infer _U, infer V] ? V : Elements extends readonly [infer U, ...infer V] ? LastArrayElement<V, U> : Elements extends readonly (infer U)[] ? ElementBeforeTailingSpreadElement | U : never;
+/**
+ * Returns the static, fixed-length portion of the given array, excluding variable-length parts.
+ *
+ * @example
+ * ```
+ * type A = [string, number, boolean, ...string[]];
+ * type B = StaticPartOfArray<A>;
+ * //=> [string, number, boolean]
+ * ```
+ */
+type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArray = []> = T extends unknown ? number extends T["length"] ? T extends readonly [infer U, ...infer V] ? StaticPartOfArray<V, [...Result, U]> : Result : T : never;
+/**
+ * Returns the variable, non-fixed-length portion of the given array, excluding static-length parts.
+ *
+ * @example
+ * ```
+ * type A = [string, number, boolean, ...string[]];
+ * type B = VariablePartOfArray<A>;
+ * //=> string[]
+ * ```
+ */
+type VariablePartOfArray<T extends UnknownArray> = T extends unknown ? T extends readonly [...StaticPartOfArray<T>, ...infer U] ? U : [] : never;
+//#endregion
+export { ArrayElement, ArrayIndices, ArrayLength, ArrayValues, Arrayable, FirstArrayElement, LastArrayElement, StaticPartOfArray, TypedArray, UnknownArray, UnknownArrayOrTuple, VariablePartOfArray };
+//# sourceMappingURL=array.d.mts.map

package/dist/array.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.mts","names":[],"sources":["../src/array.ts"],"sourcesContent":[],"mappings":";;AAqBA;AAEA;AAKY,KAPA,SAOU,CAAA,CAAA,CAAA,GAPK,CAOL,GAPS,CAOT,EAAA;AAClB,KANQ,YAAA,GAMR,SAAA,OAAA,EAAA;;;;AAIA,KALQ,UAAA,GACR,aAIA,GAHA,cAGA,GAFA,YAEA,GADA,YACA,GAAA,SAAA,GACA,UADA,GAEA,UAFA,GAGA,UAHA,GAIA,iBAJA,GAKA,WALA,GAMA,WANA;;;;;;AAMA,KAOQ,WAPR,CAAA,UAAA,SAAA,OAAA,EAAA,CAAA,GAOoD,CAPpD,SAAA;EAAW,SAAA,MAAA,EAAA,KAAA,EAAA;AAOf,CAAA,GAAY,CAAA,GAAA,KAAA;AAaZ;AAqBA;AAqBA;;;;;AAAsE,KA1C1D,YA0C0D,CAAA,CAAA,CAAA,GA1CxC,CA0CwC,SAAA,SAAA,OAAA,EAAA,GA1CT,CA0CS,CAAA,CAAA,CAAA,GAAA,KAAA;AAQtE;AAKA;AAyBA;;;;;;;;;;;;AA2BA;;;;;AAKM,KA3FM,WA2FN,CAAA,UAAA,SAAA,OAAA,EAAA,CAAA,GA3FkD,CA2FlD,CAAA,MAAA,CAAA;;;;;;;;AAgBN;;;;;;;;;;;;KAtFY,mDAAmD,QAC7D,QAAQ,oBACR;;;;KAMU,mBAAA;;;;KAKA,iCAAiC,uBAC3C;;;;;;;;;;;;;;;;;;;;;;;KAwBU,mGAKV,+BACI,oCACA,uDAEE,kDAGE,iBAAiB,GAAG,KACpB,wCACE,oCAAoC;;;;;;;;;;;KAapC,4BACA,6BACK,qBACb,mCACe,cACb,2CACE,kBAAkB,OAAO,QAAQ,MACjC,SACF;;;;;;;;;;;KAaM,8BAA8B,gBAAgB,oBACtD,uBAAuB,kBAAkB"}

package/dist/async.d.cts

@@ -1,2 +1,111 @@
-import { a as Awaitable, i as Await, n as AsyncReturnType, o as Resolvable, r as Asyncify, s as SetReturnType, t as AsyncFunction } from "./async-eKWh-_sF.cjs";
-export { AsyncFunction, AsyncReturnType, Asyncify, Await, Awaitable, Resolvable, SetReturnType };
+import { FunctionLike, IsUnknown } from "./base.cjs";
+
+//#region src/async.d.ts
+
+/**
+ * Get the type of the value that a promise resolves to.
+ *
+ * @example
+ * ```
+ * import type {Awaited} from 'type-fest';
+ *
+ * const value: Awaited<Promise<string>> = 'foo';
+ * ```
+ */
+type Awaitable<T> = T | PromiseLike<T>;
+/**
+ * A type that can be either a value or a function that returns a value.
+ *
+ * @example
+ * ```
+ * import type {Resolvable} from 'type-fest';
+ *
+ * const foo: Resolvable<string> = 'bar';
+ * const bar: Resolvable<string> = () => 'baz';
+ * ```
+ */
+type Resolvable<T> = Awaitable<T> | (() => Awaitable<T>);
+/**
+ * Create a function type with a return type of your choice and the same parameters as the given function type.
+ *
+ * Use-case: You want to define a wrapped function that returns something different while receiving the same parameters. For example, you might want to wrap a function that can throw an error into one that will return `undefined` instead.
+ *
+ * @example
+ * ```
+ * import type {SetReturnType} from 'type-fest';
+ *
+ * type MyFunctionThatCanThrow = (foo: SomeType, bar: unknown) => SomeOtherType;
+ *
+ * type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | undefined>;
+ * //=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
+ * ```
+ */
+type SetReturnType<TFunct extends (...arguments_: any[]) => any, TypeToReturn> = TFunct extends ((this: infer ThisArgument, ...arguments_: infer Arguments) => any) ? IsUnknown<ThisArgument> extends true ? (...arguments_: Arguments) => TypeToReturn : (this: ThisArgument, ...arguments_: Arguments) => TypeToReturn : (...arguments_: Parameters<TFunct>) => TypeToReturn;
+type AsyncFunction = (...arguments_: any[]) => Promise<unknown>;
+/**
+ * Unwrap the return type of a function that returns a `Promise`.
+ *
+ * There has been [discussion](https://github.com/microsoft/TypeScript/pull/35998) about implementing this type in TypeScript.
+ *
+ * @example
+ * ```ts
+ * import type {AsyncReturnType} from 'type-fest';
+ * import {asyncFunction} from 'api';
+ *
+ * // This type resolves to the unwrapped return type of `asyncFunction`.
+ * type Value = AsyncReturnType<typeof asyncFunction>;
+ *
+ * async function doSomething(value: Value) {}
+ *
+ * asyncFunction().then(value => doSomething(value));
+ * ```
+ */
+type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;
+/**
+ * Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.
+ *
+ * Use-case: You have two functions, one synchronous and one asynchronous that do the same thing. Instead of having to duplicate the type definition, you can use `Asyncify` to reuse the synchronous type.
+ *
+ * @example
+ * ```
+ * import type {Asyncify} from 'type-fest';
+ *
+ * // Synchronous function.
+ * function getFooSync(someArg: SomeType): Foo {
+ *   // …
+ * }
+ *
+ * type AsyncifiedFooGetter = Asyncify<typeof getFooSync>;
+ * //=> type AsyncifiedFooGetter = (someArg: SomeType) => Promise<Foo>;
+ *
+ * // Same as `getFooSync` but asynchronous.
+ * const getFooAsync: AsyncifiedFooGetter = (someArg) => {
+ *   // TypeScript now knows that `someArg` is `SomeType` automatically.
+ *   // It also knows that this function must return `Promise<Foo>`.
+ *   // If you have `@typescript-eslint/promise-function-async` linter rule enabled, it will even report that "Functions that return promises must be async.".
+ *
+ *   // …
+ * }
+ * ```
+ */
+type Asyncify<TFunct extends FunctionLike> = SetReturnType<TFunct, Promise<Awaited<ReturnType<TFunct>>>>;
+/**
+ * Get the result type of a `Promise`
+ *
+ * @example
+ * ```ts
+ * import { Await } from '@stryke/types'
+ *
+ * const promise = new Promise<string>((res, rej) => res('x'))
+ *
+ * type test0 = C.Await<typeof promise>  // string
+ * type test1 = C.Await<Promise<number>> // number
+ * ```
+ *
+ * @param P - A promise
+ * @returns [[Any]]
+ */
+type Await<P> = P extends Promise<infer A> ? A : P;
+//#endregion
+export { AsyncFunction, AsyncReturnType, Asyncify, Await, Awaitable, Resolvable, SetReturnType };
+//# sourceMappingURL=async.d.cts.map

package/dist/async.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.cts","names":[],"sources":["../src/async.ts"],"sourcesContent":[],"mappings":";;;;;;AA8BA;;;;;AAaA;;;AAA4D,KAbhD,SAagD,CAAA,CAAA,CAAA,GAbjC,CAaiC,GAb7B,WAa6B,CAbjB,CAaiB,CAAA;;;AAiB5D;;;;;;;;;AAeiC,KAhCrB,UAgCqB,CAAA,CAAA,CAAA,GAhCL,SAgCK,CAhCK,CAgCL,CAAA,GAAA,CAAA,GAAA,GAhCiB,SAgCjB,CAhC2B,CAgC3B,CAAA,CAAA;;;;AAEjC;AAoBA;;;;;;AA+BA;;;;;AAEU,KAtEE,aAsEF,CAAA,eAAA,CAAA,GAAA,UAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,EAAA,YAAA,CAAA,GAjER,MAiEQ,UAAA,CAAA,IAAA,EAAA,KAAA,aAAA,EAAA,GAAA,UAAA,EAAA,KAAA,UAAA,EAAA,GAAA,GAAA,IA3DJ,SA2DI,CA3DM,YA2DN,CAAA,SAAA,IAAA,GAAA,CAAA,GAAA,UAAA,EA1Dc,SA0Dd,EAAA,GA1D4B,YA0D5B,GAAA,CAAA,IAAA,EAzDK,YAyDL,EAAA,GAAA,UAAA,EAzDkC,SAyDlC,EAAA,GAzDgD,YAyDhD,GAAA,CAAA,GAAA,UAAA,EAvDY,UAuDZ,CAvDuB,MAuDvB,CAAA,EAAA,GAvDmC,YAuDnC;AAAR,KArDU,aAAA,GAqDV,CAAA,GAAA,UAAA,EAAA,GAAA,EAAA,EAAA,GArDoD,OAqDpD,CAAA,OAAA,CAAA;;;AAmBF;;;;;;;;;;;;;;;;KApDY,+BAA+B,iBAAiB,QAC1D,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BD,wBAAwB,gBAAgB,cAClD,QACA,QAAQ,QAAQ,WAAW;;;;;;;;;;;;;;;;;KAmBjB,WAAW,UAAU,uBAAuB"}

package/dist/async.d.mts

@@ -1,2 +1,111 @@
-import { a as Awaitable, i as Await, n as AsyncReturnType, o as Resolvable, r as Asyncify, s as SetReturnType, t as AsyncFunction } from "./async-BtPWg6IL.mjs";
-export { AsyncFunction, AsyncReturnType, Asyncify, Await, Awaitable, Resolvable, SetReturnType };
+import { FunctionLike, IsUnknown } from "./base.mjs";
+
+//#region src/async.d.ts
+
+/**
+ * Get the type of the value that a promise resolves to.
+ *
+ * @example
+ * ```
+ * import type {Awaited} from 'type-fest';
+ *
+ * const value: Awaited<Promise<string>> = 'foo';
+ * ```
+ */
+type Awaitable<T> = T | PromiseLike<T>;
+/**
+ * A type that can be either a value or a function that returns a value.
+ *
+ * @example
+ * ```
+ * import type {Resolvable} from 'type-fest';
+ *
+ * const foo: Resolvable<string> = 'bar';
+ * const bar: Resolvable<string> = () => 'baz';
+ * ```
+ */
+type Resolvable<T> = Awaitable<T> | (() => Awaitable<T>);
+/**
+ * Create a function type with a return type of your choice and the same parameters as the given function type.
+ *
+ * Use-case: You want to define a wrapped function that returns something different while receiving the same parameters. For example, you might want to wrap a function that can throw an error into one that will return `undefined` instead.
+ *
+ * @example
+ * ```
+ * import type {SetReturnType} from 'type-fest';
+ *
+ * type MyFunctionThatCanThrow = (foo: SomeType, bar: unknown) => SomeOtherType;
+ *
+ * type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | undefined>;
+ * //=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
+ * ```
+ */
+type SetReturnType<TFunct extends (...arguments_: any[]) => any, TypeToReturn> = TFunct extends ((this: infer ThisArgument, ...arguments_: infer Arguments) => any) ? IsUnknown<ThisArgument> extends true ? (...arguments_: Arguments) => TypeToReturn : (this: ThisArgument, ...arguments_: Arguments) => TypeToReturn : (...arguments_: Parameters<TFunct>) => TypeToReturn;
+type AsyncFunction = (...arguments_: any[]) => Promise<unknown>;
+/**
+ * Unwrap the return type of a function that returns a `Promise`.
+ *
+ * There has been [discussion](https://github.com/microsoft/TypeScript/pull/35998) about implementing this type in TypeScript.
+ *
+ * @example
+ * ```ts
+ * import type {AsyncReturnType} from 'type-fest';
+ * import {asyncFunction} from 'api';
+ *
+ * // This type resolves to the unwrapped return type of `asyncFunction`.
+ * type Value = AsyncReturnType<typeof asyncFunction>;
+ *
+ * async function doSomething(value: Value) {}
+ *
+ * asyncFunction().then(value => doSomething(value));
+ * ```
+ */
+type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;
+/**
+ * Create an async version of the given function type, by boxing the return type in `Promise` while keeping the same parameter types.
+ *
+ * Use-case: You have two functions, one synchronous and one asynchronous that do the same thing. Instead of having to duplicate the type definition, you can use `Asyncify` to reuse the synchronous type.
+ *
+ * @example
+ * ```
+ * import type {Asyncify} from 'type-fest';
+ *
+ * // Synchronous function.
+ * function getFooSync(someArg: SomeType): Foo {
+ *   // …
+ * }
+ *
+ * type AsyncifiedFooGetter = Asyncify<typeof getFooSync>;
+ * //=> type AsyncifiedFooGetter = (someArg: SomeType) => Promise<Foo>;
+ *
+ * // Same as `getFooSync` but asynchronous.
+ * const getFooAsync: AsyncifiedFooGetter = (someArg) => {
+ *   // TypeScript now knows that `someArg` is `SomeType` automatically.
+ *   // It also knows that this function must return `Promise<Foo>`.
+ *   // If you have `@typescript-eslint/promise-function-async` linter rule enabled, it will even report that "Functions that return promises must be async.".
+ *
+ *   // …
+ * }
+ * ```
+ */
+type Asyncify<TFunct extends FunctionLike> = SetReturnType<TFunct, Promise<Awaited<ReturnType<TFunct>>>>;
+/**
+ * Get the result type of a `Promise`
+ *
+ * @example
+ * ```ts
+ * import { Await } from '@stryke/types'
+ *
+ * const promise = new Promise<string>((res, rej) => res('x'))
+ *
+ * type test0 = C.Await<typeof promise>  // string
+ * type test1 = C.Await<Promise<number>> // number
+ * ```
+ *
+ * @param P - A promise
+ * @returns [[Any]]
+ */
+type Await<P> = P extends Promise<infer A> ? A : P;
+//#endregion
+export { AsyncFunction, AsyncReturnType, Asyncify, Await, Awaitable, Resolvable, SetReturnType };
+//# sourceMappingURL=async.d.mts.map

package/dist/async.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.d.mts","names":[],"sources":["../src/async.ts"],"sourcesContent":[],"mappings":";;;;;;AA8BA;;;;;AAaA;;;AAA4D,KAbhD,SAagD,CAAA,CAAA,CAAA,GAbjC,CAaiC,GAb7B,WAa6B,CAbjB,CAaiB,CAAA;;;AAiB5D;;;;;;;;;AAeiC,KAhCrB,UAgCqB,CAAA,CAAA,CAAA,GAhCL,SAgCK,CAhCK,CAgCL,CAAA,GAAA,CAAA,GAAA,GAhCiB,SAgCjB,CAhC2B,CAgC3B,CAAA,CAAA;;;;AAEjC;AAoBA;;;;;;AA+BA;;;;;AAEU,KAtEE,aAsEF,CAAA,eAAA,CAAA,GAAA,UAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA,EAAA,YAAA,CAAA,GAjER,MAiEQ,UAAA,CAAA,IAAA,EAAA,KAAA,aAAA,EAAA,GAAA,UAAA,EAAA,KAAA,UAAA,EAAA,GAAA,GAAA,IA3DJ,SA2DI,CA3DM,YA2DN,CAAA,SAAA,IAAA,GAAA,CAAA,GAAA,UAAA,EA1Dc,SA0Dd,EAAA,GA1D4B,YA0D5B,GAAA,CAAA,IAAA,EAzDK,YAyDL,EAAA,GAAA,UAAA,EAzDkC,SAyDlC,EAAA,GAzDgD,YAyDhD,GAAA,CAAA,GAAA,UAAA,EAvDY,UAuDZ,CAvDuB,MAuDvB,CAAA,EAAA,GAvDmC,YAuDnC;AAAR,KArDU,aAAA,GAqDV,CAAA,GAAA,UAAA,EAAA,GAAA,EAAA,EAAA,GArDoD,OAqDpD,CAAA,OAAA,CAAA;;;AAmBF;;;;;;;;;;;;;;;;KApDY,+BAA+B,iBAAiB,QAC1D,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BD,wBAAwB,gBAAgB,cAClD,QACA,QAAQ,QAAQ,WAAW;;;;;;;;;;;;;;;;;KAmBjB,WAAW,UAAU,uBAAuB"}

package/dist/base.cjs

@@ -1 +1,3 @@
-const e=require(`./base-Cpeh4C5c.cjs`);exports.$NestedValue=e.t,exports.EMPTY_OBJECT=e.n,exports.EMPTY_STRING=e.r,exports.NEWLINE_STRING=e.i,exports.TYPE_ARGUMENTS=e.a,exports.TYPE_ARRAY=e.o,exports.TYPE_MAP=e.s,exports.TYPE_OBJECT=e.c,exports.TYPE_SET=e.l;
+const e=``,t=`\r
+`,n={},r=`Arguments`,i=`Array`,a=`Object`,o=`Map`,s=`Set`,c=Symbol(`NestedValue`);exports.$NestedValue=c,exports.EMPTY_OBJECT=n,exports.EMPTY_STRING=``,exports.NEWLINE_STRING=`\r
+`,exports.TYPE_ARGUMENTS=`Arguments`,exports.TYPE_ARRAY=`Array`,exports.TYPE_MAP=`Map`,exports.TYPE_OBJECT=`Object`,exports.TYPE_SET=`Set`;