JSX includes several elements like `div`, `span`, `h1`, and so on.

In this exercise, we'll be adding support for our own `custom-element`.

Currently, we have an error when we try to use it:

```typescript
const element = <custom-element>hello world</custom-element>; 
```

The error reads:

```markdown
Property 'custom-element' does not exist on type 'JSX.IntrinsicElements'. 
```

## Challenge

Your challenge is to dig into the React typings to find where `JSX.IntrinsicElements` is located, then add this new element.

Reference the Global and External Libraries lessons for a refresher.

Bonus points if you can make the `<custom-element>` have required props!

The first step is to explore React's typings and find `JSX.IntrinsicElements`.

You can use VS Code locally to navigate through or [view the `IntrinsicElements` interface on GitHub](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/220087807a5746367416c2a3ef87c17d7344f22f/types/react/index.d.ts#L3144) if you are using the online Stackblitz editor.

The interface includes key-value pairs that represent different elements and their attributes:

```typescript
interface IntrinsicElements { // HTML a: React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>; ... 
```

For example, if we dig into the `AnchorHTMLAttributes` associated with the `a` element, we see the different types of attributes it supports:

```typescript
interface AnchorHTMLAttributes<T> extends HTMLAttributes<T> { 
    download?: any; 
    href?: string | undefined; 
    hrefLang?: string | undefined; 
    media?: string | undefined; 
    ping?: string | undefined; 
    rel?: string | undefined; 
    target?: HTMLAttributeAnchorTarget | undefined; 
    type?: string | undefined; 
    referrerPolicy?: HTMLAttributeReferrerPolicy | undefined; 
} 
```

As an experiment, we can add a `custom-solution-element` straight to the `IntrinsicElements` interface inside of the `index.d.ts` file. We can specify it can optionally have a `children` property of `React.ReactNode`. Leaving off the `?` will specify that `wow` is a required boolean:

```tsx
// inside of index.d.ts locally interface IntrinsicElements { 'custom-solution-element': { children?: React.ReactNode wow: boolean } 
```

Back in the solution file, the error has disappeared:

```tsx
const element = (
	<custom-solution-element wow={true}> Hello world </custom-solution-element>
);
```

However, as we saw earlier, saving changes to the `index.d.ts` file isn't a good idea.

Instead, we need to use `declare global` and the `JSX` namespace to add our custom element to the `IntrinsicElements` interface:

```tsx
// inside solution file declare global { namespace JSX { interface IntrinsicElements { "custom-solution-element": {}; } } } 
```

With the `custom-solution-element` added, we can add `children` with the optional property modifier as well as any required props we want:

```tsx
declare global {
	namespace JSX {
		interface IntrinsicElements {
			"custom-solution-element": {
				children?: React.ReactNode;
			};
		}
	}
}

const element = (
	<custom-solution-element> Hello world </custom-solution-element>
);
```

The process used in this solution would work similarly for adding custom elements to Qwik or Solid, which also use JSX.

  
Diving into external libraries and appending to globals is really nice!

 Explore React typings to add a custom element to JSX.IntrinsicElements, defining required props and children, and utilizing HTML props.

Adding Custom Elements to JSX.IntrinsicElements

0:00 Let's give it a go. We have custom-solution-element here. We first need to dive into React typings to see if we can understand why JSX.IntrinsicElements even lives. If we go into React, I'm just going to have to...Here we go. In fact, we get a freebie here, where we've got K in keyof JSX.IntrinsicElements. I can-command click on JSX.IntrinsicElements. I end up inside here. Wow.

0:31 We have a, abbr, address, area, article, aside, all of the different types here that represent all...Well, what are they representing, actually? Because it looks like here we have a key. Then we have something. That something, it looks like it's the props of those attributes or the things that a takes here.

0:56 React.DetailedHTMLProps. AnchorHTMLAttributes. DetailedHTMLProps -- oh boy -- that looks a bit intimidating. AnchorHTMLAttributes, these are the actual props that that element actually takes itself.

1:10 This IntrinsicElements thing, if we can add a new element to this...In fact, let me just try this. I'll do this. Now if I just add custom-solution-element -- here we go -- and then let's say it takes a wow boolean. Now, property wow is missing here. We've got wow is...Let's just say it's 1.

1:40 Nice. It doesn't take children. Here we go. What if it takes children? Which is like React.ReacNode, for instance. Beautiful. Then wow, which is boolean. There we go. We've also got some nice required props here. That's cool.

2:01 How do we add this in, inside this file? Because currently I'm just editing the raw index.d.ts files. Let me delete that. We're inside an interface, which is IntrinsicElements, here. Let me pull this over. Whoops. Don't save.

2:21 We've got our IntrinsicElements. This is inside namespace JSX. We know, from JSX namespace, that we can basically say, "declare global namespace JSX," and then append to this interface of IntrinsicElements. I definitely don't want to save those changes. Let me go back to the file where I was.

2:43 Inside here, I can say, "declare global namespace JSX." Then I can say, "interface IntrinsicElements" -- in fact, Copilot is giving the game away here -- and "custom-solution-element." Look at that. Beautiful, beautiful stuff.

3:03 Hang on. Looks like I've accidentally saved this little piece of code. What we can do here is we can say, "interface IntrinsicElements custom-solution-element."

3:14 Does not exist on type JSX.IntrinsicElements. Did I mess that up somehow? Intrisic. Oh gosh. IntrinsicElements. There you go. You can see how painful this declaration merging is. That's a nasty little typo in the middle there that I didn't figure out.

3:31 Now we've got an empty object here. We should probably say that children is possible here, so React.ReactNode. That's nice. Now I can add a required prop if I want to, so requiredProp string. We get requiredProp, blah, blah, blah, blah, blah, blah. So beautiful.

3:46 This is really cool. It's nice to be able to do this sort of deep diving into external libraries, append to globals, and get a sense that we can mess about with this stuff and make some changes. Well done if you found this solution.

Custom JSX Elements

0:00 This is a fun little exercise. We are importing React into this project. The reason we're doing that is because we want to add a custom element to React's JSX. This is JSX. JSX bundles with a bunch of different stuff in. It has div. It has span. It has -- I don't know -- whatever, h1, h2.

0:21 We want to add a custom-element to JSX. We want it to be custom-element, like this, as though we're using a Web component or something. We want to add it so that this error goes away. Property custom-element does not exist on type JSX.IntrinsicElements.

0:41 You're going to need to do a bit of investigation here to dive into React typings to see if you can figure out where, for instance, JSX.IntrinsicElements even lives and how you can possibly, from this file, add in a new type to it. You'll need a bit of the knowledge that you picked up in the globals section and also the external libraries section. Good luck.

The Advanced Patterns workshop is a primer on several patterns that emerge from TypeScript's primitives. We'll build on the generics and type transformations work we've done so far - extracting methods for architecting them into novel solutions.

Most of these patterns aren't documented by TypeScript - they've been discovered and iterated on by the TypeScript community. Each section focuses on a different pattern via interactive exercises.

**This workshop is not appropriate for beginners.**

## Branded Types

Branded types (sometimes known as nominal types) let you break the rules of TypeScript by 'naming' types. This opens up a _lot_ of possibilities for using the type system to ensure your app's logic is robust.

## Globals

The often-feared global scope is a necessary part of most applications. Whether you're importing a library via CDN that attaches to `window`, or relying on environment variables, you'll need to know how to strongly type the global scope.

## Type Predicates & Assertion Functions

Type predicates and assertion functions give you the power to customize TypeScript's control flow. When used in combination with `if` statements, they can help improve inference and make your code easier to reason about.

## The Builder Pattern

This section builds on the Generics work we did in the previous workshop. We'll use classes and generics to perform ridiculous feats of inference - building up entire data structures in TypeScript without a single type annotation from the user.

## External Libraries

Diving into external libraries is extremely complex. But it's often necessary to debug complicated type errors. Understanding the flow of generics through an external library can be critical to quickly fixing red lines. We'll look at several popular libraries.

## Identity Functions

Sometimes in TypeScript, you just need a function. Some generic inference isn't possible without an identity function. We'll learn when and where to use them, as well as some powerful type helpers to assist their inference.

Intermediate to advanced workshop: Boost app logic, type global scopes, and debug with external libraries.

Advanced Patterns Workshop

Total TypeScript Core Volume is a set of four full TypeScript workshops for the intermediate to expert professional TypeScript programmer that wants to take their skills to the next level. This bundle also includes the Advanced React with TypeScript workshop that will give you expert-level knowledge for typing your React apps.

Type Transformations

TypeScript Generics

Advanced TypeScript Patterns

Advanced React with TypeScript

TypeScript Expert Interviews

Core Volume

Take your coding skills to the next level with this workshop and learn how to use type predicates, assertion functions, branded types, and more.

Advanced Workshop Welcome 

Branded types allow us to enforce certain logic on the type level so we can write safer code and impose constraints that aren't available in regular TypeScript.

What is a Branded Type?

Branded types can validate raw value data into types that will be correct no matter where they are passed in your application.

Assigning Branded Types to Values

Form Validation with Branded Types

Branded types can be used to confidently fetch data of a specific type. This is great for working with complicated data structures.

Add Branded Types to Functions and  Models

Using Branded Types as Entity Id’s

Using type helpers along with branded types provides a more reusable way of marking things as valid or invalid.

Combine Type Helpers with Branded Types

Creating Reusable Validity Checks with Branded Types and Type Helpers

Unit tests are great, but adding branded types provides another way to test validity on the type level.

Using Branded Types to Validate Code Logic

Creating Validation Boundaries with Branded Types

Here you'll learn an interesting property present when combining index signatures and branded types. 

Indexing an Object with Branded Types

Using Index Signatures with Branded Types

Covers three patterns used by the TypeScript community.

Nominal Typing from Basarat's TypeScript Deep Dive

How opaque types in Flow and TypeScript can make your code better, faster, more secure and easier to refactor.

Stronger JavaScript with Opaque Types by Charles Pick

Reference unique symbols in the TypeScript Handbook

unique symbol from the TypeScript Docs

Refresh yourself on type helpers with the Type Helpers section of the Type Transformations workshop.

Type Helpers from Total TypeScripts

Reference for Index Signatures in the TypeScript Handbook

Index Signatures from the TypeScript Docs

Branded Types

Functions in global scope can be accessed across projects. Use them carefully, as globals should be avoided when possible.

Add a Function to the Global Scope

TypeScript's Global Scope

It is possible to add functionality to existing TypeScript globals by taking advantage of declaration merging.

Use Declaration Merging to Add Functionality to the Global Window

Add Functionality to Existing Global Interfaces

Adding types to properties of global interfaces allows for autocompletion across your  project's files, even when they are within namespaces.

Typing process.env in the NodeJS Namespace

Add Types to Properties of Global Namespaced Interfaces

Globals can be used to communicate between files that don't necessarily import or export to each other. 

Solving the Colocation Problem with Globals

Colocating Types for Global Interfaces

A reference for Global Declarations in the TypeScript Handbook

Global Declarations from the TypeScript Docs

A reference for Declaration Merging in the TypeScript Handbook

Declaration Merging from the TypeScript Docs

See where window is declared in TypeScript's definition file for the DOM.

lib.dom.d.ts in the TypeScript Source on GitHub

The TypeScript definition file for the Node.js process object.

process.d.ts from @types/node on GitHub

Globals

Type predicates provide a useful way for ensuring types are what we expect them to be. 

Use a Type Predicate to Filter Types

Filtering with Type Predicates

Assertion functions make sure if types are valid or assignable to other types. They are great for writing clever checks.

Ensure Valid Types with an Assertion Function

Checking Types with Assertion Functions

There is a gotcha to assertion functions that can lead to TypeScript worst error message. Luckily, it's easy to avoid once you know the rule.

Declare Assertion Functions Properly to Avoid Confusing Errors

Avoiding TypeScript's Most Confusing Error 

Generics and type predicates make a powerful combination for getting good inference from TypeScript.

Filtering with Type Predicates and Generics

Combining Type Predicates with Generics

Using brands with type predicates provide an alternative to assertions, casting, and other type adjustments when checking for validity.

Checking for Validity with Brands and Type Predicates

Combining Brands and Type Predicates

Using brands with assertions produces a nice validation API with readable error messages.

Validate Types with Brands and Assertions

Combining Brands with Assertion Functions

Reference Type Predicates in the TypeScript Handbook

Type Predicates from the TypeScript Docs

Reference Assertion Functions in the TypeScript Handbook

Assertion Functions from the TypeScript Docs

Type Predicates and Assertion Functions

TypeScript allows for classes to be used as types or values. They are able to cross the boundary between the runtime world and the type world.

Using Classes in TypeScript

Classes as Types and Values

Learn how to use type predicates in TypeScript classes to improve type safety and streamline your code.

Type predicates can simplify your TypeScript code and make it more maintainable.

Simplifying TypeScript with Type Predicates

Dive into Classes with Type Predicates 

Type predicates and assertion functions can bring amazing inference to classes in TypeScript.

Leverage Assertion Functions for Better Inference in Classes

Assertion Functions and Classes

The builder pattern provides a powerful way to construct APIs that fit nicely with TypeScript.

Class Implementation Following the Builder Pattern

Alex, the creator of the TRPC library, walks through an example of the builder pattern.

TRPC's Creator on the Builder Pattern

The builder pattern can be used to remove unknowns and add type safety and  autocompletion by building upon generics.

Getters and Setters in the Builder Pattern

Create a Type Safe Map with the Builder Pattern

One small change can drastically change the behavior of your code and lose your type safety.

Default Generics in the Builder Pattern

Debugging the Builder Pattern

Combining generics with the builder pattern allows you to create chainable functions that work through dynamic inference of inputs and outputs.

The Power of Generics and the Builder Pattern

Building Chainable Middleware with the Builder Pattern

Colin, the creator of Zod, presents examples of subclassing in the library.

Subclassing in Zod

Build high-performance, scalable, and easy-to-use APIs for your applications.

TRPC's Documentation

Classes

Orta Therox, a former member of the core TypeScript team,  discusses how types that you don't define can make their way into your application code.

Where Do External Types Come From?

With some clever type transformations it's possible to extract and extend types from an external library that you don't control.

Retrieve Function Parameters from an External Library

Extract Types to Extend an External Library

Navigating Lodash's Type Definitions

It's important to use proper type arguments and generics when using library functions. Let's practice type definitions to determine what to use and their order.

Passing Type Arguments with Lodash

Finding Proper Type Arguments and Generics with Lodash

The Express types from Definitely Typed ensure that the REST APIs you build are generic and type safe.

Navigating Express's Type Definitions

By making a request function generic, we can effectively handle the query params.

Make an Express Request Function Generic

Add Query Params to an Express Request

Zod is a TypeScript library created with the goal of validating data types. Let's read through its type definitions to better understand the flow of generics.

Browsing Zod's Types

Using Zod allows you to create functions that are both runtime and type safe. This lets you accept different types of input without the need for casting.

Infer Runtime Arguments from a Zod Schema

Create a Runtime and Type Safe Function with Generics and Zod

Sometimes you need to add or override types from an external library. This can be done by using a declaration file.

Create a Declarations File to Override Types

Override External Library Types

The Lodash common module in the DefinitelyTyped repository.

Lodash Types from Definitely Typed on GitHub

See how types are defined for the popular library Express in the DefinitelyTyped project. 

Express Types from Definitely Typed on GitHub

See how the types for Arrays are defined in TypeScript's own source code.

Array from TypeScript's Types on GitHub

Build a deeper expertise with Zod in this free tutorial here on Total TypeScript.

Zod Tutorial on Total TypeScript

See how the Zod library defines its own types.

Zod's Types on GitHub

External Libraries

as const asserts type, but isn't always available. Identity functions with F.Narrow from ts-toolbelt improve inference in these cases.





Using const type parameters For Better Inference

Identity Functions as an Alternative to the `as const`

Constraining and Narrowing an Identity Function

Add Constraints to an Identity Function

Sometimes TypeScript infers when we don't want it to. The `NoInfer` type helps us avoid this problem.

Fix Inference Issues with the NoInfer Type

Specifying Where Inference Should Not Happen

Avoid Duplicate Code in an Identity Function with Generics

Find the Generic Flow of an Identity Function

Reverse mapped types allow changing inference in identity functions to infer from input, rather than output. Mind-bending, but cool!





Inference Inception in an Identity Function

Reverse Mapped Types

ts-toolbelt offers advanced utility types & functions for TypeScript that aren't available in the standard library, helping to write more type-safe code.








ts-toolbelt GitHub Repository

The Narrow utility type from ts-toolbelt can be helpful for narrowing union types in TypeScript, leading to more precise type checking.





F.Narrow from ts-toolbelt on GitHub

ts-toolbelt's NoInfer type prevents unwanted inference, leading to more precise and flexible type definitions in TypeScript.








F.NoInfer from ts-toolbelt on GitHub

TypeScript 5.0's const type parameters can be helpful for enforcing constant values in type definitions, leading to more reliable code.





Microsoft's announcement for TypeScript 5.0 Beta

Mapping over a union to create an object using TypeScript's mapped types can be helpful for generating complex types with ease and flexibility.





The Mapped Types Module of the Type Transformations Workshop

Identity Functions

Add Objects to the Global Scope Dynamically

Merge Dynamic Objects with Global Objects

Practice typing a TypeScript wrapper function for a fruit array that returns a fruit object based on name. Use generics and ts-toolbelt

Transcript

Custom JSX Elements

Transcript