ncc VS esbuild

You could use ncc to compile a binary:

https://github.com/vercel/ncc

This appears to be caused by lazy loading of image layer data, particularly during container initialization, and latency introduced by the read operations. In general, you want to access as few files and as little data as possible during the initialization of your functions. For example, we've seen improvement when using ncc to bundle Node.js applications.

What we do however, is bundle all these dependencies, and our own code into a single JS file using the nifty ncc tool (thanks Vercel!)

Vercel's ncc compiler

The most unclear and confusing part is packing the code using ncc. The necessity of this step is caused by GitHub’s approach to running your Action.

This may be slightly tangential but I recently discovered ncc[1] from vercel which can take a single node project and compile it and all dependencies to a single file.

As an added benefit it also collapses all contained dependencies license files into a single licenses.txt file too!

- [1] https://github.com/vercel/ncc

The current process of building a package locally is by running through a gulp task, using ttypescript to compile the TS and @vercel/ncc to build the binary:

- "introduce bugs": I dont' think so, my product is running like this, bundling every commit but I didn't see any problem. For bigger app: vercel using this way to delivery they's serverless application with https://github.com/vercel/ncc.

Here is link number 1 - Previous text "ncc"

The other option I want to highlight is packaging the project using something like Webpack or esbuild. JS Bundlers transpile all of your separate files and classes (along with all node_modules) into one single file, a practice originally developed to reduce package size for frontend applications. This helps improve the cold start time in Lambda, as unimported files can be pruned and the entire handler becomes one file.

I wonder how this compares (performance and feature-wise) to esbuild (https://github.com/evanw/esbuild), which is also a bundler written in a compiled language (Go)? esbuild claims to be 10-100x faster than JS-based builders, while Rspack doesn't provide any concrete numbers (at least I didn't find any)...

It uses esbuild so you can write the latest JavaScript syntax while supporting older browsers,

The javascript bundler esbuild is written in Go and is extremely fast for that reason. The author originally tried both Rust and Go and ended up using Go. There is a discussion of why he chose Go here: https://news.ycombinator.com/item?id=22336284

Now that we have our production-ready app, let’s examine how Nx handles the build process using [esbuild](https://esbuild.github.io/).

// config/esbuild.mjs import path from 'path' import esbuild from 'esbuild' import rails from 'esbuild-rails' import babel from 'esbuild-plugin-babel' esbuild .build({ bundle: true, // Path to application.js folder absWorkingDir: path.join(process.cwd(), 'app/javascript'), // Application.js file, used by Rails to bundle all JS Rails code entryPoints: ['application.js'], // Destination of JS bundle, points to the Rails JS Asset folder outdir: path.join(process.cwd(), 'app/assets/builds'), // Enables watch option. Will regenerate JS bundle if files are changed watch: process.argv.includes('--watch'), // Split option is disabled, only needed when using multiple input files // More information: https://esbuild.github.io/api/#splitting (change it if using multiple inputs) splitting: false, chunkNames: 'chunks/[name]-[hash]', // Remove unused JS methods treeShaking: true, // Adds mapping information so web browser console can map bundle errors to the corresponding // code line and column in the real code // More information: https://esbuild.github.io/api/#sourcemap sourcemap: process.argv.includes('--development'), // Compresses bundle // More information: https://esbuild.github.io/api/#minify minify: process.argv.includes('--production'), // Removes all console lines from bundle // More information: https://esbuild.github.io/api/#drop drop: process.argv.includes('--production') ? ['console'] : [], // Build command log output: https://esbuild.github.io/api/#log-level logLevel: 'info', // Set of ESLint plugins plugins: [ // Plugin to easily import Rails JS files, such as Stimulus controllers and channels // https://github.com/excid3/esbuild-rails rails(), // Configures bundle with Babel. Babel configuration defined in babel.config.js // Babel translates JS code to make it compatible with older JS versions. // https://github.com/nativew/esbuild-plugin-babel babel() ] }) .catch(() => process.exit(1))

You can also roll-up your JS files using a bundler. I use esbuild, and a plugin called glslify so I can include .glsl files, to integrate ThreeJS into my Twine projects.

esbuild.

You should know that CRA is using webpack and babeljs for bundling and compiling the js, jsx to es5( based on your configs), and these two are pretty damn slow! you can change babel with esbuild which you can read here and also there are other articles out there... this will make a hige speedup for you because you are replacing those two which is written by javascript with esbuild which is written by golang that is pretty (fast](https://esbuild.github.io/), actually vite is using esbuild behind the scene and that is why its is super fast!