My name is Maina Wycliffe, and I love teaching Typescript to developers. My goal is to break down complex topics into small, understandable bits that you can apply in your day-to-day life as a developer.

Subscribe now

React Advanced London 2024

I want to announce a special collaboration with GitNation, the organizers of events such as JSNation and React Summit in Amsterdam and New York, React Day Berlin, and React Advanced in London.

React Advanced London 2024 is coming up later in the year (October), and as subscribers for All Things Typescript, you will get 10% off for tickets using the code AllThingsTypescript10 for the conference.

In this conference, you learn more about React 19, Performance, Server Components, Senior-Driven Tech Mindset & more! On top of that, you will get to network and reconnect with some of the top minds in the industry and engage in board games and, if you want to, parties and karaoke.

Get your ticket today

Typescript 5.5 Released

The latest version of Typescript (version 5.5) was released in June and has a very exciting update that all Typescript developers are excited about. Typescript has improved Type inference and now can narrow Types based on control flow within arrays when you use the array filter method, which wasn’t possible before.

Before Typescript 5.5., if you filtered an array to, let’s say, remove undefined values inside an array, Typescript wasn’t able to infer that the type needed to be narrowed as the undefined values have been removed. This has changed, as demonstrated in the video clip I created below when the beta version was released.

Other notable features include:

• Control flow narrowing for Constant Indexed Accesses

• Import types into JS Docs (JS Files)

• Type-checking in regular expressions

• ESM Set new methods such as union and intersection are now supported.

And there is more, which you can learn by reading the announcement blog here.

Next week, I will take a deep dive into some of the exciting features of Typescript 5.5.

From All Things Typescript

I want to apologize for not publishing as regularly as in previous months, but I will resume publishing regularly in June, starting next week when I take a deep dive into Typescript 5.5.

I want to give a shout-out to CSS Isn’t Magic by Stas Melnikov. Most of us struggle with understanding CSS concepts, and If you want to change that and take your CSS game to the next level, please subscribe to the newsletter.

From Other Authors

How To Write API Response Types with TypeScript by Artem Holinka

Organize TypeScript types for API responses to ensure a great development experience, code maintenance, and avoidance of obvious coding errors.

Link

7 Use Cases for Javascript Proxies by Matt Lewandowski

JavaScript's Proxy object is a useful tool that opens up a world of possibilities, allowing you to create some really useful behaviors in your applications. When combined with TypeScript, Proxy enhances your ability to manage and manipulate objects and functions in ways you might not have thought possible. In this article, we'll explore the incredible utility of Proxies through practical examples.

Link

Visual testing: The greatest trick in UI development by Michael Shilman

In UI development, making sure everything looks right is as important as making sure it works. Visual tests are image snapshot tests that solve for this.

However, somewhat surprisingly, they can also replace the most brittle part of many UI unit tests: asserting on details of the UI. In many cases this can replace the unit test entirely, allowing you to test more with far less code.

Link

A Gentle Intro to TypeScript by Jo Franchetti

This article is an excellent article for developers who are just getting started with Typescript and wondering why Typescript exists and the fundamentals of Typescript.

Link

Introduction to Sorting Algorithms in JavaScript by Alex Merced

Sorting algorithms are fundamental to computer science and programming. They are essential tools for organizing data in a meaningful order, whether it’s numerical, alphabetical, or based on any other criteria. For JavaScript developers, understanding these algorithms is crucial, as they often need to manipulate and sort data efficiently within their applications. This blog aims to provide an introduction to some of the most common sorting algorithms implemented in JavaScript, highlighting their mechanics and when to use them.

Link

Dual Publishing ESM and CJS Modules with tsup and Are the Types Wrong? by John Reilly

If you need to publish a package that supports both ECMAScript modules (ESM) and CommonJS modules (CJS), you can use tsup to do so. This post will show you how to do that and how to ensure that the types are correct using the tool Are the Types Wrong?.

Link

Understanding JavaScript Object Accessors by Jack Pritom Soren

JavaScript is a versatile and powerful programming language used extensively in web development. One of its key features is the ability to define objects, which can encapsulate properties and methods. Among the various ways to interact with these objects, accessors play a crucial role. This blog post will delve into the concept of JavaScript object accessors, explaining what they are, how they work, and why they are beneficial.

Link

I've been writing TypeScript without understanding it by vincanger

