How rename certain keys for a Typescript type

Question

I need to rename some properties / keys of a certain Typescript type for a specific React component.

My Props type looks like this:

export type Props = {
  data: {
    title: string;
    items: (VarianOne | VariantTwo)[];
  };
}

VariantOne (and VariantTwo) are referring to other types (defined in another file):

export type VariantOne = { __typename: 'VariantOne' } & VariantOneItem;

Inside VariantOneItem I want to change both key names myAlias to e.g renamedAlias and anotherAlias to renamedAnotherAlias:

export interface VariantOneItem {
  myAlias: string;
  anotherAlias: string;

}

I started with the following approach (for one key now), but it's not working yet:

export type Props = {
      data: {
        title: string;
        items: (VarianOne | VariantTwo)[];
      };
    } & RenamedVariantOne;

type RenamedVariantOne = Omit<VariantOne, 'myAlias'> & { renamedAlias: VariantOne['myAlias'] };

question from:https://stackoverflow.com/questions/65858173/how-rename-certain-keys-for-a-typescript-type

Answer 1

type SomeData = {
    prop1: string;
    prop2: number;
}

type WithChange<T> = { [P in keyof T & string as `${P}Change`]: T[P] };

type SomeMoreData = WithChange<SomeData>; // {  prop1Change: string, prop2Change: number }

Here is what you can do.

type SomeMoreDataMapping = {
  prop1: "prop1Change"
  prop2: "prop2Change"
}

type ValueOf<T> = T[keyof T]
type KeyValueTupleToObject<T extends [keyof any, any]> = {
  [K in T[0]]: Extract<T, [K, any]>[1]
}
type MapKeys<T, M extends Record<string, string>> =
  KeyValueTupleToObject<ValueOf<{
    [K in RequiredKeys<T>]-?: [K extends keyof M ? M[K] : K, T[K]]
  }>> & Partial<KeyValueTupleToObject<ValueOf<{
    [K in OptionalKeys<T>]-?: [K extends keyof M ? M[K] : K, T[K]]
  }>>> extends infer O ? { [K in keyof O]: O[K] } : never;

type RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
type OptionalKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never }[keyof T];

interface SomeData {
  prop1?: string;
  prop2: number;
  prop3?: string;
  prop4: number;
}

type SomeMoreData = MapKeys<SomeData, SomeMoreDataMapping>;