TypeScript: Filling an Object progressively to match a type/interface

In TypeScript, is there a way to progressively build an object to match a type or interface, without having the IDE (or the compiler?) complaining because not all expected attributes are here from the start?

Let me take an example. I have a list of fruits, and I will want to manipulate objects that assign values to each and every fruit.

type Fruit = 'apple' | 'lemon' | 'melon';
type FruitMapToString = { [ key in Fruit ]: string; };
const FRUIT_DESCRIPTIONS: FruitMapToString = {
  apple: 'A basic fruit',
  lemon: 'An acidic fruit',
  melon: 'A refreshing fruit',
} as const;

This is in a file that might be modified to add new fruits. And I don't want the rest of my code to rely on the knowledge of what fruits exists, because I don't want to update it.

Now, I want a map from fruits to number (to count my fruits). And I want to use a type that implies that all fruits are covered:

type FruitMapToNumber = { [ key in Fruit ]: number; };

So, I want to rely on FRUIT_DESCRIPTIONS's key to initialize my object to: { apple: 0, lemon: 0, melon: 0 }. But I can't find a way to do that without the IDE complaining at some point that some properties are lacking.

Typically I would like to do that:

function makeFruitToNumberMap(): FruitMapToNumber {
  const map: FruitMapToNumber = {}; // ❌ Missing the properties 'apple' etc
  let fruit: Fruit;
  for ( fruit in FRUIT_DESCRIPTIONS ) {
    map[ fruit ] = 0;
  }
  return map;
}

But it doesn't work, because when initialized to {}, my map is lacking properties.

I also tried starting with a type where the keys are optional:

  const map: { [ key in Fruit ]?: boolean; } = {};

But then the IDE complains at the return level, because “'number | undefined' is not assignable to type 'number'”. (Even thought at the end of the functions, all fruits are assigned to 0.)

I even tried this, even through I don't want to use that for readability:

function makeFruitToNumberMap(): FruitMapToNumber {
  return Object.fromEntries(
    Object.keys( FRUIT_DESCRIPTIONS ).map(
      ( fruit ) => [ fruit, 0 ]
    )
  );
}

Again, the IDE complains about missing properties.

It might be more convinient to use enum here for setting up primary types and use them for iterating:

enum Fruit {
  apple = "apple",
  lemon = "lemon",
  melon = "melon"
}
type TFruit = keyof typeof Fruit; //it's the same as your strings uion type
type FruitMapToNumber = { [key in Fruit]: number };
type FruitMapToString = { [key in Fruit]: string };
const FRUIT_DESCRIPTIONS: FruitMapToString = {
  [Fruit.apple]: "A basic fruit",
  [Fruit.lemon]: "An acidic fruit",
  [Fruit.melon]: "A refreshing fruit"
};

There's no way to create an object with already predefined fields. So, we can create it only by iterating. And here there're 2 unpleasant things:

• the 1st one as it's iterating creation we always start with an empty object and that means we have Partial type in the end.

• the 2d unpleasant thing here is that js doesn't allow us to
  pass which keys will be returned from Object.keys method, it always
  expects to return string keys.

  function makeFruitToNumberMap() {
    const keys = Object.keys(Fruit); // 2d issue: keys type is string[]
    const map = keys.reduce((acc, key) => ({ ...acc, [key]: 0 }), {}); // 1st issue: original object is empty and we set values iteratively
    return map;
  }

So, to resolve it we can use casting

function makeFruitToNumberMap() {
  const keys = Object.keys(Fruit) as TFruit[];
  const map = keys.reduce((acc, key) => ({ ...acc, [key]: 0 }), {});
  return map as FruitMapToNumber;
}

Anastasiya Stanevich made me realize that what I was lacking is type assertion, i.e., using … as Type to assert that my object was indeed, at this point, of the required type Type.

I should also be using Partial<Type> to type my “not yet completed” object.

Typically, in the sample case I provided:

function makeFruitToNumberMap(): FruitMapToNumber {
  const map: Partial<FruitMapToNumber> = {}; // 👈 Partial
  let fruit: Fruit;
  for ( fruit in FRUIT_DESCRIPTIONS ) {
    map[ fruit ] = 0;
  }
  return map as FruitMapToNumber; // 👈 Type assertion
}