Generic function for creating and returning a generic array of objects

Everytime I think I have understood the generics, I come up with a task which proves me wrong. This is what I want:

Playground

type tFruits  = 'apple' | 'orange' | 'pear';
type tCars    = 'peugot' | 'mercedes'| 'nissan';
type tFlowers = 'rose' | 'tulip' | 'violet';

type tAssets = {
  image: {},
  text: {},
}

type tFruitAssets  = tAssets & { id: tFruits }
type tCarAssets    = tAssets & { id: tCars }
type tFlowerAssets = tAssets & { id: tFlowers }


const createAssets = <T, U>(ids: U[]):T[] => {
    const assets:T[] = [];

    for (const dataId of ids){
      // Typescript doesn't like this:
        assets.push({
            id: dataId,
            image:{},
            text:{},
        });
    }

    return assets;
}

const fruitAssets  = createAssets<tFruitAssets, tFruits>(['apple','orange','pear']);
const carAssets    = createAssets<tCarAssets, tCars>(['peugot','mercedes','nissan']);
const flowerAssets = createAssets<tFlowerAssets, tFlowers>(['rose','tulip','violet']);

Typescript doesn't like the object I try to push to the assets array inside my createAssets functions. It says:

Argument of type '{ id: U; image: {}; texts: {}; }' is not assignable to parameter of type 'T'.
'T' could be instantiated with an arbitrary type which could be unrelated to '{ id: U; image: {}; texts: {}; }'.

Could someone please explain me how I have to change the function? Or is it not possible?

Because T could be other type like tAssets & { id: tFruits } & { anotherId: tFruits } which is not compatible with tAssets & { id: tFruits } like the createAssets do.

createAssets say it can create T[] from U[], but it actually only create (tAssets & { id: U })[] from U[].If T includes anotherId, createAssets will not return it and this may cause error.

type tFruits = 'apple' | 'orange' | 'pear';
type tAssets = {
    image: {};
    text: {};
};
type FruitAssets = tAssets & { id: tFruits };
type OtherFruitAssets = FruitAssets & { anotherId: tFruits };
//works
const tFruitAssets: FruitAssets[] = createAssets<FruitAssets, tFruits>(['apple']);
//not work properly,but will not throw type error here
//expect otherTFruitAssets to be type OtherFruitAssets[]
//but actually otherTFruitAssets will be FruitAssets[] and this may cause error
const otherTFruitAssets: OtherFruitAssets[] = createAssets<OtherFruitAssets, tFruits>(['apple']);

What createAssets do is create (tAssets & { id: U })[] from U[], so its type should be:

const createAssets = <U,>(ids: U[]): (tAssets & { id: U })[] => {
    const assets: (tAssets & { id: U })[] = [];
    for (const dataId of ids) {
        assets.push({
            id: dataId,
            image: {},
            text: {},
        });
    }
    return assets;
};

10 Minutes later I came up with this:

// [...]

const createAssets = <T, U>(ids: U[]):T[] => {
    const assets:T[] = [];

    for (const dataId of ids){
        const t = {
            id: dataId,
            image:{},
            text:{},
        } as T;
        assets.push(t);
    }

    return assets;
}

Typescript is satisfied now but I feel like as if it would be more of a workaround than a proper solution. Am I fooling myself here?

While you could assert it and be done with it for now,

const createAssets = <T, U>(ids: U[]): T[] => {
    const assets: T[] = [];

    for (const dataId of ids) {
        const t = {
            id: dataId,
            image: {},
            texts: {},
        } as T;

        assets.push(t);
    }

    return assets;
};

this is actually unsound because the caller chooses the type of T and U, which means this passes type-checking:

const fruitAssets = createAssets<tCarAssets, tFruits>(["apple", "orange", "pear"]);
//                               ^^^^^^^^^^ should be invalid

You can easily make it safer by adding constraints to the generic parameters.

const createAssets = <T extends tAssets & { id: U }, U extends string>(ids: U[]): T[] => {

However, now you will have to use as unknown as T because TypeScript sees the possibility that someone may use

createAssets<{ id: string; image: {}; text: {}; extraProperty: {} }, string>(...);
//                                               ^^^^^^^^^^^^^ extra property here

which means that pushing t to assets is unsound, since you would be missing that extra property. If you really wanted to, you could also prevent this from happening by changing the constraints a little...

const createAssets = <T extends tAssets & { id: U }, U extends (tAssets & { id: U } extends T ? string : never)>(ids: U[]): T[] => {

Unfortunately, with all of these in place, the assertion is still necessary.
You could try to make it a little cleaner (get rid of the double assertion) with map:

const createAssets = <T extends tAssets & { id: U }, U extends (tAssets & { id: U } extends T ? string : never)>(ids: U[]): T[] => {
    const assets = ids.map((id) => ({ id, image: {}, text: {} })) as T[];

    return assets;
};

Playground