How to fix Index signature parameter type cannot be generic in TypeScript

// ❌ WRONG - Causes error
interface GenericIndex<T> {
  [key: T]: string;  // Error: Index signature parameter type cannot be generic
}

// ✅ CORRECT - Use mapped type
type GenericMapped<T extends string | number | symbol> = {
  [K in T]: string;
};

// Example usage
type StringKeys = GenericMapped<"a" | "b" | "c">;
// Result: { a: string; b: string; c: string; }

// ✅ Also works with keyof constraints
type PickProperties<T, K extends keyof T> = {
  [P in K]: T[P];
};

// Example: Pick specific properties from an object type
interface User {
  id: number;
  name: string;
  email: string;
  age: number;
}

type UserNameAndEmail = PickProperties<User, "name" | "email">;
// Result: { name: string; email: string; }

// ❌ WRONG
interface Dictionary<T extends string> {
  [key: T]: any;  // Error
}

// ✅ CORRECT - Use Record
type Dictionary<T extends string | number | symbol> = Record<T, any>;

// Example usage
type StatusCodes = Dictionary<200 | 404 | 500>;
// Equivalent to: { 200: any; 404: any; 500: any; }

type StringDictionary = Dictionary<string>;
// Equivalent to: { [key: string]: any; }

// ✅ You can also create your own Record-like type
type MyRecord<K extends keyof any, T> = {
  [P in K]: T;
};

// Usage with constraints
type Config<T extends string> = MyRecord<T, boolean>;

const config: Config<"darkMode" | "notifications"> = {
  darkMode: true,
  notifications: false,
};

// ❌ WRONG - Generic without constraint
interface FlexibleObject<T> {
  [key: T]: string;  // Error
}

// ✅ CORRECT - Constrain to allowed types
interface FlexibleObject<T extends string | number | symbol> {
  [key: T]: string;  // Now works because T is constrained
}

// ✅ More specific constraints
interface StringKeyObject<T extends string> {
  [key: T]: string;
}

interface NumberKeyObject<T extends number> {
  [key: T]: string;
}

// ✅ Using template literal types
interface PrefixedKeys<T extends string> {
  [key: `prefix-${T}`]: string;
}

// Example usage
type MyPrefixed = PrefixedKeys<"a" | "b">;
// Result: { "prefix-a": string; "prefix-b": string; }

// ✅ Union type constraints
interface MixedKeys<T extends string | number> {
  [key: T]: string;
}

// ❌ WRONG - Complex generic in index signature
interface ComplexIndex<T> {
  [key: T extends string ? `key-${T}` : never]: string;  // Error
}

// ✅ CORRECT - Use conditional mapped type
type ComplexMapped<T> = T extends string ? {
  [K in `key-${T}`]: string;
} : never;

// Example usage
type Result = ComplexMapped<"a" | "b">;
// Result: { "key-a": string; "key-b": string; }

// ✅ Another example with inference
type ExtractKeys<T> = T extends { [key: infer K]: any } ? K : never;

// ✅ Create type-safe dictionaries with validation
type ValidatedDictionary<Keys extends string, Value> = {
  [K in Keys]: Value;
} & {
  // Additional methods or properties
  getKeyCount(): number;
};

// Implementation
function createDictionary<Keys extends string, Value>(
  keys: Keys[],
  defaultValue: Value
): ValidatedDictionary<Keys, Value> {
  const dict = {} as any;
  for (const key of keys) {
    dict[key] = defaultValue;
  }
  dict.getKeyCount = () => keys.length;
  return dict;
}

const myDict = createDictionary(["a", "b", "c"], 0);
// Type: ValidatedDictionary<"a" | "b" | "c", number>

// ❌ Problematic design requiring generic index signatures
interface Problematic<T> {
  data: { [key: T]: any };  // Would cause error if T is generic
}

// ✅ Alternative 1: Use tuple or array for ordered data
interface Alternative1<T> {
  data: T[];  // Array of values
  keys: string[];  // Separate array for keys
}

// ✅ Alternative 2: Use Map or Set for dynamic collections
interface Alternative2<T> {
  data: Map<string, T>;  // Map preserves key-value pairs
}

// ✅ Alternative 3: Union type of possible states
type Alternative3 =
  | { type: "stringKeys"; data: Record<string, any> }
  | { type: "numberKeys"; data: Record<number, any> }
  | { type: "specificKeys"; data: { a: any; b: any; c: any } };

// ✅ Alternative 4: Factory function pattern
function createDataStore<T extends Record<string, any>>(initialData: T) {
  return {
    data: initialData,
    get<K extends keyof T>(key: K): T[K] {
      return this.data[key];
    },
    set<K extends keyof T>(key: K, value: T[K]) {
      this.data[key] = value;
    }
  };
}

// Usage
const store = createDataStore({
  name: "John",
  age: 30,
  active: true
});

store.get("name");  // string
store.set("age", 31);  // OK

// ⚠️ Use with caution - type assertion bypasses type checking
interface WithAssertion<T> {
  data: { [key: string]: any } as { [key in T & (string | number | symbol)]: any };
}

// Better approach: type guard function
function isRecordWithKeys<T extends string>(
  obj: any,
  keys: T[]
): obj is Record<T, any> {
  if (typeof obj !== "object" || obj === null) return false;
  return keys.every(key => key in obj);
}

// Usage with type guard
function processData<T extends string>(data: any, expectedKeys: T[]) {
  if (isRecordWithKeys(data, expectedKeys)) {
    // TypeScript now knows data is Record<T, any>
    console.log(data);
  } else {
    throw new Error("Invalid data structure");
  }
}

// Another approach: indexed access types
type ValueOf<T> = T[keyof T];

interface Container<T> {
  values: T;
  getValue<K extends keyof T>(key: K): T[K];
  setValue<K extends keyof T>(key: K, value: T[K]): void;
}

// Usage
const container: Container<{ x: number; y: string }> = {
  values: { x: 1, y: "hello" },
  getValue(key) { return this.values[key]; },
  setValue(key, value) { this.values[key] = value; }
};