Typescript: How can I make entries in an ES6 Map based on an object key/value type

by

Here’s the closest I can imagine getting, although I still don’t understand why we don’t just use plain objects to begin with:

type ObjectToEntries<O extends object> = { [K in keyof O]: [K, O[K]] }[keyof O]

interface ObjectMap<O extends object> {
  forEach(callbackfn: <K extends keyof O>(
    value: O[K], key: K, map: ObjectMap<O>
  ) => void, thisArg?: any): void;
  get<K extends keyof O>(key: K): O[K];
  set<K extends keyof O>(key: K, value: O[K]): this;
  readonly size: number;
  [Symbol.iterator](): IterableIterator<ObjectToEntries<O>>;
  entries(): IterableIterator<ObjectToEntries<O>>;
  keys(): IterableIterator<keyof O>;
  values(): IterableIterator<O[keyof O]>;
  readonly [Symbol.toStringTag]: string;
}

interface ObjectMapConstructor {
  new <E extends Array<[K, any]>, K extends keyof any>(
    entries: E
  ): ObjectMap<{ [P in E[0][0]]: Extract<E[number], [P, any]>[1] }>;
  new <T>(): ObjectMap<Partial<T>>;
  readonly prototype: ObjectMap<any>;
}

const ObjectMap = Map as ObjectMapConstructor;

The idea is to make a new interface, ObjectMap, which is specifically dependent on an object type O to determine its key/value relationship. And then you can say that the Map constructor can act as an ObjectMap constructor. I also removed any methods that can change which keys are actually present (and the has() method is redundantly true also).

I can go through the trouble of explaining each method and property definition, but it’s a lot of type-juggling. In short you want to use K extends keyof O and O[K] to represent the types normally represented by K and V in Map<K, V>.

The constructor is a bit more annoying in that type inference doesn’t work the way you’d like, so guaranteeing type safety comes in two steps:

// let the compiler infer the type returned by the constructor
const myMapInferredType = new ObjectMap([
  ['key1', 'v'], 
  ['key2', 1],  
]);

// make sure it's assignable to `ObjectMap<Values>`: 
const myMap: ObjectMap<Values> = myMapInferredType;

If your myMapInferredType doesn’t match ObjectMap<Values> (e.g., you are missing keys or have the wrong value types) then myMap will give you errors.

Now you can use myMap as an ObjectMap<Values>, similarly to how you’d use a Map instance, with get() and set(), and it should be type safe.

Please note again… this seems like a lot of work for a more complex object with trickier typings and no more functionality than a plain object. I would seriously warn anyone using a Map whose keys are subtypes of keyof any (that is, string | number | symbol) to strongly consider using a plain object instead, and be sure that your use case really necessitates a Map.

Playground link to code

More Related Contents:

  1. How to fix TS2322: “could be instantiated with a different subtype of constraint ‘object'”?
  2. How to transform union type to tuple type
  3. In TypeScript, how to get the keys of an object type whose values are of a given type?
  4. Types for function that applys name of function and arguments
  5. Why this CustomExtract returns an different result from default Extract?
  6. How to avoid imports with very long relative paths in Angular 2?
  7. Object destructuring with property names that are not valid variable names
  8. Typescript Function with Generic Return Type
  9. What does “keyof typeof” mean in TypeScript?
  10. Typescript Key-Value relation preserving Object.entries type
  11. What does “… resolves to a non-module entity and cannot be imported using this construct” mean?
  12. Typescript: Cannot use import statement outside a module
  13. Why can’t the generic interface in TS infer the type correctly?
  14. Mapping tuple-typed value to different tuple-typed value without casts
  15. How to map over union array type?
  16. Eliminate nevers to make union possible
  17. How excess property check helps?
  18. TypeScript: Why can’t I assign a valid field of an object with type { a: “a”, b: “b” }
  19. extend and only specify known properties?
  20. Generic type extending union is not narrowed by type guard
  21. Getting the return type of a function which uses generics
  22. TypeScript: type for an object with only one key (no union type allowed as a key) [duplicate]
  23. Why does A | B allow a combination of both, and how can I prevent it?
  24. Parameters generic of overloaded function doesn’t contain all options
  25. Enforcing the type of the indexed members of a Typescript object?
  26. Constructor overload in TypeScript
  27. How to get a subset of `keyof T` whose value, T[K] are callable functions in Typescript
  28. Angular 2 2.0.0-rc.1 Property ‘map’ does not exist on type ‘Observable’ not the same as issue report
  29. ‘Property does not exist on type ‘never’
  30. In Typescript, How to check if a string is Numeric

Leave a Comment