[00:00] In this exercise, we have attempted to create some reusable type guards, but it's all gone a little bit wrong. We have down here a passValue function and a passValueAgain function. What these functions do is they're pretty much identical. You can imagine some sort of different logic inside them. But they all need to do this 1 check,

[00:18] which is a hasData and id check, where they're taking in a value of unknown. And they're supposed to be checking that value here is a really complicated check. It's an object, that the value is not null, that there's a data property on it, that value data is an object, that value.data is not equal to null, that there's an id property on

[00:38] value.data, and that value.data.id is a string. This all looks fine actually inside this check here, and if we were to move this and actually just remove hasData and id from both of these then actually the check would work. So this code would just work here but ideally we do want to take this

[00:58] code and just stick it in its own function because it's so verbose. Your job is to try to work out using something called a type predicate, how you would annotate this function has data and ID to make sure that what it returns tells TypeScript that value is what we think it is, which is an object with a data

[01:18] object on it that has an ID property on it that is a string. And that should make all of the tests pass. Good luck.

In this exercise, we have a `passValue` function and a `passValueAgain` function that are nearly identical. Both functions take in a value of `unknown` type and need to perform a complex check on the value before proceeding.

However, there are currently some errors. Inside of the `hasDataAndId` function, the check verifies that the value is an object, not null, and has a `data` property. It also checks that `value.data` is an object, not equal to null, and has an `id` property of type string.

Here's what the check looks like:

```tsx
const hasDataAndId = (value: unknown) => {
  return (
    typeof value === "object" &&
    value !== null &&
    "data" in value &&
    typeof value.data === "object" &&
    value.data !== null &&
    "id" in value.data &&
    typeof value.data.id === "string"
  );
};
```

We also have `parseValue` and `parseValueAgain` functions that call `hasDataAndId` to perform the check. The code inside of them is identical, and they both throw an error if the check fails. However, there is currently an error underneath `value` because TypeScript does not recognize the type of `value` after the check:

```typescript
const parseValue = (value: unknown) => {
  if (hasDataAndId(value)) {
    return value.data.id; // red squiggly line under value
  }

  throw new Error("Parsing error!");
};

const parseValueAgain = (value: unknown) => {
  if (hasDataAndId(value)) {
    return value.data.id; // red squiggly line under value
  }

  throw new Error("Parsing error!");
};
```

## Challenge

Your task is to use a type predicate to annotate the `hasDataAndId` function. This will tell TypeScript that when the function returns `true`, the `value` parameter is an object with a `data` property, which in turn is an object with an `id` property of type string.

Correctly implementing the type predicate should make all the tests pass.

Learn how to use type predicates to create reusable type guard functions that tell TypeScript the type of a variable when a function returns true.

[00:00] The solution here is we need to add an extra annotation to hasData and id. The annotation we need to add is a return type annotation, and we need to give it a type predicate. We're going to say value is, and then for now let's just say string. And this will look a little bit weird to you. What

[00:18] we're saying here, this little bit here is a type predicate. And we're saying that the value that gets passed in is going to be a string when this function returns true. So if we look at pass value here, we're basically saying has data on id just there. It's returning that the value is a string. So if we hover over value here, it's saying string

[00:37] and we're getting an error because property data does not exist on type string. So that's not quite right. And it's interesting that value is string just doesn't match this check here, but TypeScript isn't warning us. We'll get to that in a bit. To make our test pass, what we need to say is it's not a string, is in fact an object with a data

[00:56] property on it, which itself has an ID property, which is a string. So there we go. After a bit of formatting, we can see that we've properly annotated this now. And now, as data and ID, it's properly checked and value is an object with data and ID on it. Now, you're looking at this and you're

[01:16] going, why can't TypeScript infer this automatically? Since TypeScript 5.5, TypeScript has been able to do this logic perfectly fine. Why can't it infer this for me? Well, it turns out that that feature, automatic type predicate inference, has a little bit of a fail safe in it. It means that if your check is

[01:35] really, really complicated like this and like multiple lines long, TypeScript will kind of bail out of it and will prevent you from inferring it. So I think it might be like 3 lines. Yeah. OK. 3 lines seems to be working. Does 4 lines work? Okay, at 4 lines, it bails out and says, nah, I'm not gonna do

[01:53] this. So I'm not sure fully of the rules here, haven't dived into the compiler code to check this, but it means that sometimes you do need to manually annotate your type predicates themselves. And this has some downsides because as we saw earlier, we can say value is data ID string, but what if we're

