Visulima Packem

A fast and modern bundler for Node.js and TypeScript.
Supports multiple runtimes, shared modules, server components, dynamic import, wasm, css, and more.
Built on top of Rollup, combined with your preferred transformer like esbuild, swc, OXC, or sucrase.

Overview

Visulima Packem is built on top of Rollup, combined with your preferred transformer like esbuild, swc, OXC, or sucrase. It enables you to generate multiple bundles (CommonJS or ESModule) simultaneously while adhering to Node.js’ native file type support.

It uses the exports configuration in package.json and recognizes entry file conventions to match your exports and build them into bundles.

Features

• ✅ package.json#exports, package.json#main, package.json#module to define entry-points
• ✅ package.json#bin to define executables
• ✅ package.json#types to define types
• ✅ Generates package.json#typeVersions to support node 10
• ✅ Dependency externalization
• ✅ Minification
• ✅ TypeScript support + .d.ts bundling
• ✅ Watch mode
• ✅ CLI outputs (auto hashbang insertion)
• ✅ Validator
  • Validates package.json and checks if all fields that are needed to publish your package are configured correctly
  • Bundle size validation
• ✅ Supports multiple runtimes (default, react-server, edge-light, browser and node)
• ✅ Supports react server and client components
• ✅ Supports shared modules
• ✅ Supports dynamic import
• ✅ Supports tsconfig.json paths and package.json imports resolution
• ✅ ESM ⇄ CJS interoperability
• ✅ Supports isolated declaration types (experimental) (Typescript version 5.5 or higher)
• ✅ Supports wasm WebAssembly modules
• ✅ Supports css, sass, less, stylus and Up-to-date CSS Modules (experimental)
• ✅ TypeDoc documentation generation

And more...

Install

1npm install --save-dev @visulima/packem

1yarn add -D @visulima/packem

1pnpm add -D @visulima/packem

Prepare your project

You need to prepare your project to be able to bundle it with packem.

You can check out the following cases to configure your package.json.

1{
2    "files": ["dist"],
3    "exports": {
4        "import": "./dist/index.mjs",
5        "require": "./dist/index.cjs"
6    },
7    "scripts": {
8        "build": "packem build"
9    }
10}

1{
2    "files": ["dist"],
3    "exports": {
4        "import": {
5            "types": "./dist/index.d.mts",
6            "default": "./dist/index.mjs"
7        },
8        "require": {
9            "types": "./dist/index.d.cts",
10            "default": "./dist/index.cjs"
11        }
12    },
13    "scripts": {
14        "build": "packem build"
15    }
16}

1{
2    "files": ["dist"],
3    "main": "./dist/index.cjs",
4    "module": "./dist/index.mjs",
5    "types": "./dist/index.d.ts",
6    "exports": {
7        "import": {
8            "types": "./dist/index.d.mts",
9            "default": "./dist/index.mjs"
10        },
11        "require": {
12            "types": "./dist/index.d.cts",
13            "default": "./dist/index.cjs"
14        }
15    },
16    "scripts": {
17        "build": "packem build"
18    }
19}

1export default defineConfig({
2    // ...
3    rollup: {
4        // ...
5        node10Compatibility: {
6            typeScriptVersion: ">=5.0", // Chose the version of TypeScript you want to support
7            writeToPackageJson: true,
8        },
9        // ...
10    },
11    transformer,
12});

Links:

• https://github.com/frehner/modern-guide-to-packaging-js-library#set-the-main-field

Usage

Initialize the packem configuration

Initialize packem in your project, this will create a packem.config.ts or packem.config.js file in the root of your project.

1packem init [options]

This command will ask you some questions about your project and create the configuration file.

Bundle files

Run the following command to bundle your files:

1packem build [options]

Then files in src folders will be treated as entry files and match the export names in package.json.

[!NOTE] The src folder can be configured in the packem configuration file.

For example: src/index.ts will match the exports name "." or the only main export.

Now just run npm run build or pnpm build / yarn build if you're using these package managers, packem will find the entry files and build them. The output format will be based on the exports condition and also the file extension. Given an example:

• It's CommonJS for require and ESM for import based on the exports condition.
• It's CommonJS for .cjs and ESM for .mjs based on the extension regardless the exports condition. Then for export condition like "node" you could choose the format with your extension.

[!NOTE] All the dependencies and peerDependencies will be marked as external automatically and not included in the bundle. If you want to include them in the bundle, you can use the --no-external option.

This will write the files into the ./dist folder.

[!NOTE] The dist folder can be configured in the packem configuration file.

Multiple Runtime

