How to fix Mapped type constraints cannot reference type parameters in TypeScript

// WRONG - T is not constrained, can't be used in mapped type
type Transform<T> = {
  [K in keyof T]: T[K];
};

// CORRECT - Constrain T to be an object type
type Transform<T extends object> = {
  [K in keyof T]: T[K];
};

// WRONG - Trying to use arbitrary type parameter as keys
type MapKeys<T, U> = {
  [K in T]: U;  // Error: T is not a valid key type
};

// CORRECT - Constrain T to be string | number | symbol
type MapKeys<T extends string | number | symbol, U> = {
  [K in T]: U;
};

// WRONG - Inner mapped type references outer T
type Outer<T> = {
  inner: <U>() => {
    [K in T]: U;  // Error: T not accessible here
  };
};

// CORRECT - Pass T as parameter to inner function
type Outer<T> = {
  inner: <U>(t: T) => {
    [K in keyof T]: U;
  };
};

// WRONG - Complex nested generic with scope issues
type DeepTransform<T> = {
  [K in keyof T]: <U>() => {
    [P in T[K]]: U;  // Error: T[K] not valid constraint
  };
};

// CORRECT - Extract to separate type with proper constraints
type ValueTransform<V extends PropertyKey, U> = {
  [P in V]: U;
};

type DeepTransform<T extends Record<string, PropertyKey>> = {
  [K in keyof T]: <U>() => ValueTransform<T[K], U>;
};

// WRONG - Trying to do complex filtering in mapped type constraint
type FilterProps<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K];
};

// This often works, but for more complex cases:

// CORRECT - Use conditional type with mapped type
type FilterByType<T, U> = {
  [K in keyof T]: T[K] extends U ? T[K] : never;
}[keyof T];

// WRONG - Self-referential mapped type
type RecursiveTransform<T> = {
  [K in keyof T]: T[K] extends object
    ? RecursiveTransform<T[K]>
    : T[K];
};

// CORRECT - Use conditional type approach
type DeepReadonly<T> = T extends object
  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
  : T;

// WRONG - Too complex, likely to hit constraint issues
type ComplexTransform<T, U, V> = {
  [K in keyof T]: T[K] extends U
    ? { [P in keyof V]: T[K] }
    : { [P in keyof T[K]]: V };
};

// CORRECT - Break into smaller, focused types
type TransformIfExtends<T, U, V> = T extends U
  ? MapToKeys<V, T>
  : MapObjectKeys<T[K], V>;

type MapToKeys<K extends PropertyKey, V> = {
  [P in K]: V;
};

type MapObjectKeys<T extends object, V> = {
  [K in keyof T]: V;
};

// Then compose them
type ComplexTransform<T, U, V> = {
  [K in keyof T]: TransformIfExtends<T[K], U, V>;
};

// WRONG - Unnecessary mapped type
type GetValues<T> = {
  [K in keyof T]: T[K];
};

// CORRECT - Simpler indexed access
type GetValues<T> = T[keyof T];

// WRONG - Complex mapped type that could be simpler
type PickByType<T, U> = {
  [K in keyof T as T[K] extends U ? K : never]: T[K];
};

// CORRECT - Alternative approach
type PickByType<T, U> = Pick<T, {
  [K in keyof T]: T[K] extends U ? K : never
}[keyof T]>;

// WRONG - Mapped type for simple transformation
type Optionalize<T> = {
  [K in keyof T]?: T[K];
};

// CORRECT - Use built-in utility type
type Optionalize<T> = Partial<T>;

// 1. Start with concrete types to verify logic
type Example = { a: string; b: number };
type ConcreteTest = {
  [K in keyof Example]: Example[K];
}; // Works

// 2. Add one generic parameter
type Test1<T extends object> = {
  [K in keyof T]: T[K];
}; // Works

// 3. Add complexity gradually
type Test2<T extends object, U> = {
  [K in keyof T]: T[K] extends U ? T[K] : never;
}; // Works

// 4. Use type inference to see intermediate results
type Debug<T> = T; // Hover over Debug<YourType> to see inferred type

// 5. Simplify constraints
// Instead of: type Complex<T> = { [K in T]: any }
// Try: type Complex<T extends PropertyKey> = { [K in T]: any }

// 6. Use TypeScript playground to isolate issues
// Go to: https://www.typescriptlang.org/play
// Paste minimal reproducing example