From be389c6cfae8aa18dc17055366247e79f9566d68 Mon Sep 17 00:00:00 2001
From: Dmytro Stanchiev <git@dmytros.dev>
Date: Tue, 7 Apr 2026 08:08:44 -0400
Subject: [PATCH] style(skills): standardize utility-types.ts formatting

---
 .../references/utility-types.ts               | 213 +++++++++---------
 1 file changed, 106 insertions(+), 107 deletions(-)

diff --git a/.claude/skills/typescript-expert/references/utility-types.ts b/.claude/skills/typescript-expert/references/utility-types.ts
index bd56937..8a5accb 100644
--- a/.claude/skills/typescript-expert/references/utility-types.ts
+++ b/.claude/skills/typescript-expert/references/utility-types.ts
@@ -1,6 +1,6 @@
 /**
  * TypeScript Utility Types Library
- * 
+ *
  * A collection of commonly used utility types for TypeScript projects.
  * Copy and use as needed in your projects.
  */
@@ -11,19 +11,19 @@
 
 /**
  * Create nominal/branded types to prevent primitive obsession.
- * 
+ *
  * @example
  * type UserId = Brand<string, 'UserId'>
  * type OrderId = Brand<string, 'OrderId'>
  */
-export type Brand<K, T> = K & { readonly __brand: T }
+export type Brand<K, T> = K & { readonly __brand: T };
 
 // Branded type constructors
-export type UserId = Brand<string, 'UserId'>
-export type Email = Brand<string, 'Email'>
-export type UUID = Brand<string, 'UUID'>
-export type Timestamp = Brand<number, 'Timestamp'>
-export type PositiveNumber = Brand<number, 'PositiveNumber'>
+export type UserId = Brand<string, "UserId">;
+export type Email = Brand<string, "Email">;
+export type UUID = Brand<string, "UUID">;
+export type Timestamp = Brand<number, "Timestamp">;
+export type PositiveNumber = Brand<number, "PositiveNumber">;
 
 // =============================================================================
 // RESULT TYPE (Error Handling)
@@ -33,33 +33,33 @@ export type PositiveNumber = Brand<number, 'PositiveNumber'>
  * Type-safe error handling without exceptions.
  */
 export type Result<T, E = Error> =
-    | { success: true; data: T }
-    | { success: false; error: E }
+	| { success: true; data: T }
+	| { success: false; error: E };
 
 export const ok = <T>(data: T): Result<T, never> => ({
-    success: true,
-    data
-})
+	success: true,
+	data,
+});
 
 export const err = <E>(error: E): Result<never, E> => ({
-    success: false,
-    error
-})
+	success: false,
+	error,
+});
 
 // =============================================================================
-// OPTION TYPE (Nullable Handling)  
+// OPTION TYPE (Nullable Handling)
 // =============================================================================
 
 /**
  * Explicit optional value handling.
  */
-export type Option<T> = Some<T> | None
+export type Option<T> = Some<T> | None;
 
-export type Some<T> = { type: 'some'; value: T }
-export type None = { type: 'none' }
+export type Some<T> = { type: "some"; value: T };
+export type None = { type: "none" };
 
-export const some = <T>(value: T): Some<T> => ({ type: 'some', value })
-export const none: None = { type: 'none' }
+export const some = <T>(value: T): Some<T> => ({ type: "some", value });
+export const none: None = { type: "none" };
 
 // =============================================================================
 // DEEP UTILITIES
@@ -69,31 +69,31 @@ export const none: None = { type: 'none' }
  * Make all properties deeply readonly.
  */
 export type DeepReadonly<T> = T extends (...args: any[]) => any
-    ? T
-    : T extends object
-    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
-    : T
+	? T
+	: T extends object
+		? { readonly [K in keyof T]: DeepReadonly<T[K]> }
+		: T;
 
 /**
  * Make all properties deeply optional.
  */
 export type DeepPartial<T> = T extends object
-    ? { [K in keyof T]?: DeepPartial<T[K]> }
-    : T
+	? { [K in keyof T]?: DeepPartial<T[K]> }
+	: T;
 
 /**
  * Make all properties deeply required.
  */
 export type DeepRequired<T> = T extends object
-    ? { [K in keyof T]-?: DeepRequired<T[K]> }
-    : T
+	? { [K in keyof T]-?: DeepRequired<T[K]> }
+	: T;
 
 /**
  * Make all properties deeply mutable (remove readonly).
  */
 export type DeepMutable<T> = T extends object
-    ? { -readonly [K in keyof T]: DeepMutable<T[K]> }
-    : T
+	? { -readonly [K in keyof T]: DeepMutable<T[K]> }
+	: T;
 
 // =============================================================================
 // OBJECT UTILITIES
