TypeScript predicates not working with generics?

Take a look at the following snippet:

type WeightedItem<T> = { item: T; weight: number };

const isWeightedItemArray = <T>(items: WeightedItem<T>[] | T[]): items is WeightedItem<T>[] => {
  return (items as WeightedItem<T>[]).every((item: WeightedItem<T>) => "weight" in item);
};

export const createWeightedTable = <T>(items: T[]) => {
  if (isWeightedItemArray(items)) {
    // items is typed as  T[] & WeightedItem<T>[], and weight does not exist on type T
    const weights = (items).map((item) => item.weight);
  }
}

I created isWeightedItemArray to guarantee that items is of type WeightedItem<T>[], and yet TypeScript still throws an error and would apparently force me to type cast items to WeightedItem<T>[] even after using the predicate function.

Why is items typed as T[] & WeightedItem<T>[] and not just WeightedItem<T>[] after the predicate function?

Minimal reproducible example here.

It seems that you want your T and WeightedItem<T> to be separate objects, where {item: T, weight: number} has the item as a property. If that understanding is correct, then the problem is that you have declared items: T[] when logically you want it to be either T[] or WeightedItem<T>[]. If it can't be the latter then it wouldn't make sense to test it with your isWeightedItemArray function!

So the solution is simply to correct the parameter's type:

export const createWeightedTable = <T>(items: T[] | WeightedItem<T>[]): void => {
  // ...
}

Then the isWeightedItemArray type predicate can correctly narrow the type of items to that branch of the union.

Playground Link

I would rewrite it like this - with no generics, as none of those functions actually need the T type that you declare, so you can use unknown there:

type WeightedItem<T> = { item: T; weight: number };

const isWeightedItemArray = (items: WeightedItem<unknown>[] | unknown[]): items is WeightedItem<unknown>[] => {
  return items.every(item => item && typeof item === 'object' && 'weight' in item);
};

export const createWeightedTable = (items: unknown[] | WeightedItem<unknown>[]): void => {
  if (isWeightedItemArray(items)) {
    const weights = (items).map((item) => item.weight);
  }
}

Note: The createWeightedTable needs rewriting anyway, because the question author added some new requirements in the comments.

Update: And a version with <T> type (thanks to kaya3)

const isWeightedItemArray = <T>(items: WeightedItem<T>[] | unknown[]): items is WeightedItem<T>[] => {
  return items.every(item => item && typeof item === 'object' && 'weight' in item);
};

Here it is more explicit that we verify if that is WeightedItem<T>[].

For simplicity, you could declare types like:

type WeightedArray = WeightedItem<unknown>[];