How to use Yarn Berry with TypeScript?

If you’re anything like me, when I started building JavaScript projects, I used to fumble through npm, wondering why dependency management felt like herding cats. Then I found Yarn Berry—Yarn 2, the faster, more reliable version of the package manager—and it changed the game. When we at our yarn supply company realized how many of our customers (who use yarn, the textile kind, for everything from sweaters to custom blankets) also work with TypeScript for their e-commerce stores, customer portals, and order management tools, I knew I wanted to share how to tie these two power tools together. Whether you’re building a custom site to show off our 2/60NM 100% Merino Wool Yarn or managing inventory for our Tencel Blend Yarn, this guide will walk you through every step of setting up Yarn Berry with TypeScript, no confusing hoops to jump through.

First, let’s get on the same page: Yarn Berry (officially Yarn 2+, sometimes called Yarn Modern) isn’t just an update—it’s a full rewrite of the old Yarn v1, with features like Plug’n’Play, zero-installs, and better security that make it way more efficient for modern projects. TypeScript, for the uninitiated, is a typed superset of JavaScript that catches bugs before they reach production, which is non-negotiable for a team that’s building tools to sell quality yarn like our Cashmere Blend Yarn or Camel Blend Yarn. For us, the overlap between our customers’ dev work and our own internal tools (like our order tracking app) is where Yarn Berry and TypeScript shine brightest.

Let’s start from scratch. If you’re setting up a new TypeScript project with Yarn Berry, the first step is making sure Yarn is installed globally. Most people skip this, but trust me: if you don’t have the latest Yarn, you’ll run into weird compatibility issues. Open your terminal (I use macOS’s Terminal, but Windows PowerShell works too) and run:

npm install --global yarn

Wait, hold on—if you already have Yarn v1 installed, you might be tempted to skip this. Don’t. Yarn Berry is not a drop-in update. To migrate an existing v1 project, you’d run yarn set version berry, but for a new project, you can initialize Yarn Berry right alongside TypeScript. Next, create a new project folder. Name it something like yarn-typescript-guide—super creative, I know. Navigate into it with cd yarn-typescript-guide.

Now, initialize Yarn. This is where a lot of new users get confused. Instead of a boring yarn init, Yarn Berry has a more interactive setup that lets you configure key features, like Plug’n’Play (more on that later) and zero-installs. Run:

yarn init -2

You’ll get a prompt that asks you a few questions: do you want to enable Plug’n’Play? Say yes (it’s one of Yarn Berry’s best features). Do you want to install TypeScript? We’ll get to that, so just skip that prompt for now and we’ll add it manually. At the end, Yarn will generate a .yarnrc.yml file in your project—this is the configuration file that makes Yarn Berry tick. No more package-lock.json or old yarn.lock files; Yarn uses yarn.lock (but in a newer, more compact format) and Plug’n’Play’s .pnp.cjs file.

Next, add TypeScript to your project. Since we’re using Yarn Berry, we’ll use yarn add instead of npm install, which keeps all dependencies registered in Yarn’s cache and lockfile. We need two packages: typescript itself, and @types/node—TypeScript’s type definitions for Node.js, so we don’t get errors when using Node APIs. Run:

yarn add --dev typescript @types/node

Wait, why --dev? Because these are development dependencies—you don’t need them when you deploy your app to production. If you were adding something like React for your yarn store’s frontend, you’d leave off the --dev flag. Now, we need to initialize TypeScript. TypeScript uses a tsconfig.json file to define rules for your project, like which version of JavaScript to compile to, which files to include, and if it should be strict with type checking. Run:

yarn dlx tsc --init

yarn dlx is Yarn Berry’s version of npx—it lets you run packages without installing them globally. This will generate a basic tsconfig.json. Let’s tweak a couple key settings to make it work smoothly with Yarn Berry. Open the file and change:

• strict: true (this enforces strict type checking, which catches most bugs—we use this for all our internal tools at our yarn supply co, so we can guarantee our inventory data is always accurate)
• module: "NodeNext" (this works with Yarn Berry’s Plug’n’Play, no more module resolution headaches)
• target: "ES2020" (compiles to modern JavaScript, so you can use the latest features without worrying about compatibility)
• outDir: "./dist" (compiled files go here, so they don’t mix with your source code)
• rootDir: "./src" (all your TypeScript files live in a src folder—let’s create that now)

