@stryke/types 0.8.5 → 0.8.6

package/dist/async.d.ts

@@ -37,7 +37,7 @@ export type Resolvable<T> = Awaitable<T> | (() => Awaitable<T>);
  * //=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
  * ```
  */
-export type SetReturnType<Function_ extends (...arguments_: any[]) => any, TypeToReturn> = Function_ extends (this: infer ThisArgument, ...arguments_: infer Arguments) => any ? IsUnknown<ThisArgument> extends true ? (...arguments_: Arguments) => TypeToReturn : (this: ThisArgument, ...arguments_: Arguments) => TypeToReturn : (...arguments_: Parameters<Function_>) => TypeToReturn;
+export 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;
 export type AsyncFunction = (...arguments_: any[]) => Promise<unknown>;
 /**
  * Unwrap the return type of a function that returns a `Promise`.
@@ -85,7 +85,7 @@ export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<T
  * }
  * ```
  */
-export type Asyncify<Function_ extends FunctionLike> = SetReturnType<Function_, Promise<Awaited<ReturnType<Function_>>>>;
+export type Asyncify<TFunct extends FunctionLike> = SetReturnType<TFunct, Promise<Awaited<ReturnType<TFunct>>>>;
 /**
  * Get the result type of a `Promise`
  *

package/dist/base.d.ts

@@ -191,25 +191,25 @@ export type NestedValue<TValue extends object = object> = {
 export interface RefObject<T> {
     current: T;
 }
-export interface IIdentity<T = string> {
+export interface Identity<T = string> {
     id: T;
 }
-export interface IVersioned {
+export interface Versioned {
     version: number;
 }
-export interface ISequenced {
+export interface Sequenced {
     /**
      * The sequence number (version, or event counter, etc.) of the record
      */
     sequence: number;
 }
-export interface ITyped {
+export interface Typed {
     /**
      * The type of the record
      */
     __typename: string;
 }
-export interface ClassTypeCheckable<T> extends ITyped {
+export interface ClassTypeCheckable<T> extends Typed {
     /**
      * Run type check on the given value
      * @param value - The value to check

package/dist/object.d.ts

@@ -106,10 +106,10 @@ export type ToString<T> = T extends number | string ? `${T}` : never;
  * It creates a type-safe way to access the member type of `unknown` type.
  */
 export type ObjectValue<T, K> = K extends keyof T ? T[K] : ToString<K> extends keyof T ? T[ToString<K>] : K extends `${infer NumberK extends number}` ? NumberK extends keyof T ? T[NumberK] : never : never;
-export type Paths<T> = Paths_<T>;
-type Paths_<T, Depth extends number = 0> = T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> ? never : IsAny<T> extends true ? never : T extends UnknownArray ? number extends T["length"] ? InternalPaths<VariablePartOfArray<T>[number][], Depth> | InternalPaths<StaticPartOfArray<T>, Depth> : InternalPaths<T, Depth> : T extends object ? InternalPaths<T, Depth> : never;
-export type InternalPaths<_T, Depth extends number = 0, T = Required<_T>> = T extends EmptyObject | readonly [] ? never : {
-    [Key in keyof T]: Key extends number | string ? Key | (LessThan<Depth, 15> extends true ? IsNever<Paths_<T[Key], Sum<Depth, 1>>> extends false ? `${Key}.${Paths_<T[Key], Sum<Depth, 1>>}` : never : never) | ToString<Key> : never;
+export type Paths<T> = InnerPaths<T>;
+type InnerPaths<T, Depth extends number = 0> = T extends NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown> ? never : IsAny<T> extends true ? never : T extends UnknownArray ? number extends T["length"] ? InternalPaths<VariablePartOfArray<T>[number][], Depth> | InternalPaths<StaticPartOfArray<T>, Depth> : InternalPaths<T, Depth> : T extends object ? InternalPaths<T, Depth> : never;
+export type InternalPaths<TDef, TDepth extends number = 0, T = Required<TDef>> = T extends EmptyObject | readonly [] ? never : {
+    [Key in keyof T]: Key extends number | string ? Key | (LessThan<TDepth, 15> extends true ? IsNever<InnerPaths<T[Key], Sum<TDepth, 1>>> extends false ? `${Key}.${InnerPaths<T[Key], Sum<TDepth, 1>>}` : never : never) | ToString<Key> : never;
 }[(T extends UnknownArray ? number : unknown) & keyof T];
 interface GetOptions {
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stryke/types",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "type": "module",
   "description": "A package containing many base TypeScript type definitions that are shared across many projects.",
   "repository": {
@@ -291,5 +291,6 @@
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts"
+  "types": "./dist/index.d.ts",
+  "gitHead": "a8c829509eefd6d8e5fcdc84bd5b9a0b8e02ee7e"
 }