For exports condition like react-native, react-server and edge-light as they're special platforms, they could have different exports or different code conditions. In this case packem provides an override input source file convention if you want to build them as different code bundle.

For instance:

1{
2    "exports": {
3        "react-server": "./dist/react-server.mjs",
4        "edge-light": "./dist/edge-light.mjs",
5        "import": "./dist/index.mjs"
6    }
7}

[!NOTE] The edge-light export contains a process.env.EdgeRuntime variable true, for all other runtimes false is returned.

production and development exports condition

If you need to separate the production and development exports condition, packem provides process.env.NODE_ENV injected by default if present that you don't need to manually inject yourself.

• When the production exports condition is defined and the file ends with *.production.* in the package.json, the bundle will be minified.
• When the development exports condition is defined and the file ends with *.development.* in the package.json, the bundle will not be minified.

1{
2    "exports": {
3        "development": "./dist/index.development.mjs",
4        "production": "./dist/index.production.mjs"
5    }
6}

Executables

To build executable files with the bin field in package.json. The source file matching will be same as the entry files convention.

[!NOTE] > packem automatically preserves and prepends the shebang to the executable file, and fix correct permissions for the executable file.

For example:

1|- src/
2  |- bin/
3    |- index.ts

This will match the bin field in package.json as:

1{
2    "bin": "./dist/bin/index.cjs"
3}

or .mjs if the type field is module in package.json.

1{
2    "type": "module",
3    "bin": "./dist/bin/index.mjs"
4}

For multiple executable files, you can create multiple files.

1|- src/
2  |- bin/
3    |- foo.ts
4    |- bar.ts

This will match the bin field in package.json as:

1{
2    "bin": {
3        "foo": "./dist/bin/foo.cjs",
4        "bar": "./dist/bin/bar.cjs"
5    }
6}

Server Components

packem supports to build server components and server actions with library directives like "use client" or "use server". It will generate the corresponding chunks for client and server that scope the client and server boundaries properly. Then when the library is integrated to an app such as Next.js, app bundler can transform the client components and server actions correctly and maximum the benefits.

If you're using "use client" or "use server" in entry file, then it will be preserved on top and the dist file of that entry will become a client component. If you're using "use client" or "use server" in a file that used as a dependency for an entry, then that file containing directives be split into a separate chunk and hoist the directives to the top of the chunk.

Shared Modules (Experimental)

There are always cases that you need to share code among bundles, but they don't have to be a separate entry or exports. You want to have them bundled into a shared chunk and then use them in different bundles. You can use shared module convention [name].[layer]-runtime.[ext] to create shared modules bundles.

1// src/util.shared-runtime.js
2export function sharedUtil() {
3    /* ... */
4}

1// src/index.js
2import { sharedUtil } from "./util.shared-runtime";

1// src/lite.js
2import { sharedUtil } from "./util.shared-runtime";

With multiple runtime bundles, such as having default and react-server together. They could have the modules that need to be shared and kept as only one instance among different runtime bundles. You can use the shared module convention to create shared modules bundles for different runtime bundles.

1"use client";
2// src/app-context.shared-runtime.js
3export const AppContext = React.createContext(null);

1// src/index.js
2import { AppContext } from "./app-context.shared-runtime";

1// src/index.react-server.js
2import { AppContext } from "./app-context.shared-runtime";

Text or Data Files

packem supports importing of file as string content, you can name the extension as .txt or .data, and it will be bundled as string content.

1// src/index.js
2import { text } from "./text.txt";
3
4console.log(text); // "Hello World"

Visualize Bundle Makeup

Use the --visualize flag to generate a packem-bundle-analyze.html file at build time, showing the makeup of your bundle.

Building Module Workers (Experimental) (WIP)

packem supports building module workers with the --workers flag, which are a special type of bundle that can be used to run code in a web worker.

1worker = new Worker(new URL("./worker.js", import.meta.url), { type: "module" });
2// or simply:
3worker = new Worker("./worker.js", { type: "module" });

Plugins

A plugin can additionally specify an enforce property (similar to webpack loaders) to adjust its application order. The value of enforce can be either "pre" or "post". The value of type can be either "build" or "dts", where "build" is the default value.

If dts is specified, the plugin will only run when declaration files are generated.

The resolved plugins will be in the following order:

• Alias
• User plugins with enforce: 'pre'
• Rollup core plugins
• User plugins without enforce value
• Rollup build plugins
• User plugins with enforce: 'post'
• Rollup post build plugins (minify, manifest, copy, reporting)