@@ -103,38 +103,40 @@ export type DeepMutable<T> = T extends object
  * Get keys of object where value matches type.
  */
 export type KeysOfType<T, V> = {
-    [K in keyof T]: T[K] extends V ? K : never
-}[keyof T]
+	[K in keyof T]: T[K] extends V ? K : never;
+}[keyof T];
 
 /**
  * Pick properties by value type.
  */
-export type PickByType<T, V> = Pick<T, KeysOfType<T, V>>
+export type PickByType<T, V> = Pick<T, KeysOfType<T, V>>;
 
 /**
  * Omit properties by value type.
  */
-export type OmitByType<T, V> = Omit<T, KeysOfType<T, V>>
+export type OmitByType<T, V> = Omit<T, KeysOfType<T, V>>;
 
 /**
  * Make specific keys optional.
  */
-export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 
 /**
  * Make specific keys required.
  */
-export type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> &
+	Required<Pick<T, K>>;
 
 /**
  * Make specific keys readonly.
  */
-export type ReadonlyBy<T, K extends keyof T> = Omit<T, K> & Readonly<Pick<T, K>>
+export type ReadonlyBy<T, K extends keyof T> = Omit<T, K> &
+	Readonly<Pick<T, K>>;
 
 /**
  * Merge two types (second overrides first).
  */
-export type Merge<T, U> = Omit<T, keyof U> & U
+export type Merge<T, U> = Omit<T, keyof U> & U;
 
 // =============================================================================
 // ARRAY UTILITIES
@@ -143,30 +145,30 @@ export type Merge<T, U> = Omit<T, keyof U> & U
 /**
  * Get element type from array.
  */
-export type ElementOf<T> = T extends (infer E)[] ? E : never
+export type ElementOf<T> = T extends (infer E)[] ? E : never;
 
 /**
  * Tuple of specific length.
  */
 export type Tuple<T, N extends number> = N extends N
-    ? number extends N
-    ? T[]
-    : _TupleOf<T, N, []>
-    : never
+	? number extends N
+		? T[]
+		: _TupleOf<T, N, []>
+	: never;
 
-type _TupleOf<T, N extends number, R extends unknown[]> = R['length'] extends N
-    ? R
-    : _TupleOf<T, N, [T, ...R]>
+type _TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N
+	? R
+	: _TupleOf<T, N, [T, ...R]>;
 
 /**
  * Non-empty array.
  */
-export type NonEmptyArray<T> = [T, ...T[]]
+export type NonEmptyArray<T> = [T, ...T[]];
 
 /**
  * At least N elements.
  */
-export type AtLeast<T, N extends number> = [...Tuple<T, N>, ...T[]]
+export type AtLeast<T, N extends number> = [...Tuple<T, N>, ...T[]];
 
 // =============================================================================
 // FUNCTION UTILITIES
@@ -175,28 +177,28 @@ export type AtLeast<T, N extends number> = [...Tuple<T, N>, ...T[]]
 /**
  * Get function arguments as tuple.
  */
-export type Arguments<T> = T extends (...args: infer A) => any ? A : never
+export type Arguments<T> = T extends (...args: infer A) => any ? A : never;
 
 /**
  * Get first argument of function.
  */
 export type FirstArgument<T> = T extends (first: infer F, ...args: any[]) => any
-    ? F
-    : never
+	? F
+	: never;
 
 /**
  * Async version of function.
  */
 export type AsyncFunction<T extends (...args: any[]) => any> = (
-    ...args: Parameters<T>
-) => Promise<Awaited<ReturnType<T>>>
+	...args: Parameters<T>
+) => Promise<Awaited<ReturnType<T>>>;
 
 /**
  * Promisify return type.
  */
 export type Promisify<T> = T extends (...args: infer A) => infer R
-    ? (...args: A) => Promise<Awaited<R>>
-    : never
+	? (...args: A) => Promise<Awaited<R>>
+	: never;
 
 // =============================================================================
 // STRING UTILITIES
@@ -205,31 +207,30 @@ export type Promisify<T> = T extends (...args: infer A) => infer R
 /**
  * Split string by delimiter.
  */
-export type Split<S extends string, D extends string> =
-    S extends `${infer T}${D}${infer U}`
-    ? [T, ...Split<U, D>]
-    : [S]
+export type Split<
+	S extends string,
+	D extends string,
+> = S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
 
 /**
  * Join tuple to string.
  */
