turborepo VS tsup

GitHub: vercel/turborepo

When you setup a monorepo using turbo, the basic template gives you 3 packages by default. This can be found in turborepo/examples/basic.

Next, let’s create monorepo with Turborepo.

> Look at the dependency tree for a next

Looks ok to me: https://npmgraph.js.org/?q=next

Ironically, most of the dependencies are actually Rust crates used by swc and turbopack [1]. Try running cargo tree on either of those crates, it's enlightening to say the least. And of course, Node has a built in file watcher, and even the most popular third party package for file watching (Chokidar) has a single dependency [3].

[1] https://github.com/vercel/turborepo/blob/main/Cargo.toml

[2] https://github.com/swc-project/swc/blob/main/Cargo.toml

[3] https://npmgraph.js.org/?q=chokidar

Turborepo: Smart build system for JavaScript/TypeScript monorepos

We’ve only scratched the surface of what we can do with Turborepo. You can find more examples in the Turborepo examples directory on GitHub. Skill Recordings on GitHub is also another great resource that has been around since Turborepo was first released.

git clone https://github.com/vercel/turborepo.git

I use https://turborepo.org/ to facilitate my monorepo. Essentially it's a way of structuring your configs, UI; apps etc and you consume each like an internal package. I find benefits for this as the kinds of sites I make will generally have an internal app, an admin panel and a marketing site. I can write UI, config etc in one place and consume them over the three projects to keep everything consistent.

The latest addition to the Composer Suite monorepo, Turborepo optimizes monorepo workflows by caching build artifacts. This may sound a little abstract and boring, but what this actually means is that when you build something within your monorepo, Turborepo will make sure only the things that it depends on are rebuilt; everything else will be retrieved from a cache that either lives on your local computer, or a remote cache server. Adding Turborepo to the Composer Suite monorepo pretty much halved CI build times, but it was also a way to teach Vercel, which I use for hosting the various example apps in the repo, to only actually deploy the ones that have changed since their last deployment. And that's really cool!

By the way, this is the first time I’ve published one of my own packages on npm. It was a great experience to learn how to publish on npm and discover the convenience of tools like tsup.

The Icons and Fonts modules add depth to the visual language. Icons are managed through an efficient process that generates components from SVG files using SVGR and tsup. This ensures that icons are consistent and can be flexibly integrated across the system.

1. tsup docs: https://tsup.egoist.dev/ 2. npm: https://www.npmjs.com/package/tsup 3. tsup usage in shadcn-ui/ui: https://github.com/shadcn-ui/ui/blob/main/packages/cli/package.json#L33 4. My open source CLI related project: https://github.com/Ramu-Narasinga/TThroo/blob/main/packages/cli/package.json#L35

All the compilation of new features into old ones is done internally by @swc/core, which is a very fast compiler. Luckily its all built-in into tsup, which is the build tool I use for every single package I publish and cannot recommend it enough.

Now, we can run all this server reaching the port 4000. If you want to test, build it with tsup or any other way that you want, like ts-node.

If you're building hooks, providers & components you can go with only React + TypeScript, and use something ESBuild or tsup to build it.

I am using `tsup` to transpile my application - https://github.com/egoist/tsup

I spent way to much time over the last couple days trying to line up vite/rollup to bundle my component library with types, type maps and the correct formats. Until I ran across this blog post which introduced me to https://github.com/egoist/tsup and it all just worked in a single readable command. I figured I'd share with you beautiful people so you could get your code bundled faster and carry on with the fun part of programming.