1import { defineConfig } from "@visulima/packem/config";
2import { optimizeLodashImports } from "@optimize-lodash/rollup-plugin";
3
4export default defineConfig({
5    // ...
6    plugins: [
7        {
8            enforce: "pre",
9            plugin: optimizeLodashImports(),
10            // type: "build" -> default value
11        },
12    ],
13    // ...
14});

Aliases

Aliases are automatically inferred from paths in your tsconfig.json file, and can also be configured in the import map defined in package.json#imports.

For native Node.js import mapping, all entries must be prefixed with # to indicate an internal subpath import. Packem takes advantage of this behavior to define entries that are not prefixed with # as an alias.

Native Node.js import mapping supports conditional imports (eg. resolving different paths for Node.js and browser), but packem does not.

⚠️ Aliases are not supported in type declaration generation. If you need type support, do not use aliases.

1{
2    // ...
3
4    imports: {
5        // Mapping '~utils' to './src/utils.js'
6        "~utils": "./src/utils.js",
7
8        // Native Node.js import mapping (can't reference ./src)
9        "#internal-package": "./vendors/package/index.js",
10    },
11}

ESM ⇄ CJS interoperability

Node.js ESM offers interoperability with CommonJS via static analysis. However, not all bundlers compile ESM to CJS syntax in a way that is statically analyzable.

Because packem uses Rollup, it's able to produce CJS modules that are minimal and interoperable with Node.js ESM.

This means you can technically output in CommonJS to get ESM and CommonJS support.

require() in ESM

Sometimes it's useful to use require() or require.resolve() in ESM. ESM code that uses require() can be seamlessly compiled to CommonJS, but when compiling to ESM, Node.js will error because require doesn't exist in the module scope.

When compiling to ESM, packem detects require() usages and shims it with createRequire(import.meta.url).

Not only does packem shim ESM ⇄ CJS, but fixes the export and export types for default exports in your commonjs files.

To enable both features you need to add cjsInterop: true to your packem config.

1export default defineConfig({
2    cjsInterop: true,
3    // ...
4});

Environment variables

Pass in compile-time environment variables with the --env flag.

This will replace all instances of process.env.NODE_ENV with 'production' and remove unused code:

1packem build --env.NODE_ENV=production

Validators

Package.json Validation

Packem validates your package.json file and checks if all fields are configured correctly, that are needed to publish your package.

[!NOTE] To have a full validation checkup, visit publint and are the types wrong.

Bundle Size Validation

Packem validates the bundle size and checks if the bundle size is within the limit you set in the configuration file.

1import { defineConfig } from "@visulima/packem/config";
2
3export default defineConfig({
4    // ...
5    validator: {
6        bundleSize: {
7            limit: 1024 * 1024, // 1MB
8            // or / and limits per file
9            limits: {
10                "index.cjs": 1024 * 1024, // 1MB
11                "test.mjs": "1MB",
12                // Glob pattern
13                "**/*.mjs": "1MB",
14            },
15        },
16    },
17    // ...
18});

Experimental Features

OXC Resolver

packem supports the oxc-resolver resolver to resolve modules in your project.

To use the oxc resolver, you need to enable it in the packem configuration file.

1import { defineConfig } from "@visulima/packem/config";
2
3export default defineConfig({
4    // ...
5    experimental: {
6        oxcResolve: true,
7    },
8    // ...
9});

TypeDoc

Installation

To generate api documentation for your project, you need to install typedoc to your project.

1npm exec packem add typedoc

1yarn exec packem add typedoc

1pnpm exec packem add typedoc

To generate documentation for your project, you can use the --typedoc flag.

1packem build --typedoc

This will generate a api-docs folder in the root of your project.

Different formats

You can specify the output format inside the packem.config.js file.

1export default defineConfig({
2    // ...
3    typedoc: {
4        format: "inline",
5        readmePath: "./README.md",
6    },
7    // ...
8});

Isolated declaration types (in TypeScript 5.5)

Generating .d.ts files with the default rollup-plugin-dts is slow because the TypeScript compiler must perform costly type inference, but these files streamline type checking by removing unnecessary details, and while shipping raw TypeScript files could simplify workflows, it is impractical due to ecosystem assumptions and performance trade-offs, which isolated declarations aim to address.

You need to choose of the supported transformer to use isolated declaration types.

• oxc
• @swc/core
• typescript

Default is typescript.

1import { defineConfig } from "@visulima/packem/config";
2import transformer from "@visulima/packem/transformer/esbuild";
3import isolatedDeclarationTransformer from "@visulima/packem/dts/isolated/transformer/typescript";
4
5// eslint-disable-next-line import/no-unused-modules
6export default defineConfig({
7    transformer,
8    isolatedDeclarationTransformer,
9});