[02:12] not fully completing the check inside here? So we just deleted some lines of the check and now there's nothing TypeScript saying that means this is wrong here. It seems like our type predicate here can totally be out of sync with the logic that is defined at runtime. And that's true.

[02:31] Type predicates are a little bit unsafe, but what they do let you do is just extend your faith in your code a little bit more. And it means that you can do things like this where you have a big complicated check and you just need to annotate that it returns the type correctly. So if you are using type

[02:50] predicates, remember, they're about as unsafe as I would say as or the non nullable assertion, but they do let you make these nice kind of, I mean, the actual user code here is really, really nice. And being able to capture complicated logic inside these type helpers, even if you do have to manually

[03:10] edit them, and they're kind of a little bit brittle, it is still really, really nice. So manually adding type predicates, sometimes you need to do it, especially when you're using big complicated logic statements like this.

The solution is to add a return type annotation to `hasDataAndId` that has a type predicate. We need to specify that the `value` parameter is an object with a `data` property, which itself has an `id` property of type `string`. This annotation guides TypeScript to narrow down the type of `value` correctly:

```typescript
const hasDataAndId = (
  value: unknown,
): value is {
  data: {
    id: string;
  };
} => {
  return (
    typeof value === "object" &&
    value !== null &&
    "data" in value &&
    typeof value.data === "object" &&
    value.data !== null &&
    "id" in value.data &&
    typeof value.data.id === "string"
  );
};
```

The `value is string` is the type predicate that tells TypeScript the expected shape of the `value` parameter when the function returns `true`. This annotation allows TypeScript to narrow down the type of `value` inside the `parseValue` function.

## Considerations and Limitations

You might be wondering why TypeScript can't infer the type predicate automatically. Since TypeScript 5.5, the compiler can handle complex type checks and infer type predicates. However, there are limitations to this feature. 

There is a fail-safe mechanism in TypeScript that prevents automatic inference if the type check logic is too complex or spans multiple lines like in our example. In cases like these, you'll need to manually annotate the type predicate to guide TypeScript correctly and keep your type predicates in sync with the runtime logic.


TypeScript 5.5 allows you to annotate a return type with a type predicate to guide TypeScript in narrowing.

Annotate a Return Type with a Type Predicate

Using Type Predicates to Create Reusable Type Guards

Total TypeScript Pro Essentials is the **ultimate guide to becoming a TypeScript Wizard**.

Pro Essentials **requires zero TypeScript knowledge** to get started. We'll start with setting up your IDE and understanding TypeScript's place in the build process. We'll cover everything you need to go from a good JavaScript developer to a great TypeScript developer.

But we won't stop there. The material goes all the way up to advanced topics like generics, type guards and building shared utilities. If you feel like **you never _really_ learned TypeScript**, now's your chance.

We don't believe in sitting back and learning passively. With over **200 lessons in 17 sections**, the Pro Essentials workshop is a _practical_ course. The material has been tested in several in-person workshops and refined with feedback from hundreds of students.

Whether you're picking up TypeScript for the first time, or want to deepen your knowledge, Pro Essentials is the course for you.

Here’s what’s included:

## Introduction to TypeScript

Kickstart your TypeScript setup with a refresher on the core benefits and concepts of TypeScript: initial configuration, the TypeScript compiler, and type inference.

Follow the recommended setup and extensions for your editor, with a focus on Visual Studio Code, and become familiar with features like navigation, autocompletion, refactoring, and writing self-documenting code.

Understand TypeScript's role in the build process, and why browsers need help understanding the syntax. Structure your project to work nicely with the compiler, and configure for working with modern build tools like Vite and hot module replacement (HMR). Practice setting up type checking in a CI/CD pipeline, preventing errors from reaching production.

## TypeScript Fundamentals

Reinforce your foundational skills by working with TypeScript's essential types and annotations. You'll work with function parameters and return types, and model data with object literal types, arrays, and tuples. Write reusable type aliases, correctly type async code, and handle data that comes from external sources. Create more flexible types by using unions, intersections, and interfaces.

Write more expressive code that refines types through several narrowing techniques, and recognize the role of any, never, and unknown in your codebase.

## Objects, Classes, and Mutability

