How to fix Mapped type 'X' cannot use 'in' with non-union type in TypeScript

// WRONG - T could be any type
type Mapped<T> = {
  [K in T]: string;  // Error: T might not be a union
};

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

// Even better: Constrain to string literals specifically
type StringMapped<T extends string> = {
  [K in T]: string;
};

// Usage examples:
type Keys = "name" | "age" | "email";
type Result = Mapped<Keys>;  // OK: Keys is a union

// This will work:
const example: Result = {
  name: "John",
  age: "30",
  email: "[email protected]"
};

// WRONG - Single string literal
type SingleKey = "id";
type Mapped1 = {
  [K in SingleKey]: string;  // Error: SingleKey is not a union
};

// CORRECT - Make it a union (even if just one member)
type SingleKeyUnion = "id";
type Mapped2 = {
  [K in SingleKeyUnion]: string;  // OK: technically a union of one
};

// Better: Use a proper union type
type Keys = "id" | "name" | "value";
type Mapped3 = {
  [K in Keys]: string;
};

// Using template literal types to create unions
type Prefix<T extends string> = `${T}_prop`;
type PrefixedKeys = Prefix<"user" | "admin">;  // "user_prop" | "admin_prop"

type Mapped4 = {
  [K in PrefixedKeys]: boolean;
};

// Flexible mapped type that handles any input
type SafeMapped<T> = T extends string | number | symbol
  ? { [K in T]: string }
  : never;

// Usage:
type UnionResult = SafeMapped<"a" | "b">;  // { a: string; b: string; }
type SingleResult = SafeMapped<"id">;      // { id: string; }
type InvalidResult = SafeMapped<object>;   // never

// More advanced: Handle arrays and convert to unions
type ArrayToUnion<T extends readonly any[]> = T[number];
type KeysFromArray = ArrayToUnion<["name", "age", "email"]>;  // "name" | "age" | "email"

type MappedFromArray<T extends readonly string[]> = {
  [K in ArrayToUnion<T>]: string;
};

// Usage:
const keys = ["name", "age"] as const;
type Result = MappedFromArray<typeof keys>;  // { name: string; age: string; }

// WRONG - keyof on primitive returns never
type PrimitiveKeys = keyof string;  // never
type Mapped1 = {
  [K in PrimitiveKeys]: any;  // Error: never is not a union
};

// CORRECT - Use keyof on object types
interface User {
  id: number;
  name: string;
  email: string;
}

type UserKeys = keyof User;  // "id" | "name" | "email"
type Mapped2 = {
  [K in UserKeys]: string;
};

// Handle optional properties
interface PartialUser {
  id?: number;
  name?: string;
}

type PartialKeys = keyof PartialUser;  // "id" | "name"
type RequiredMapped = {
  [K in PartialKeys]-?: string;  // Remove optionality
};

// Using keyof with generics
type GenericMapped<T extends object> = {
  [K in keyof T]: T[K];
};

// This ensures T is an object type
type Result = GenericMapped<{ a: number; b: string }>;  // { a: number; b: string; }

// Non-distributive (wrong approach)
type NonDistributive<T> = T extends any ? { [K in T]: string } : never;
// Error: T in mapped type might not be union

// Distributive mapped type (correct)
type DistributiveMapped<T> = T extends any
  ? { [K in T]: string }
  : never;

// Even better: Extract to helper type
type ToUnion<T> = T extends any ? T : never;
type SafeMapped<T> = { [K in ToUnion<T>]: string };

// Usage with complex unions
type Status = "pending" | "success" | "error";
type WithData<T> = T extends any
  ? { status: T; data: string }
  : never;

type Result = WithData<Status>;
// Equivalent to:
// { status: "pending"; data: string } |
// { status: "success"; data: string } |
// { status: "error"; data: string }

// Transforming union members individually
type MakeOptional<T> = T extends any
  ? { [K in T]?: string }
  : never;

type OptionalResult = MakeOptional<"a" | "b">;  // { a?: string } | { b?: string }

// Check if a type is a union
type IsUnion<T> = [T] extends [T & any] ? false : true;

// Test it:
type Test1 = IsUnion<"a">;        // false
type Test2 = IsUnion<"a" | "b">;  // true

// Extract union members
type UnionMembers<T> = T extends any ? T : never;

// Debug what keyof produces
interface Example {
  x: number;
  y: string;
}

type Keys = keyof Example;  // "x" | "y"
type KeyType = Keys extends string ? "string" : "other";  // "string"

// Use type assertions to narrow types
function processKeys<T extends string>(keys: T[]): { [K in T]: string } {
  // Type assertion to help TypeScript understand
  const keyUnion = keys[0] as T;
  return {} as any; // Implementation
}

// Create type guards
function isStringUnion<T>(value: T): value is T & string {
  return typeof value === "string";
}

// Use satisfies for type checking
const config = {
  keys: ["id", "name"] as const,
  values: { id: "123", name: "John" }
} satisfies {
  keys: readonly string[];
  values: Record<string, string>;
};