Css and Css Modules

packem supports:

• PostCSS
• Sass
• Less
• Stylus
• Up-to-date CSS Modules implementation
• URL resolving/rewriting with asset handling
• Ability to use @import statements inside regular CSS
• Built-in assets handler
• Ability to emit pure CSS for other plugins
• Complete code splitting support, with respect for multiple entries, preserveModules and manualChunks
• Multiple instances support, with check for already processed files
• Proper sourcemaps, with included sources content by default
• Respects assetFileNames for CSS file names
• Respects sourcemaps from loaded files
• Support for implementation forcing for Sass
• Support for partials and ~ in Less import statements

PostCSS

PostCSS is a tool for transforming styles with JS plugins. These plugins can lint your CSS, add support for variables and mixins, transpile future CSS syntax, inline images, and more.

Install all the necessary dependencies:

1npm install --save-dev postcss postcss-load-config postcss-modules postcss-modules-extract-imports postcss-modules-local-by-default postcss-modules-scope postcss-modules-values postcss-value-parser icss-utils

1yarn add -D postcss postcss-load-config postcss-modules postcss-modules-extract-imports postcss-modules-local-by-default postcss-modules-scope postcss-modules-values postcss-value-parser icss-utils

1pnpm add -D postcss postcss-load-config postcss-modules postcss-modules-extract-imports postcss-modules-local-by-default postcss-modules-scope postcss-modules-values postcss-value-parser icss-utils

Add the loader to your packem.config.ts:

1import { defineConfig } from "@visulima/packem/config";
2import transformer from "@visulima/packem/transformer/esbuild";
3import postcssLoader from "@visulima/packem/css/loader/postcss";
4import sourceMapLoader from "@visulima/packem/css/loader/sourcemap";
5
6export default defineConfig({
7    transformer,
8    rollup: {
9        css: {
10            loaders: [postcssLoader, sourceMapLoader],
11        },
12    },
13});

Sass

To use Sass, you need to install the sass package:

1npm install --save-dev sass-embedded // recommended
2// or
3npm install --save-dev sass
4// or
5npm install --save-dev node-sass

1yarn add -D sass-embedded // recommended
2// or
3yarn add -D sass
4// or
5yarn add -D node-sass

1pnpm add -D sass-embedded // recommended
2// or
3pnpm add -D sass
4// or
5pnpm add -D node-sass

Add the loader to your packem.config.ts:

1import { defineConfig } from "@visulima/packem/config";
2import transformer from "@visulima/packem/transformer/esbuild";
3import postcssLoader from "@visulima/packem/css/loader/postcss";
4import sassLoader from "@visulima/packem/css/loader/sass";
5import sourceMapLoader from "@visulima/packem/css/loader/sourcemap";
6
7export default defineConfig({
8    transformer,
9    rollup: {
10        css: {
11            loaders: [postcssLoader, sassLoader, sourceMapLoader],
12        },
13    },
14});

Less

To use Less, you need to install the less package:

1npm install --save-dev less

1yarn add -D less

1pnpm add -D less

Add the loader to your packem.config.ts:

1import { defineConfig } from "@visulima/packem/config";
2import transformer from "@visulima/packem/transformer/esbuild";
3import postcssLoader from "@visulima/packem/css/loader/postcss";
4import lessLoader from "@visulima/packem/css/loader/less";
5import sourceMapLoader from "@visulima/packem/css/loader/sourcemap";
6
7export default defineConfig({
8    transformer,
9    rollup: {
10        css: {
11            loaders: [postcssLoader, lessLoader, sourceMapLoader],
12        },
13    },
14});

Stylus

To use Stylus, you need to install the stylus package:

1npm install --save-dev stylus

1yarn add -D stylus

1pnpm add -D stylus

Add the loader to your packem.config.ts:

1import { defineConfig } from "@visulima/packem/config";
2import transformer from "@visulima/packem/transformer/esbuild";
3import postcssLoader from "@visulima/packem/css/loader/postcss";
4import stylusLoader from "@visulima/packem/css/loader/stylus";
5import sourceMapLoader from "@visulima/packem/css/loader/sourcemap";
6
7export default defineConfig({
8    transformer,
9    rollup: {
10        css: {
11            loaders: [postcssLoader, stylusLoader, sourceMapLoader],
12        },
13    },
14});

After that you can import CSS/Sass/Less/Stylus files in your code:

1import "./styles.css";

Default mode is inject, which means CSS is embedded inside JS and injected into <head> at runtime, with ability to pass options to CSS injector or even pass your own injector.

CSS is available as default export in inject and extract modes, but if CSS Modules are enabled you need to use named css export.