The other day, I was stuck with a bug in some code that was handling optimistic updates, so I asked my colleague Filip for some help. Filip, a TypeScript wizard, mentioned that the satisfies keyword would be part of the solution I was looking for.

Satisfies? What the heck is that? And why had I never heard of it before? I mean, I’ve been using TypeScript for some time now, so I was surprised I didn’t know it myself.

Link

Subscribe now

That's it for this issue. Thank you for getting this far. If you enjoyed this article and would like to support my work, please share and like this issue and consider sharing All Things Typescript with friends and colleagues.

Share All Things Typescript

Did you know you can hire me to coach your team and help them improve their Typescript skills? If this interests you, please get in touch with me to discuss it.

And until next time, please keep on learning.

My name is Maina Wycliffe, and I love teaching Typescript to developers. My goal is to break down complex topics into small, understandable bits that you can apply in your day-to-day life as a developer.

If you want to learn Typescript, please subscribe to this newsletter.

Subscribe now

Now that that self-plug is out of the way (subtle) let’s get to today’s issue.

Typescript Tip 💡

This month was thin on official Typescript news, so instead of that, I will leave you with a Typescript tip instead.

Many developers habitually reach out for type assertions when checking whether an object with a union of types has specific fields. The in-operator is perfect for this, as shown below:

From All Things Typescript

If you like my content and want to support my work, please consider supporting me (you can buy me a double latte, the juice that powers my creativity and determination ☕️) through Github Sponsors.

☕️ Consider buying me a cup of coffee

Book Recommendation

Learning Typescript by Josh Goldberg

This is an amazing book, especially if you are starting Typescript. It’s well laid out, and the concepts are broken down into small, easy-to-understand concepts that are easy to follow and grasp different concepts in Typescript.

You can learn more about the book here.

From Other Authors

Effective Testing in JavaScript by Ashley Davis

This article emphasizes the importance of testing, advocating for a proactive approach where testing is frequent and early, ensuring code remains functional. The author shares personal insights and techniques to make testing less laborious while still effective, ultimately underscoring the goal of delivering reliable code that meets customer needs.

Link

Automatically Generate Types for Your PostgreSQL Database by Paul Scanlon

SQL can be typesafe, in the JavaScript sense of the word. Paul Scanlon demonstrates why devs shouldn't be afraid to work with "raw SQL."

Link

The Typescript feature we all wanted by Ohans Emmanuel

Inferred Type Predicates are now available in Typescript 5.5 Beta. In this article, I’ll explain the much-awaited feature and how it’ll help you write more type-safe code.

Link

A Guide to the Node.js Event Loop by Musab Habeeb

The Node.js event loop is a crucial mechanism in Node.js that makes Node.js programs run concurrently and asynchronously. Mastering the Node.js event loop helps a Node.js developer understand how Node.js programs run under the hood.

In this article, you will learn the basics of the event loop, starting with threads and processes, then how the JavaScript event loop works, and finally, how the Node.js event loop works.

Link

How to document your JavaScript package Andy Jiang, Luca Casonato, Jo Franchetti, and Leo Kettmeir

This article emphasizes the importance of writing clear, concise JSDocs. It outlines best practices for creating JSDocs, including providing good type information, using tags to add detail, and including examples to demonstrate usage. It also discusses the significance of keeping documentation up-to-date with code changes and auditing JSDoc comments to ensure quality. The goal is to help users quickly understand how to use a package with minimal effort, enhancing the package's success within the community.

Link

Subscribe now

That's it for this issue. Thank you for getting this far. If you enjoyed this article and would like to support my work, please share and like this issue and consider sharing All Things Typescript with friends and colleagues.

Share All Things Typescript

Did you know you can hire me to coach your team and help them improve their Typescript skills? If this interests you, please get in touch with me to discuss it.

And until next time, please keep on learning.

My name is Maina Wycliffe, and I love teaching Typescript to developers. My goal is to break down complex topics into small, understandable bits that you can apply in your day-to-day life as a developer.

My First Typescript Workshop

I am excited to announce that I am working on a series of virtual Typescript workshops. The first will be in a couple of months—either later in July or early August.