Types, interfaces, and classes all have their place in TypeScript. Learn the differences between them, and how to choose the right structure for your needs. Work with dynamic data in objects, and and overcome index signature limitations by using mapped types. Practice using essential type helpers like Pick, Omit, and Partial, and how to build your own helper when you need to.

Develop the mental model for how mutability affects type inference and safety. Recognize the benefits of immutable data structures, and how to work around their quirks.

Apply object-oriented programming principles to your TypeScript code. Understand the role of classes, constructors, and access modifiers, and how to use inheritance and composition to build complex systems that follow real-world design patterns.

## Working with the Compiler

Harness the power of the TypeScript compiler to derive types from values, while furthering your understanding of type inference. Create new kinds of type aliases, and use indexed access types to target nested properties.

Recognize when TypeScript needs your help through type annotations and assertions, and the purpose of as, asserts, and satisfies. Apply these techniques to real-world scenarios like working with DOM APIs, parsing JSON, and creating configuration objects.

## Understanding the Environment

Distinguish between TypeScript modules and scripts, and prevent global scope pollution. Provide types for JavaScript files and third-party libraries, and understand the role of ambient declarations.

Safely modify global interfaces like Window through declaration merging, work with namespaces like JSX, and understand when to use .d.ts type definition files vs. modules.

Learn best practices for configuring TypeScript's behavior based on the type of project you're working on. Adjust strictness levels, module resolution, and generate type declaration files. Use TypeScript as a linter, and optimize build performance for large projects.

## Advanced Application Development

Understand the core differences between CommonJS (CJS) and ES Modules (ESM), and how TypeScript handles module syntax. Learn to use file extensions for guiding module resolution, and configure TypeScript settings for more consistent behavior. Make informed decisions about when to adopt ESM into your projects, and build libraries that support both CJS and ESM consumers for maximum compatibility.

Practice domain modeling by representing real-world concepts and encoding business logic within your types. Establish single sources of truth for type definitions, and create reusable generic type utilities. Enforce stricter type checking with well-placed constraints.

Combine generics and function overloads for maximum flexibility, and create custom type guards and predicates to enhance type inference. Create type-safe APIs with template literal types, mapped types, and custom error types.


Learn TypeScript by setting up a pro environment, using advanced IDE features, and mastering type annotations, unions, object types, inference, and generics.

Pro Essentials Workshop

Total TypeScript Pro Essentials is your comprehensive workshop to master TypeScript. With over 200 lessons across 12 sections, from foundational setup to advanced techniques, conquer type-related challenges and optimize your development workflow with confidence. Whether you're starting fresh or refining your expertise, unlock the full potential of TypeScript today.

TypeScript Pro Essentials

Total TypeScript Complete Volume is a set of five full TypeScript workshops for the advanced-beginner to expert professional TypeScript programmer that wants to take their skills to the next level. This bundle includes all of the Total TypeScript self-paced workshops.

Type Transformations

TypeScript Generics

Advanced TypeScript Patterns

Advanced React with TypeScript

TypeScript Expert Interviews

Complete Volume

Discover the history of TypeScript, how it evolved from JavaScript, and how it can drastically improve your development experience with better tooling.

TypeScript's Relationship with JavaScript

Learn the differences between TypeScript and JavaScript in terms of build processes, file extensions, and how code is run in browsers and Node.js.

JavaScript vs. TypeScript in the Build Process

To get set up for TypeScript development, you'll need an IDE, Node.js, and an execution environment.

Essential Tools for TypeScript Development 

A quick guide to installing Node.js and Visual Studio Code to create a stable environment for web development.

Set up Node.js and VS Code

The pnpm package manager is a faster and more disk-efficient alternative to npm.

Installing pnpm for Package Management

The Total TypeScript VS Code extension provides helpful hints, syntax guidance, and error translations for an improved TypeScript coding experience.

Installing the Total TypeScript VS Code Extension

Kickstart Your TypeScript Set Up

Troubleshoot an unexpected token error in the browser when trying to import a TypeScript file.

Browsers are only able to understand JavaScript syntax, so we need to convert TypeScript syntax to JavaScript syntax for browser execution.

Browsers Can't Understand TypeScript Syntax

Unexpected Token Error in the Browser

Use the TypeScript CLI to convert a TypeScript file into a JavaScript file.

The tsc command can be used to convert TypeScript files into JavaScript files.

Compile TypeScript to JavaScript with the TypeScript CLI

Convert a TypeScript File into a JavaScript File