1// Injects CSS, also available as `style` in this example
2import style from "./style.css";
3// Using named export of CSS string
4import { css } from "./style.css";

In emit mode none of the exports are available as CSS is purely processed and passed along the build pipeline, which is useful if you want to preprocess CSS before using it with CSS consuming plugins, e.g. rollup-plugin-lit-css.

PostCSS configuration files will be found and loaded automatically, but this behavior is configurable using config option.

Importing a file

CSS/Stylus

1/* Import from `node_modules` */
2@import "bulma/css/bulma";
3/* Local import */
4@import "./custom";
5/* ...or (if no package named `custom` in `node_modules`) */
6@import "custom";

Sass/Less

You can prepend the path with ~ to resolve in node_modules:

1// Import from `node_modules`
2@import "~bulma/css/bulma";
3// Local import
4@import "./custom";
5// ...or
6@import "custom";

Also note that partials are considered first, e.g.

1@import "custom";

Will look for _custom first (with the appropriate extension(s)), and then for custom if _custom doesn't exist.

CSS Injection

1styles({
2    mode: "inject", // Unnecessary, set by default
3    // ...or with custom options for injector
4    mode: ["inject", { container: "body", singleTag: true, prepend: true, attributes: { id: "global" } }],
5    // ...or with custom injector
6    mode: ["inject", (varname, id) => `console.log(${varname},${JSON.stringify(id)})`],
7});

CSS Extraction

1styles({
2    mode: "extract",
3    // ... or with relative to output dir/output file's basedir (but not outside of it)
4    mode: ["extract", "awesome-bundle.css"],
5});

Metafile

Passing --metafile flag to tell packem to produce some metadata about the build in JSON format. You can feed the output file to analysis tools like bundle buddy to visualize the modules in your bundle and how much space each one takes up.

The file outputs as metafile-{bundleName}-{format}.json, e.g. packem will generate metafile-test-cjs.json and metafile-test-es.json.

onSuccess

You can specify command to be executed after a successful build, specially useful for Watch mode

1packem build --watch --onSuccess "node dist/index.js"

onSuccess can also be a function that returns Promise. For this to work, you need to use packem.config.ts instead of the cli flag:

1import { defineConfig } from "@visulima/packem/config";
2
3export default defineConfig({
4    // ...
5    async onSuccess() {
6        // Start some long running task
7        // Like a server
8    },
9});

You can return a cleanup function in onSuccess:

1import { defineConfig } from "@visulima/packem/config";
2
3export default defineConfig({
4    // ...
5    onSuccess() {
6        const server = http.createServer((req, res) => {
7            res.end("Hello World!");
8        });
9        server.listen(3000);
10        return () => {
11            server.close();
12        };
13    },
14});

Configuration

packem.config.js

The packem configuration file is a JavaScript file that exports an object with the following properties:

transformer

You choose which one of the three supported transformer to use.

• esbuild
• @swc/core
• sucrase
• OXC

File types

Packem exports a files.d.ts file that contains all supported the types.

To shim the types, you can use the following:

1/// <reference types="@visulima/packem/files" />

Alternatively, you can add @visulima/packem/files to compilerOptions.types inside tsconfig.json:

1{
2    "compilerOptions": {
3        "types": ["@visulima/packem/files"]
4    }
5}

This will provide the following type shims:

• Asset imports (e.g importing an .svg, .module.css file)

Tip:

To override the default typing, add a type definition file that contains your typings. Then, add the type reference before @visulima/packem/files.

packem-env-override.d.ts (the file that contains your typings):

1declare module '*.svg' {
2 const content: React.FC<React.SVGProps<SVGElement>>
3 export default content
4}

The file containing the reference to @visulima/packem/files:

1/// <reference types="./packem-env-override.d.ts" />
2/// <reference types="@visulima/packem/files" />

Related

• bunchee - Zero config bundler for ECMAScript and TypeScript packages
• unbuild - 📦 An unified javascript build system
• pkgroll - 📦 Zero-config package bundler for Node.js + TypeScript
• siroc - Zero-config build tooling for Node
• tsup - The simplest and fastest way to bundle your TypeScript libraries
• microbundle - Zero-configuration bundler for tiny JS libs, powered by Rollup.

Supported Node.js Versions

Libraries in this ecosystem make the best effort to track Node.js’ release schedule. Here’s a post on why we think this is important.

Contributing

If you would like to help take a look at the list of issues and check our Contributing guild.

Note: please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.

Credits

• Daniel Bannert
• All Contributors

License

The visulima pack is open-sourced software licensed under the MIT