The first workshop I will be doing is about a topic I am very passionate about - Schema first-type design in Typescript (I will be doing a talk in relationship to this next week for the This is Learning virtual conference (please join).

I aim to teach how to use tools such as Zod and Valibot to design schemas from which you can infer Typescript static. This will create a single source of truth together with static types.

Let me know if you are interested in joining my first workshop by answering the survey below:

I will send out a notification with details on the workshop and instructions on how to sign up.

Subscribe now

Typescript 5.5 Beta Released

The beta version of Typescript 5.5 was released last month, and I will review the features that I found rather interesting and exciting.

Some of the exciting improvements revolve around better type inference. For instance, one that I find personally exciting is control flow type narrowing when arrays are involved.

Currently, if you filter an array to, let’s say, remove undefined values inside an array, Typescript isn’t able to infer that the type needs to be narrowed.

This changes in the next version of Typescript, which can now narrow based on the control flow inside the filter method, as shown below.

This is exciting, isn’t it? Let me know if you want me to explore this further in a future issue of All Things Typescript.

Other notable features include:

• Import types into JS Docs (JS Files)

• Type-checking in regular expressions

And there is more, which you can learn by reading the announcement blog here.

From All Things Typescript

This month, I wrapped up the series around Generics and explored Typescript’s relationship with Javascript.

If you like my content and want to support my work, please consider supporting me (you can buy me a double latte, the juice that powers my creativity and determination ☕️) through Github Sponsors.

☕️ Consider buying me a cup of coffee

From Other Authors

An intro to TSConfig for JavaScript Developers by Jo Franchetti

Have you ever wanted to understand the tsconfig. Jo Franchetti goes over the tsconfig, the different settings available, and its capabilities in this post.

Link

Introducing JSR - the JavaScript Registry

The Deno team introduced a new Javascript Registry optimized for Typescript and ESM Modules. In a series of posts, the registry discusses what JSR is and isn’t and why you should consider using it.

Here is a list of the most interesting blog posts about the registry from the Deno team.

• Introducing JSR - the JavaScript Registry

• How we built JSR

• JSR Is Not Another Package Manager

Improving Code Quality in JavaScript Projects With Qodana by Maksim Grushchenko and Kerry Beetge

JetBrains Qodana is a powerful static code analysis platform that enables teams to analyze code quality and find issues before runtime. This article discusses how to utilize Qodan to improve code quality for JS projects.

Link

Understanding 'Use strict' in JavaScript by Muslimat Mojeed

Strict mode is a special mode in JavaScript that allows developers to opt into a set of rules and restrictions that are not enforced by default.
Strict mode in JavaScript is like having a helpful friend who keeps an eye out for mistakes while you're coding.

Link

This TypeScript Trick Will Blow Your Mind by Daniel Craciun

Daniel Craciun takes us through extracting types from arrays by creating a custom utility type.

Link

Node.js Debugging in Chrome DevTools by Frontend Masters

Learn how you can utilize Chrome DevTools to debut NodeJS and Javascript applications.

Link

That's it for this issue. Thank you for getting this far. If you enjoyed this article and would like to support my work, please share and like this issue and consider sharing All Things Typescript with friends and colleagues.

Share All Things Typescript

Did you know you can hire me to coach your team and help them improve their Typescript skills? If this interests you, please contact me to discuss it.

And until next time, please keep on learning.

My name is Maina Wycliffe, and I love teaching Typescript to developers, my goal is to break down complex topics into small understandable bits that you can apply in your day-to-day life as a developer.

Typescript News

Over the last two issues, we have looked at the release process of Typescript 5.4 which was released last month, so I won’t focus on that on this issue, you can learn more about Typescript 5.4 here.

For this issue, I want to focus on the next version of Typescript which has the potential to be huge. First, before proceeding further, I want to state we are still early and some of the details might change as we get closer to the next issue. Now, that that is out of the way, let me focus on a few interesting changes:

1. APIs marked in version 5 as deprecated are going to be removed, for more information, check out this issue.

2. Ability to add imports, when you copy-paste code from another TS file, the same imports in that file, for information, check out this issue.

3. Narrowing of generics indexed access type return type, for more information, take a look at this issue.

4. And many more such as providing syntax checking for regex, for more information, check out the road map here.

Let me know if there are features you want me to cover in a future issue of All Things Typescript.

Subscribe now

From All Things Typescript

This month, I wrote two articles that explain generics which I hope for those of you who have read them and found very useful.

From other Authors

The `never` type and error handling in TypeScript by Stefan Baumgartner

This article by Stefan Baumgartner goes on to explain more about the never type, common misunderstandings about the never type, and how to correctly handle the never type for handling errors.

For more information, you can go through the article here.

This Pattern Will Wreck Your React App's TS Performance by Matt Pocock

In this article by Matt Pocock, he looks at a case where using one way of defining Typescript type can slow down your IDE performance compared to another way, especially in a large code base.

For more information, you can go through the article here.

Making Your Code Type-Safe with Zod by Leonardo Maldonado

In the past, I have made it clear I am a huge fan of tools like Zod which look to combine schema validation for forms, and runtime data validation, while also getting back to static types for you to use in Typescript. This article takes you through the process of setting up Zod and using it to make your code type-safe with Zod.

For more information, you can go through the article here.

`any` Considered Harmful, Except For These Cases by Matt Pocock

If there is anything I have spent a large amount of time doing in this newsletter, is discouraging you not to use any. In software engineering, it’s quite rare we have a definite answer the correct answer is always, it depends and this article by Matt Pocock is a great example of situations where it’s acceptable to use any.

For more information, you can go through the article here.

Intersection Types In TypeScript by Alex Khomenko

This article by Alex Khomenko takes you through an introduction and a detailed description of what the intersection types are and how you can add them to your toolbox and be comfortable using them in your day-to-day activities.

For more information, you can go through the article here.

TypeScript Intermediates - Type Generics by Corbin Crutchley

This article by Corbin Crutchley is about generics and some real-world uses for generics. He goes into detail explaining a use case, and looks at alternative solutions, before explaining why generics are a good fit and why you might consider using generics for that use case.

For more information, you can go through the article here.

That’s it for now and I will see you again at the end of April, where I will share some interesting reads that I will come across in my learning journey in April. Until then, I will continue teaching Typescript, and next week, we will take a look at Typescript Generics and default values, to wrap up my generics series.

If you found this issue useful, consider subscribing, if you haven’t and if you have (Thank you ❤️) please consider sharing All Things Typescript with your friends and colleagues.

Share All Things Typescript

Until next, keep on learning.

Subscribe now

Announcements

Typescript 5.4 RC Released

We are getting closer to the release of Typescript 5.4 and in February, the release candidate was announced.

Here is a summary of the features to expect:

• Assignment Narrowing is Preserved in Closures

• New NoInfer Utility Type

• Type Declarations for Object.groupBy and Map.groupBy

• Support for require() calls in --moduleResolution bundler and --module preserve

• Checked Import Attributes and Assertions

• Quick Fix for Adding Missing Parameters

Let me know if there are any features you want me to take a look at in the next few issues of All Things Typescript.

Please check out the release blog post here for more information about the above features.

All Things Typescript Feb 2024 Issues

In February, I consistently released articles every week, except one. In case you missed any, here is a list of the issues that I released in February.

From other authors

Articles

When 'as never' Is The Only Thing That Works by Matt Pocock

TLDR: as never is very occasionally needed in TypeScript. Let's look at an example where it's necessary.

Link

Using Generics In TypeScript: A Practical Guide by Alex Khomenko

TLDR: Among these features, generics stand out as one of the most powerful tools for creating flexible, reusable components without sacrificing type safety. In this blog post, we'll dive into the world of generics in TypeScript, exploring how they can be used to write cleaner, more maintainable code that is robust and easy to understand.

Link

TypeScript Advanced Types: Working with Conditional Types by Alex Khomenko

TLDR: Conditional types in TypeScript provide logic to type definitions, allowing for type transformations based on certain conditions. They can be used for type inference, filtering types with utility types, building type-safe API handlers, and defensive programming. Best practices include keeping conditions simple, using type aliases and utility types, and testing types. Limitations include operating at compile-time only and not being suitable for all use cases.

Link

Understanding Async/Await and Promises in JavaScript and TypeScript by Geoffrey Kim

TLDR: This blog post aims to demystify the scenarios where you might or might not need to use await when dealing with Promises, through detailed explanations and illustrations.

Link

How Types Work in TypeScript – Explained with JavaScript + TypeScript Code by Sahil Mahapatra

TLDR: In this comprehensive guide, we'll explore TypeScript's basic types by comparing them with their JavaScript counterparts. I'll also clarify the differences and advantages offered by TypeScript's static typing features.

Link

ESLint no-unused-vars: _ ignore prefix by John Reilly

TLDR: One thing that I missed when switching to the ESLint option is that, with noUnusedLocals and noUnusedParameters, you can simply ignore unused variables by prefixing a variable with the _ character. That's right, sometimes I want to declare a variable that I know I'm not going to use, and I want to do that without getting shouted at by the linter.

It turns out you can get ESLint to respect the TypeScript default of ignoring variables prefixed with _; it's just not the default configuration for no-unused-vars. But with a little configuration, we can have it. This post is a quick guide to how to implement that configuration.

Link

Videos

There’s a fast new code editor in town by Fireship

8 NEW JavaScript 2024 Features by Web Dev Simplified

I didn't know snapshot testing was a thing by Joshua Morony

If you like my content and want to support my work, please consider supporting me (you can buy me a double latte, the juice that powers my creativity and determination ☕️) through Github Sponsors.

Share

That's all for now. I'll see you again at the end of February for another monthly recap.

I am very excited to let you know that starting in January 2024, I will be sending out a monthly curated list of top articles and resources related to Typescript and other relevant technologies. This list will be sent out on the first Monday following the end of each month.

Although I share these articles on my social media, I wanted to create a central place where all of my subscribers could find all the useful resources related to Typescript I come across regularly. This is a return to the roots of the contents of this Newsletter, which was mainly focused on curating Typescript resources.

For those who are still interested in my regular content, don't worry, as it will continue to be sent out every week.

I appreciate your support.

Announcement

TypeScript 5.4 Beta Announced

In late January, the beta version of Typescript 5.4 was released. Some of its features include:

• Assignment Narrowing is Preserved in Closures

• New NoInfer Utility Type

• Type Declarations for Object.groupBy and Map.groupBy

• Support for require() calls in --moduleResolution bundler and --module preserve

• Checked Import Attributes and Assertions

• Quick Fix for Adding Missing Parameters

For more information, check out the official announcement here.

My Articles

Articles

Daniel Rosenwasser on TypeScript and What’s Ahead in 2024 by Loraine Lawson

In this Q&A with The New Stack, Rosenwasser shared TypeScript’s most significant developments in 2023 and provided a preview of what developers can expect to see in the coming year.

Link

Solving TypeScript Errors by Matt Pocock

In this tutorial, you'll find challenges centered around reading error messages and practical solutions to solving the issues they describe.

Link

The Bun Shell by Jarred Sumner

The Bun Shell is a new experimental embedded language and interpreter in Bun that allows you to run cross-platform shell scripts in JavaScript & TypeScript.

Link.

Using Zod's schema to render a reusable and dynamic Angular table component by Tim Deschryver

In this blog post, we'll see how to use Zod to dynamically build a (minimal) table as a reusable and typesafe Angular component. For this, the following Person schema will be used within the next snippets.

Link

Everything You’ve Always Wanted to Know About TypeScript’s Integration in WebStorm by Jan-Niklas Wortmann

Ever tense up when a new TypeScript version drops? You cross your fingers and hope it plays nice with your IDE. You’re not alone. Relax into this fireside chat with WebStorm lead developer and Team Lead, Andrey Starovoyt, as we pull back the curtain on TypeScript’s integration in WebStorm.

Link

Modern JavaScript library starter by Tamás Sallai

How to publish a package with TypeScript, testing, GitHub Actions, and auto-publish to NPM

Link

TDD: Writing Testable Code by JavaScript Scene by Eric Elliott

Writing testable code is a vital skill in software engineering. Let’s explore practical advice, strategies, and tactics for writing more testable code, unlocking the benefits of modularity, reusability, and high quality software in your projects.

Link

Writing type safe API clients in TypeScript by Nazeel

Writing API integrations can be a daunting task. But it does not need to be. How many times have you had to deal with these problems?

Link

Leveraging TypeScript for domain-driven design by Matteo Di Pirro

Domain-driven design (DDD) is a software development approach that aims to simplify the creation of applications that involve complex business logic. In this article, we’ll explore how to leverage TypeScript for DDD. TypeScript’s sophisticated type system enables fine-grained domain modeling and is highly adaptable, lending itself to complex app development.

Link

The Discriminated Union: Writing Easy-to-Use Types in TypeScript by Peter Van Drunen

TypeScript’s flexibility is one of the reasons I love using it. Unfortunately, that flexibility also provides opportunities to write confusing code. The main area where I see developers struggling is defining types that make writing code painful or verbose. Often, this comes in the form of using optional fields to extend types so they represent too many ideas within the same type.

Link

That's all for now. I'll see you again at the end of February for another monthly recap.

Subscribe now

Without further ado, let's get started:

Top Articles of the Week - 2nd of Sep 2022

Structural Typing in Typescript - If it looks like a duck, walks like a duck, quacks like a duck …

by Maina Wycliffe

How do you test whether a bird is a duck? One approach would be to ask a series of questions, and the answers would dictate whether it’s a duck:

• Does it look like a duck?

• Does it walk like a duck?

• Does it quack like a duck?

If the answer to all those questions is yes, then we can conclude it must be a duck. We are checking whether the bird in question models the behavior we expect from a duck, and if it matches up, we can then conclude it’s a duck with a certain level of certainty. This is popularly known as the duck test, and Typescript type checking operates similarly. This is known as structural typing or property-based typing.

Link

The Butterfly Effect: How we gave the Linter a 100x boost

by Miroslav Jonaš

Recently we had a significant performance improvement in our linter rule. In some benchmarks, the increase was up to 100x! While one would expect such a dramatic change to result from implementing a sophisticated algorithm, the reality is that this resulted from minor tweaks. Like the butterfly effect — changing a few lines of code created a ripple effect that tremendously improved the overall performance.

Link

Getting Started With Testing Types in TypeScript

by Nic Jennings

As soon as you start writing more advanced types such as Generics or Conditional Types in TypeScript then it should become a crucial step in checking that your type is doing exactly what you expect. Testing Types is a little different to writing your normal Unit Tests as we are testing untranspiled code.

There are three main options when it comes to testing types: Using a tool like dtslint, tsd or making use of the @ts-expect-error comment. I will be covering @ts-expect-error as this is the easiest way to get started and it requires no additional tooling.

Link

Immutability with Typescript

by Oscar

The next step to learn how to use functional programming with Typescript is to understand the concept of Immutability.

If we go by the dictionary description we can simply say that Immutability means “not capable of or susceptible to change”.

Link

Why your website should be under 14kb in size

by Nathaniel

Having a smaller website makes it load faster — that's not surprising.

What is surprising is that a 14kB page can load much faster than a 15kB page — maybe 612ms faster — while the difference between a 15kB and a 16kB page is trivial.

Link

Build Your Own Git With TypeScript

by Maxsuel Silva

In today’s experiment, I want to share with you how to build a few features of Git with TypeScript. Of course there would exist better ways to do it, but here’s how I can see and solve the problem. This is a simplistic point of view of a complex thing, I hope you enjoy it.

Link

How To Improve the Jest Performance in CI Environments When Using TypeScript

by Carlos Fernando Arboleda Garcés

Every single developer or developer team must make decisions when building a new project, and in this case, we are talking about Node.js projects. When talking about JavaScript development, one of the best decisions you can make is to use TypeScript since this will give you extra tools to write a more clear and maintainable code.

Another good decision is to add a test framework or library to your project, and it’s not a secret that Jest is currently the most used framework and is a good choice since it has a powerful built-in assertion library.

Link

How to Optimize Your Node.js API

by Kayode Adeniyi

Optimization involves improving the response time of your API. The shorter the response time is, the faster the API will be.

The tips I will share in this article will help you reduce response time, lower latency, manage errors and throughput, and minimize CPU and memory usage.

Link

7 Shell Shortcuts To Speed Up Development

by Tate Galbraith

With the advent of elegant, full-service IDEs there are now fewer and fewer command-line interactions by developers. When you can install a package or manage files from a pretty UI why would you need an arsenal of outdated shell tricks? If you’ve ever run into a problem that couldn’t be solved by a fancy IDE then you’ll understand why having these tools at your disposal is of paramount importance.

In this article, we’ll discover some simple, yet incredibly effective shell shortcuts and commands. Using these tips you can troubleshoot errors quickly, run commands faster and execute searches with minimal effort.

Link

Accessible Lists Made Easy Using the Angular CDK Listbox Module

By Netanel Basal

Fortunately, starting from version 14.2.0, this is made seamless by the Angular CDK. A new module named @angular/cdk/listbox provides directives to help create accessible custom list boxes.

Link

Conclusion

That’s it from me and I hope you found the above list enlightening. I hope you have a fantastic weekend and see you next week.