Currently we have to manually run the TypeScript CLI every time we make a change. The tsc CLI features a watch mode to do this automatically.

Running tsc in watch mode allows you to automatically compile TypeScript files as you make changes.

Use tsc's Watch Mode to Automatically Compile TypeScript Files

Automating TypeScript Compilation

Currently our TypeScript files are compiled to the same directory as our source files. Let's change that!

Using the outDir setting in tsconfig.json, you can configure the output directory for all emitted files.

Configure the Output Directory for Compiled Files

Compiling TypeScript Files to a Directory

Vite provides a simple and efficient way to build front-end apps for web development.

Create a new project with Vite and TypeScript to improve upon our current setup.

Configure Vite for a Vanilla TypeScript Project

Use Vite for a Frontend App with TypeScript

Now that we are using Vite to transpile TypeScript files into JavaScript files, the tsc command doesn't seem to do anything at all.

When the noEmit option is set to true in the tsconfig.json file, TypeScript acts more like a linter than part of the build process.

TypeScript as a Linter

Comparing Vite with tsc

Integrating TypeScript into a CI/CD system allows it to catch errors before they make it to production.

TypeScript in a CI/CD System

There is some controversy around whether or not TypeScript should block your dev server when there are errors. Let's explore the pros and cons of different approaches.

Should TypeScript Block Your Dev Server?

The tsx CLI tool allows you to quickly run scripts written in TypeScript.

Quickly Create Scripts with tsx

TypeScript in The Build Process

Learn how to identify and fix common type errors in your functions.

Common sense tells us that the booleans in the `add` function should be replaced with some sort of `number` type.

Fixing Errors in the `add` Function

Understanding Function Errors

Learn about annotating empty function parameters in TypeScript.

As a general rule, you should always annotate the parameters with their respective types when writing functions.

Annotating Function Parameters

Annotating Empty Parameters

TypeScript has several basic types that can be used to annotate variables.

TypeScript comes with a set of basic types to help define what kind of values can be assigned to variables.

TypeScript Basic Types

Basic Types in TypeScript

Learn how to make function parameters optional in TypeScript to handle different argument formats.

Using the `?` , add optional parameters in TypeScript functions.

Optional Function Parameters in TypeScript

Optional Function Parameters

By adding default parameters to a function, you can specify a value that is used when an argument is not provided by the caller.

Default parameters in TypeScript are specified using the `=` syntax.

Add a Default Parameter with `=`

Default Parameters in JavaScript Functions

Annotate the type of object literals to avoid TypeScript errors and improve inference.

The ({ }) Syntax is used for objects in TypeScript so, this doesn't need to be shown.

Annotating with {}

Typing Object Literals

Object property types can be made optional, allowing for flexibility in the shape of objects.

TypeScript allows you to mark properties as optional within an object. This lets you be more expressive when defining types.

Specifying Optional Properties

Making Object Property Types Optional

Having a single source of truth for type definitions in TypeScript functions helps to reduce duplication and make changes in the future easier.

The `type` keyword allows us to reference a type by a different name. This is useful when we want to consolidate multiple types into a single type alias.

Creating `type` Aliases

A Single Source of Truth for Type Definitions

To add an array to an object, we need to define the type of items the array contains.

Learn about the two different syntaxes for defining arrays in TypeScript.

Two Syntaxes for Arrays

Add an Array to an Object

When working with arrays of objects in TypeScript, you need to define the type properly.

There are few different ways in which an array of objects can be expressed

Representing an Array of Objects

Arrays of Objects in TypeScript

Update rest parameters to specify the type of arguments being passed into a function in TypeScript.

Learn how to use rest parameters to pass an indefinite number of arguments of the same type to a function in TypeScript.

Using Rest Parameters in TypeScript

Rest Parameters in TypeScript

Tuples provide a way to enforce precise array structures in TypeScript.

Tuples in TypeScript allow you to define fixed-length arrays with specified types for each member.

Using Tuple Syntax in TypeScript

Tuples for Precise Array Structures in TypeScript

TypeScript allows for optional members in tuples, allowing for more flexibility in type definitions.

Learn how to specify optional members in a tuple using named tuples and the optional operator in TypeScript.

Working with Optional Tuple Members in TypeScript

Using Optional Tuple Members in TypeScript

Learn about the use cases for the `any` type.

Using "any" in TypeScript may seem like a quick fix, but it actually turns off type checking and can cause issues down the line.

The Dangers of Using "any"

