How to fix Cannot extend with union type containing 'never' in TypeScript

// WRONG - Distributive conditional type causes issues with never
type IsString<T> = T extends string ? true : false;
type Result = IsString<string | never>; // May cause error

// CORRECT - Wrap in tuples to avoid distribution
type IsString<T> = [T] extends [string] ? true : false;
type Result = IsString<string | never>; // Works correctly

// Example: Filtering union types
type Filter<T, U> = [T] extends [U] ? T : never;

// Example: Checking for never
type IsNever<T> = [T] extends [never] ? true : false;
type Check1 = IsNever<never>;        // true
type Check2 = IsNever<string>;       // false

// WRONG - Non-distributive comparison may fail
type ExtractString<T> = T extends string ? T : never;

// CORRECT - Use infer to create generic context
type ExtractString<T> = T extends infer U
  ? U extends string
    ? U
    : never
  : never;

// Example usage
type Result = ExtractString<string | number | boolean>;
// Result: string

// Filtering out null and undefined
type NonNullable<T> = T extends infer U
  ? U extends null | undefined
    ? never
    : U
  : never;

type Clean = NonNullable<string | null | number | undefined>;
// Clean: string | number

// Debug helper to inspect types
type Debug<T> = { [K in keyof T]: T[K] };

// Check what your type resolves to
type MyUnion = string | never;
type Resolved = Debug<{ value: MyUnion }>;
// Hover over Resolved in your IDE to see: { value: string }

// Common case: Generic parameter that might be never
type SafeExtract<T, U> = T extends never
  ? never
  : T extends U
  ? T
  : never;

// This produces never if no overlap exists
type Overlap<T, U> = Extract<T, U>;
type NoMatch = Overlap<string, number>; // never

// Fix by handling the never case explicitly
type SafeOverlap<T, U> = Extract<T, U> extends never
  ? "no overlap"
  : Extract<T, U>;

// WRONG - Doesn't handle never case
type Transform<T> = T extends string ? string[] : T;

// CORRECT - Check for never first
type Transform<T> = [T] extends [never]
  ? never
  : T extends string
  ? string[]
  : T;

// Example with union filtering
type FilterOut<T, U> = T extends never
  ? never
  : T extends U
  ? never
  : T;

type Numbers = FilterOut<string | number | boolean, string | boolean>;
// Numbers: number

// Multi-step type transformation
type Step1<T> = [T] extends [never] ? never : T;
type Step2<T> = Step1<T> extends string ? string[] : Step1<T>;
type Final<T> = Step2<T>;

type Result = Final<string>; // string[]

// Instead of custom filters, use built-ins
type OnlyStrings = Extract<string | number | boolean, string>;
// OnlyStrings: string

type NotStrings = Exclude<string | number | boolean, string>;
// NotStrings: number | boolean

type NoNulls = NonNullable<string | null | undefined>;
// NoNulls: string

// Combining utilities
type SafePick<T, K extends keyof T> = {
  [P in K]: NonNullable<T[P]>;
};

interface User {
  name: string;
  email: string | null;
  age: number | undefined;
}

type RequiredUser = SafePick<User, "name" | "email">;
// { name: string; email: string }

// WRONG - Constraint may include never
function process<T extends string | never>(value: T): void {
  // Error: Cannot extend with union type containing 'never'
}

// CORRECT - Remove never from constraint
function process<T extends string>(value: T): void {
  // Works correctly
}

// Or handle it explicitly
function process<T>(value: T extends never ? string : T): void {
  // Explicit never handling
}

// For conditional constraints
type ValidKeys<T> = {
  [K in keyof T]: T[K] extends Function ? never : K;
}[keyof T];

// Use with an object type
interface Config {
  name: string;
  getValue: () => string;
  timeout: number;
}

type DataKeys = ValidKeys<Config>;
// DataKeys: "name" | "timeout" (excludes getValue)