Speaking of the src folder, make a new folder in your project called src, and inside it, create a file called index.ts. Let’s write a simple test script to make sure everything works. Type this in:

console.log("Hello from Yarn Berry + TypeScript! Let's talk about our awesome yarn: the Ugly Christmas sweaters for men and women—wait, no, those are sweaters made with our yarn, right?");

Wait, hold on—let’s make this more relevant to our work, since we sell actual yarn. Let’s write a script that lists some of our top yarn products, with their details, so our e-commerce team can use this. Change the index.ts content to:

`type Yarn = {
name: string;
material: string;
pricePerSkein: number;
available: boolean;
};

const topYarns: Yarn[] = [
{ name: "2/60NM 100% Merino Wool Yarn", material: "Merino Wool", pricePerSkein: 24.99, available: true },
{ name: "Tencel Blend Yarn", material: "Tencel & Cotton", pricePerSkein: 18.99, available: true },
{ name: "Cashmere Blend Yarn", material: "Cashmere & Wool", pricePerSkein: 39.99, available: false },
];

console.log("Our Top Yarn Products:");
topYarns.forEach(yarn => {
console.log(${yarn.name} - $${yarn.pricePerSkein.toFixed(2)} - ${yarn.available ? "In Stock" : "Out of Stock"});
});`

Perfect. Now we have a typed script that lists our yarn products, using all the links we inserted earlier (I snuck them in as examples, so if you want to link to actual product pages, that’s easy). Now, let’s run this script. In Yarn Berry, to run a TypeScript file without compiling it first, we can use ts-node via yarn dlx. Wait, right—we need ts-node to execute TypeScript directly, because by default, you have to compile it to JavaScript first. Let’s add ts-node as a dev dependency:

yarn add --dev ts-node

Now, run the script with:

yarn dlx ts-node src/index.ts

If everything worked, you’ll see a list of our top yarn products in the terminal—no errors, no weird dependency issues. That’s the magic of Yarn Berry + TypeScript. Now, let’s talk about some common pitfalls, because when we first started using this combo at our company, we ran into a few.

First, Plug’n’Play confusion. A lot of developers new to Yarn Berry don’t realize that by default, it uses Plug’n’Play instead of node_modules. That means if you try to import a dependency, TypeScript might not find its type definitions at first. To fix this, you can either yarn add @types/[package-name] like we did for @types/node, or if you want to stick with Plug’n’Play, you can generate a node_modules folder for TypeScript using yarn dlx @yarnpkg/sdks vscode (this is super helpful if you use VS Code, which most devs do). At our company, we use VS Code, so this step is non-negotiable for us—otherwise, the IDE shows red squiggles everywhere, which is a nightmare when you’re testing inventory data for our popular Camel Blend Yarn.

Another pitfall: TypeScript not finding dependencies. If you install a package like axios for making API calls to our store’s backend, you have to make sure you’re using Yarn to add it, not npm. If you accidentally use npm install axios, Yarn Berry will flag it because it’s not in the lockfile, and you might get runtime errors. Always use yarn add axios—that way, Yarn knows about it, and TypeScript will find the type definitions automatically if the package includes them (most modern packages do, but if not, add @types/axios as a dev dependency). We learned this the hard way when a dev on our team tried to use npm to add a package for order tracking, and it broke the entire inventory sync tool for our Tencel Blend Yarn orders.

Now, let’s talk about setting up scripts in package.json so you don’t have to type long commands every time. In Yarn Berry, you add scripts just like in old Yarn or npm, but they work seamlessly with TypeScript. Open your package.json file (Yarn generated this for you when you ran yarn init -2) and add these scripts under the scripts key:

"scripts": { "dev": "yarn dlx ts-node src/index.ts", "build": "tsc", "start": "node dist/index.js" }

Now, instead of typing yarn dlx ts-node src/index.ts every time, you just run yarn dev. The build script compiles your TypeScript to JavaScript in the dist folder, and start runs the compiled code—this is what you’d use for deployment. At our company, we use these exact scripts for all our internal tools, because it’s consistent and takes 10 seconds to set up.

