pkg VS webpack

You don't even need that: https://github.com/vercel/pkg.

I think there are equivalents in the Python ecosystem.

Another exciting feature is the ability to build a single-executable Node.js binary. Before Node.js v18, the only way to build a Node.js binary was to use a third-party package, like pkg.

As a comparison I am using https://github.com/vercel/pkg to package my Node.js app into an exe file. Vercel-pkg allows me to build different images for different platforms like Windows, Linux, Mac. It would be nice if it could produce a single .exe that worked on all platforms. But I guess such an exe would have to be bigger. It is not too cumbersome to produce one exe per platform that my users need.

To run NodeJS as a sidecar we need to pack it into binary. Taurine is bundling your server code and preparing it for packing into a single binary. Using Vercel’s pkg CLI tool we can compile it into a single executable binary. That binary is running with the Tauri application.

What if you packaged the whole thing into one executable using pkg?

In addition to the other responses, there are node packages like pkg and nexe that you can use to package the node executable and your code into a single executable.

Not really, at last check it just bundles the entire .Net runtime with the compiled image. It's basically the equivalent of https://github.com/vercel/pkg or similar tools.

You can even pack your terminal application in a single binary that does not require separate NodeJS installed via pkg.

if you want to learn more about webpack just go to this website https://webpack.js.org/ explore it and see more settings in webpack.

I'm not gonna lie, I didn't read all that, but the node example alone proves you either didn't read the guy you replied to or haven't been coding long enough to grok the problem.

What if you want to start a new project using the latest postgres version because postgres has a new feature that will be handy, but you already maintain another project that uses a postgres feature or relies on behaviour that was removed/changed in the latest version? You're going to set up a whole new VM on the internet to be a staging environment and instead of setting up a testing and deployment pipeline you're going to just FTP / remote-ssh into it and change live code?

you define an apps entire chain of dependencies in a compose file / set of kube manifests / terraform config for ecs. Then in the container definition itself you lock down things like C library and distro versions: maybe you use specially patched imagemagick on one project or a pdf generator on another, and fontconfig defaults were updated and it changed how aliasing works between distro releases and now your fonts are all fugly in generated exports...

nevermind this, check out this thread to destroy your illusion that simply having node installed locally will make your next project super future proof https://github.com/webpack/webpack/issues/14532

if you respond please do not open with "yeah but rust", I can still compile Fortran code too

With tools like webpack (used by create-react-app under the hood), your entire application needs to be bundled in a single file before it can be served to the browser. Vite, on the other hand, takes advantage of native ES modules in the browser to make bundling more efficient with Rollup, serving parts of the source code as needed.

If I choose React as a used framework, Ionic’s boilerplate is based on Create React App. Because of it I want a tool which edits Webpack’s configuration without ejecting CRA’s configuration.

Webpack webpack.js.org

Module Federation is a technology provided by webpack that enables modules to be federated across different origins at runtime. This means that Webpack will simply ignore these modules at build time, expecting them to be available to be fetched across the network at runtime.

Webpack: 4.46.0

Packaging - turning all your code, CSS, assets, etc. into the files you'll actually stick on your host server. e.g. webpack, maybe esbuild, etc..

One of our internal tools at RedBit uses yaml to provide structured data. We chose yaml because it's more human-friendly than json, and the data in question is created and modified by humans during development. Applications need to consume the data as JavaScript objects, so we need to convert it from yaml to json. We could do the conversion at runtime but that would affect performance, possibly to the point of degrading the user experience. Instead, we chose to convert the data during the build process, which is controlled by webpack. This required a custom webpack loader. I won't describe the implementation of our internal tool in detail because it wouldn't be particularly helpful or relevant. Instead, I'll show you how to build a simple yaml loader that you can modify to suit your own needs.