TypeScript complex generic method

Question

I currently have this method

create<T extends ElementType | string>(type: T): Element<T>;

which uses

export type ElementType = 'ExtensionElements' | 'Documentation';

export type Element<T> =
  T extends 'ExtensionElements' ? ExtensionElements :
    T extends 'Documentation' ? Documentation :
      GenericElement;

This method is in a .d.ts, and it guarantees the result is always typed, so that

const e1 = obj.create('ExtensionElements');
      ^^ type is ExtensionElements

const e2 = obj.create('Documentation');
      ^^ type is Documentation

const e3 = obj.create('Other');
      ^^ type is GenericElement

Now, I'd like to let the users of this method extend the possible typed choices, so that, for example

type CustomElementType = 'Other' | ElementType;

type CustomElement<T> =
  T extends 'Other' ? CustomOtherElement : Element<T>;

const e4 = obj.create<CustomElementType, CustomElement>('Other');
      ^^ type is CustomOtherElement

However this doesn't seem to work correctly, as I always receive an union of all types, and I cannot use arbitrary strings.

Do you have any other idea how I could implement this?

Titian Cernicova-Dragomir · Accepted Answer · 2019-05-30 12:07:23Z

3

You can use an interface to map from the string type to the true type. Since interfaces are open ended clients can use module augmentation to add extra options:

// create.ts
export declare let obj: {   
    create<T extends ElementType | string>(type: T): Element<T>;
}
type ExtensionElements = { e: string }
type Documentation = { d: string }
type GenericElement = { g: string }

export type ElementType = 'ExtensionElements' | 'Documentation';
export interface ElementMap {
    'ExtensionElements': ExtensionElements;
    'Documentation': Documentation;
}
export type Element<T extends string> = ElementMap extends Record<T, infer E> ? E :
    GenericElement;

const e1 = obj.create('ExtensionElements'); // ExtensionElements
const e2 = obj.create('Documentation'); // Documentation
const e3 = obj.create('Else'); //GenericElement

// create-usage.ts
import { obj } from './create'
type CustomOtherElement = { x: string }

declare module './create' {
    export interface ElementMap {
        'Other': CustomOtherElement
    }
}
const e4 = obj.create('Other'); //  CustomOtherElement

If you want to do scoped extension you will need an extra function that will change the interface used to map the string to the object type. This method can just return the current object cast as the expected result (since types don't matter at runtime nothing needs to be different)

// create.ts
interface Creator<TMap = ElementMap>{
    create<T extends keyof TMap | string>(type: T): Element<TMap, T>;
    extend<TMapExt extends TMap>(): Creator<TMapExt>
}
export declare let obj: Creator
type ExtensionElements = { e: string }
type Documentation = { d: string }
type GenericElement = { g: string }

import { obj, ElementMap } from './create'
type CustomOtherElement = { x: string }

export type ElementType = 'ExtensionElements' | 'Documentation';
export interface ElementMap {
    'ExtensionElements': ExtensionElements;
    'Documentation': Documentation;
}
export type Element<TMap, T extends PropertyKey> = TMap extends Record<T, infer E> ? E : GenericElement;

const e1 = obj.create('ExtensionElements'); // ExtensionElements
const e2 = obj.create('Documentation'); // Documentation
const e3 = obj.create('Else'); //GenericElement


// create-usage.ts
export interface CustomElementMap extends ElementMap {
    'Other': CustomOtherElement
}
const customObj = obj.extend<CustomElementMap>()
const e4 = customObj.create('Other'); //  CustomOtherElement

edited May 30, 2019 at 12:07

answered May 30, 2019 at 11:21

Titian Cernicova-Dragomir

253k37 gold badges465 silver badges395 bronze badges

Sign up to request clarification or add additional context in comments.

7 Comments

LppEdd Over a year ago

Thank you! But is this valid only in case of re-export, right? What if I want to extend it just in a normal TS method scope? (basically in implementation code)

Titian Cernicova-Dragomir Over a year ago

@LppEdd you want the extension to only be available in a particular scope ?

LppEdd Over a year ago

That would be an awesome plus, yes!

Titian Cernicova-Dragomir Over a year ago

@LppEdd added a scoped extension version'

LppEdd Over a year ago

Thanks again! I think in the declaration version, the method should be create<T extends string>, without ElementType, or it won't compile, and in scoped example just remove the export from CustomElementMap. I'm trying to understand the infer E part hahaha

|

Collectives™ on Stack Overflow

TypeScript complex generic method

1 Answer 1

7 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

7 Comments

Your Answer

Sign up or log in

Post as a guest

Related