The Controversial `any` Type

How to make sure a function and its parameters and return types fit certain criteria, and how to annotate functions passed as arguments

Type aliases can be used to annotate function types for arguments, callbacks, and return values to enforce type safety and enable proper inference.

Function Types for Type Aliases in TypeScript

Function Types

An example of strictly typing a webpage event listener with no return value.

The `void` type is useful for functions that have no return value, like event listeners or functions with side effects.

The `void` Type

Typing an Event Listener

Learn how to restrict the types of elements that can be added to a Set in TypeScript.

Generics are used specify the type of data that can be used in a Set.

Creating Typed Sets

Restricting `Set` Types

Ensure proper TypeScript typing with Maps by specifying the key and value types needed.

Types in Maps ensure that only correct key-value pairs are added or retrieved.

Adding Types to Maps

Type Checking Maps

Learn how to parse JSON with TypeScript, and the common problems and gotchas that can occur.

The parsed data returned by JSON.parse is expected to be any. To resolve this, we remove the generic type arguments.

Decoding the JSON.parse Error

Debugging JSON Parsing

Learn how TypeScript infers types when working with async functions and API responses.

Unlike regular functions, you can't pass type arguments to the methods called inside an async function.

Adding Types to an Async Function

Typing Fetch API Responses in Async Functions

Essential Types And Notations

Learn how the TypeScript server in your IDE helps you catch errors and enables features like autocomplete and hovers.

Understanding How TypeScript Works in Your IDE

One of the coolest features of the TS server is the ability to introspect variables and declarations in TypeScript.

Introspecting Variables and Declarations in TypeScript

Hovering over a function call can give hints about what arguments a function requires.

By using hovers effectively, you can quickly understand and fix errors in your code without having to read lengthy error messages.

Fixing Errors with Hovering

Hovering Over a Function Call

Learn how to add comments that appear when a function is hovered over in TypeScript.

TSDoc comments allow you to document the purpose and usage of your code, providing a powerful way to communicate with others.

TSDoc Comments

Adding Documentation for Hovers

Take advantage of TypeScript's powerful autocomplete feature by knowing when and where to trigger it.

Hitting Control + Space in VS Code will open a list of all sorts of available options such as properties, methods, and DOM events.

The Control + Space Shortcut

Manually Triggering Autocomplete

TypeScript's Approach to Errors

Learn how to quickly rename symbols using VS Code's built-in features.

Quick Renaming in VS Code

Learn how to utilize TypeScript's "Go-To Definition" feature to easily navigate and understand code across files, making it a valuable tool for managing large codebases.

Navigating Code with "Go to Definition"

There are several ways to quickly import multiple variables from another module in VS Code.

Manually importing variables can be time-consuming and tedious. TypeScript supports autocomplete and quick fix hotkeys to make this process faster.

Using Autocomplete and Quick Fix to Import Variables

Fast Imports in VS Code

Visual Studio Code provides an "Organize Imports" command to help clean up import statements in large files.

VS Code provides a a hotkey for the Organize Imports command, making it quick and easy to clean up your code.

The Organize Imports Hotkey in VS Code

Organizing Imports in Large Files

The Quick Fixes menu in VS Code provides several helpful options for refactoring your code.

Targeting different sections of your code in this editor allows for a wide range of Quick Fixes.

Refactoring with Quick Fixes

Quick Fix Refactoring

Prettier is a code formatting tool for JavaScript and other languages. It can be added to a project or used as a VS Code extension.

Automatic Code Formatting with Prettier

Learn how to restart the TypeScript Server in VS Code and ensure that errors are correct.

Restarting the TypeScript Server in VS Code

Integrated Development Environments Superpowers

Learn how to handle null values in TypeScript and avoid type errors in your code.

Understand how union types allow you to express an "or" relationship between types.

Introducing Union Types in TypeScript

Handling Null Values in TypeScript

Understanding union types and assignability is essential to working effectively with TypeScript.

Diving Deeper into Unions and Assignability

TypeScript allows you to specify exactly which values are allowed as function arguments.

By combining literal & union types, we can restrict what values are allowed in certain scenarios.

Combining Literal & Union Types

Restricting Function Parameters

Literal types are assignable based on their literal values.

Literal Type Assignability

Learn how to combine unions in TypeScript to create type aliases with as little duplication as possible.

Transcript

Using Type Predicates to Create Reusable Type Guards

Transcript