satisfies keyword for class declaration ?

[eczn]

🔍 Search Terms

"satisfies with class", "satisfies for static", "class static typing", "static member typing", "type check for static mehods"

✅ 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

satisfies with class

interface FromJson {
  from(jsonString: string): ThisType<{}>;
}

class A { }
A satisfies FromJson; // ✅ works with type error:
                      // Property 'from' is missing in type 'typeof A' but required in type 'FromJson

class B {
  static from(jsonString: string) { return new B(); }
}
B satisfies FromJson; // ✅ works well, it ensures that the class B must to implement the `static from(...)`

const B = ( class { ... } ) satisfies FromJson; // workarounds in one line 

but ... all-in-one-lined satisfies doesn't works for class

tralling satisfies after class body

class C { } satisfies FromJson // ❌ it doesn't works with error: Unexpected keyword or identifier.(1434)

and put satisfies before class body could have a better taste

class D satisfies FromJson { } // ❌ it doesn't works with the same error

📃 Motivating Example

interface FromJson {
  from(type: string,json: string): ThisType<{}>
}

class A satisfies FromJson {
  from(type: string, json: string) {
    const obj = JSON.parse(json)
    if (obj.type === type) Object.assign(this, obj);
    throw new Error(`unexpected json`);
  }
}
class B satisfies FromJson { /* ... */ }
class C satisfies FromJson { /* ... */ }
class D satisfies FromJson { /* ... */ }

const typeMap = { A, B, C, D }
type ObjectTypes = keyof typeof typeMap;

const handleResponse(type: ObjectTypes, json: string): A | B | C | D {
  return typeMap[type].from(type, json)
}

💻 Use Cases

What do you want to use this for?

for type-checking for static member of class in one line

What shortcomings exist with current approaches?

tralling satisfies after class body looks very bad for human eyes parsing

What workarounds are you using in the meantime?

// one line : 
const A = ( class { ... } ) satisfies FromJson;

// two line : 
class A { ... }
A satisfies FromJson;

expected :

class C implements I satisfies S {  }

[MartinJohns]

Duplicate of #33892.