-export type Join<T extends string[], D extends string> =
-    T extends []
-    ? ''
-    : T extends [infer F extends string]
-    ? F
-    : T extends [infer F extends string, ...infer R extends string[]]
-    ? `${F}${D}${Join<R, D>}`
-    : never
+export type Join<T extends string[], D extends string> = T extends []
+	? ""
+	: T extends [infer F extends string]
+		? F
+		: T extends [infer F extends string, ...infer R extends string[]]
+			? `${F}${D}${Join<R, D>}`
+			: never;
 
 /**
  * Path to nested object.
  */
 export type PathOf<T, K extends keyof T = keyof T> = K extends string
-    ? T[K] extends object
-    ? K | `${K}.${PathOf<T[K]>}`
-    : K
-    : never
+	? T[K] extends object
+		? K | `${K}.${PathOf<T[K]>}`
+		: K
+	: never;
 
 // =============================================================================
 // UNION UTILITIES
@@ -238,27 +239,28 @@ export type PathOf<T, K extends keyof T = keyof T> = K extends string
 /**
  * Last element of union.
  */
-export type UnionLast<T> = UnionToIntersection<
-    T extends any ? () => T : never
-> extends () => infer R
-    ? R
-    : never
+export type UnionLast<T> =
+	UnionToIntersection<T extends any ? () => T : never> extends () => infer R
+		? R
+		: never;
 
 /**
  * Union to intersection.
  */
 export type UnionToIntersection<U> = (
-    U extends any ? (k: U) => void : never
+	U extends any
+		? (k: U) => void
+		: never
 ) extends (k: infer I) => void
-    ? I
-    : never
+	? I
+	: never;
 
 /**
  * Union to tuple.
  */
 export type UnionToTuple<T, L = UnionLast<T>> = [T] extends [never]
-    ? []
-    : [...UnionToTuple<Exclude<T, L>>, L]
+	? []
+	: [...UnionToTuple<Exclude<T, L>>, L];
 
 // =============================================================================
 // VALIDATION UTILITIES
@@ -268,28 +270,25 @@ export type UnionToTuple<T, L = UnionLast<T>> = [T] extends [never]
  * Assert type at compile time.
  */
 export type AssertEqual<T, U> =
-    (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2)
-    ? true
-    : false
+	(<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2
+		? true
+		: false;
 
 /**
  * Ensure type is not never.
  */
-export type IsNever<T> = [T] extends [never] ? true : false
+export type IsNever<T> = [T] extends [never] ? true : false;
 
 /**
  * Ensure type is any.
  */
-export type IsAny<T> = 0 extends 1 & T ? true : false
+export type IsAny<T> = 0 extends 1 & T ? true : false;
 
 /**
  * Ensure type is unknown.
  */
-export type IsUnknown<T> = IsAny<T> extends true
-    ? false
-    : unknown extends T
-    ? true
-    : false
+export type IsUnknown<T> =
+	IsAny<T> extends true ? false : unknown extends T ? true : false;
 
 // =============================================================================
 // JSON UTILITIES
@@ -298,23 +297,23 @@ export type IsUnknown<T> = IsAny<T> extends true
 /**
  * JSON-safe types.
  */
-export type JsonPrimitive = string | number | boolean | null
-export type JsonArray = JsonValue[]
-export type JsonObject = { [key: string]: JsonValue }
-export type JsonValue = JsonPrimitive | JsonArray | JsonObject
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonArray = JsonValue[];
+export type JsonObject = { [key: string]: JsonValue };
+export type JsonValue = JsonPrimitive | JsonArray | JsonObject;
 
 /**
  * Make type JSON-serializable.
  */
 export type Jsonify<T> = T extends JsonPrimitive
-    ? T
-    : T extends undefined | ((...args: any[]) => any) | symbol
-    ? never
-    : T extends { toJSON(): infer R }
-    ? R
-    : T extends object
-    ? { [K in keyof T]: Jsonify<T[K]> }
-    : never
+	? T
+	: T extends undefined | ((...args: any[]) => any) | symbol
+		? never
+		: T extends { toJSON(): infer R }
+			? R
+			: T extends object
+				? { [K in keyof T]: Jsonify<T[K]> }
+				: never;
 
 // =============================================================================
 // EXHAUSTIVE CHECK
@@ -324,12 +323,12 @@ export type Jsonify<T> = T extends JsonPrimitive
  * Ensure all cases are handled in switch/if.
  */
 export function assertNever(value: never, message?: string): never {
-    throw new Error(message ?? `Unexpected value: ${value}`)
+	throw new Error(message ?? `Unexpected value: ${value}`);
 }
 
 /**
  * Exhaustive check without throwing.
  */
 export function exhaustiveCheck(_value: never): void {
-    // This function should never be called
+	// This function should never be called
 }