`const K = classFactory(...)` should be equivalent to `class K extends classFactory(...) {}`

[denis-migdal]

🔍 Search Terms

class factory

Checked all opened issues and the 5 first pages of the closed ones. Also searched for existing issues with IA.

✅ Viability Checklist

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

Playground Link

Currently, if we have a class factory:

function classFactory<T extends Record<string, any>>(props: T) {
    class Foo {
        protected foo(){} // needs to disable declaration files.
    }

    return Foo as {new(): Foo&T};
}

And we assign the result into a constant variable:

const Klass = classFactory({a: 34})

Then, not only K can't be used as a type, but its type description is ugly:

const Klass: new () => classFactory<{
    a: number;
}>.Foo & {
    a: number;
}

Therefore, I'd like it to be equivalent to class Klass extends classFactory({a: 34}) {}, i.e. to produce a class Klass type.

📃 Motivating Example

The type description would be cleaner class Klass instead of:

const Klass: new () => classFactory<{
    a: number;
}>.Foo & {
    a: number;
}

Also, we will be able to use it as a type which could be quite useful. For exemple we would then be able to export default the generated class with its type.

💻 Use Cases

Currently there are 2 workarounds:

1/ Using class Klass extends classFactory({foo: 34}) {}. However this creates an additional class and is more verbose to write.

2/ Re-creating the type. However dynamics and protected properties cause issues. This require to duplicate information, and likely require unsafe type casting of the factory function result.

[MartinJohns]

Duplicate of #18942.

[denis-migdal]

How did you find a duplicate so fast ?

It seems the main issue is that TS type checker doesn't know User is a type until it checks classFactory return type, requiring more pass for TS.

I think the issues could be solved if we had a way to tell TS that this is a class, i.e. to write something like:

class Klass = createClass(...);

Maybe some kind of notation:

const Klass: @asClass = createClass(...);

But this starts to feel hacky.

[denis-migdal]

Maybe could we allow an empty type definition:

const Klass: = createClass(...);

Then, we could write:

const Klass := createClass(...);

This could work for other types :

const RO := Symbol();
const RW := Symbol();

type T = Record<string,  RO|RW>;
// instead of :
type T = Record<string,  typeof RO|typeof RW>;

[MartinJohns]

How did you find a duplicate so fast ?

I have been around for a while. I have seen things.

[typescript-automation]

This issue has been marked as "Duplicate" and has seen no recent activity. It has been automatically closed for house-keeping purposes.