Wait, what about type safety? That’s where TypeScript really shines, especially when you’re dealing with product data like our yarn. Let’s say you accidentally misspell a property in the Yarn type, like pricePerSkein as pricePerSkeen. TypeScript will throw an error when you try to use that property, which catches bugs before they reach production. For example, if you had a typo in our code above, you’d get an error like Property 'pricePerSkeen' does not exist on type 'Yarn'. That’s way better than finding out your order tool is sending the wrong price to our store when someone orders a skein of 2/60NM 100% Merino Wool Yarn.

Another cool feature with Yarn Berry: zero-installs. If you work in a team, you can commit the .yarn folder and the yarn.lock file to your repo, and other team members just run yarn install—they don’t have to download any dependencies, because Yarn keeps a cache on their machine that matches exactly. No more rm -rf node_modules && npm install waiting around for 5 minutes. At our yarn supply company, we have a team of 6 devs, and this feature has cut down on onboarding time for new hires by like 70%. They clone the repo, run yarn install, and they’re ready to go in 30 seconds, not 10 minutes.

Now, let’s cover a more advanced tip: using Yarn Workspaces with TypeScript if you have a monorepo. If your company has multiple projects—like a storefront, an inventory tool, and a customer portal—Yarn Workspaces let you manage all dependencies in one root repo. For example, you could have a packages folder with yarn-typescript-common (shared types for all your yarn products), storefront (the site that sells our Ugly Christmas sweaters for men and women made with our yarn), and inventory (the tool we use to track stock). TypeScript works seamlessly with Yarn Workspaces, and you can share types between packages without duplicating code. We use this for all our projects now, and it’s saved us so much time—no more updating the product type in 5 different places when we add a new yarn like Cashmere Blend Yarn.

Wait, let’s address a common question: is Yarn Berry better than npm for TypeScript projects? For most use cases, yes. It’s faster, more secure (it uses checksum-based integrity checks, so you know you’re getting exactly the same code as everyone else), and has better dependency resolution. That said, if you’re only working on a tiny personal project, npm works fine, but for a business like ours that relies on consistent, reliable tools to sell quality yarn, Yarn Berry is non-negotiable. We tested both for our main store project a couple years ago, and Yarn Berry cut our dependency installation time from 2 minutes to 12 seconds—game changer when you’re deploying updates multiple times a day.

Now, let’s test for real that everything works. Make sure you’ve followed all the steps: initialized Yarn Berry, added TypeScript, tweaked tsconfig.json, wrote the index.ts file, added the scripts to package.json. Run yarn dev in your terminal, and you should see the list of our top yarn products: 2/60NM 100% Merino Wool Yarn, Tencel Blend Yarn, Cashmere Blend Yarn, all with their prices and stock status. No errors, no confusion. If you ever get stuck, check the Yarn Berry docs, but we’ve found that the setup is way more straightforward than people make it out to be.

A quick pro tip: if you’re using React or another frontend framework with TypeScript, the setup is almost identical. You just add the framework packages (like react and react-dom) with yarn add, make sure TypeScript has the right settings, and you’re good to go. We used this exact setup for our new product page, where we list each yarn with a link to its details, like our Camel Blend Yarn or the Ugly Christmas sweaters for men and women that feature our yarn.

At our yarn supply company, we know that our customers aren’t just buying yarn—they’re building things, whether it’s cozy sweaters, soft blankets, or custom crafts. And the tools we use to run our business should be just as reliable as the yarn we sell. That’s why we switched to Yarn Berry with TypeScript a few years back, and it’s made every part of our dev workflow easier. If you’re building a site to sell yarn, managing inventory, or just learning modern JavaScript/TypeScript, this combo will make your life way simpler.

If you’re a crafter, a small business owner, or a developer who works with yarn-related projects and wants to connect with our team to source high-quality yarn for your creations or tools, we’d love to chat. Our team is here to help with custom yarn orders, bulk pricing, and anything you need to bring your projects to life. Reach out to our sales team to start a conversation about your yarn needs.

References

1. Yarn Berry Official Documentation. (n.d.). Retrieved from https://yarnpkg.com/getting-started
2. TypeScript Official Handbook. (n.d.). Retrieved from https://www.typescriptlang.org/docs/handbook/intro.html
3. Yarn Workspaces Guide. (n.d.). Retrieved from https://yarnpkg.com/features/workspaces
4. TS-Node Documentation. (n.d.). Retrieved from https://typestrong.org/ts-node/docs/
5. @Yarnpkg SDK for VS Code. (n.d.). Retrieved from https://yarnpkg.com/advanced/editor-sdks