Allow Type Checking to be Extended (into Tagged Templates, for example)
See original GitHub issueSearch Terms
Tagged Templates, template literals, JSX, htm, lit, lit-html, hyperhtml, nanohtml, choo
Suggestion
Many developers are exploring Tagged Templates as an alternative to JSX/TSX, as the result offers some important advantages. In particular, Tagged Templates parse faster than compiled JSX in all modern JS engines [1], and expose potential optimizations for consuming rendering libraries to be able to bypass comparison logic for identified static portions of a UI representation.
Regardless of the merit of these advantages, one of the key drawbacks cited by developers when adopting Tagged Templates in place of TSX is the lack of typing within static templates and associated expression parts. This affects all libraries using Tagged Templates.
[1]: analysis and benchmark data forthcoming, email me for access if necessary.
Using htm as an example:
interface Props {
sticky: boolean;
}
function Header({ sticky }: Props) {
return html`<header class=${'header' + (sticky ? ' sticky' : '')} />`;
}
render(html`<${Header} sticky=${'yes'} />`);
// Incorrect type, but no error ^^^^^
Since the template’s static parts are an unknown format, this is logical. However, consider the compiled output of the above:
interface Props {
sticky: boolean;
}
function Header({ sticky }: Props) {
return h('header', {class: 'header' + (sticky ? ' sticky' : '')});
}
render(h(Header, { sticky: 'yes' }));
// ^^^^^^
// Type 'string' is not assignable to type 'boolean'.
I would like to suggest that we need a solution for type-checking Tagged Templates. The shortest-path solution would be to special-case checking for Tagged Templates with a tag function that has a local identifier with the name html
, though clearly that’s not optimal as implementation of html
can vary.
Use Cases
The use-case for this is to allow developers to express view hierarchies in standard JavaScript syntax rather than JSX/TSX, while preserving the typing support currently offered by TSX being integrated into TypeScript’s parser.
If a design were to be proposed to extend type checking to arbitrary opaque Tagged Templates (perhaps through plugins), this would allow a whole host of untyped code to be checked by the TypeScript Compiler. I’m fairly certain the various CSS-in-JS solutions would be also interested in this level of static analysis in order to errors currently handled at runtime into compilation.
Examples
interface Props {
sticky: boolean;
}
function Header({ sticky }: Props) {
return html`<header class=${'header' + (sticky ? ' sticky' : '')} />`;
}
render(html`<${Header} sticky=${'yes'} />`);
// ^^^^^^^^
// Type 'string' is not assignable to type 'boolean'.
Checklist
My suggestion meets these guidelines:
- 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, etc.)
- This feature would agree with the rest of TypeScript’s Design Goals. (specifically goals 1, 2 & 6)
Issue Analytics
- State:
- Created 5 years ago
- Reactions:33
- Comments:21 (7 by maintainers)
At least we have a partial built-in solution now: https://github.com/microsoft/TypeScript/issues/33304
For example, using the new Template String Types, then in
the type of
div
will be inferred toHTMLDivElement
, andp
will beHTMLParagraphElement
.playground example
cc @octref and @rictic
In our experience looking into this, one of the first missing pieces is a type construction API. We can parse a template, like:
And know how we should build the type of the LHS of the implied assignment, ie:
but we don’t have an actual API to build the type. If we did, there is an API for checking assignability.
Once we have those pieces we can do this in a compiler plugin. From there we would really love to have a way to specify plugins in tsconfig so we don’t have to write a wrapper around
tsc
.