prebundle 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Rspack Contrib
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,171 @@
+# dep-pre-bundler
+
+This package is used to prebundle 3rd party dependencies, based on [ncc](https://github.com/vercel/ncc) and `dts-packer`.
+
+## Motivation
+
+Prebundle is used to:
+
+- Reduce dependencies of core packages, install faster.
+- Improve stability by locking the sub-dependency version .
+- Fix peer dependency warning of some packages.
+
+## Command
+
+Run following command to prebundle all dependencies:
+
+```bash
+pnpm start
+```
+
+Run following command to prebundle single dependencies:
+
+```bash
+pnpm start <pkgName>
+
+# For example, prebundle commander
+pnpm start commander
+```
+
+## Add a new dependency
+
+1. Remove the dependency from the `dependencies` of original package.
+2. Add the dependency to the `devDependencies` of `@rsbuild/prebundle`. If this package has a `@types/package-name` package, it also needs to be added. It is recommended to lock the version of dependencies.
+3. Add the task config to `src/constant.ts`:
+
+```ts
+const TASKS: TaskConfig[] = [
+  {
+    packageDir: 'toolkit/utils',
+    packageName: '@rsbuild/utils',
+    dependencies: [
+      // Add the package name
+      'address',
+    ],
+  },
+];
+```
+
+4. Run `pnpm start`.
+5. Import from the compiled directory:
+
+```ts
+// Old
+import foo from 'foo';
+
+// New
+import foo from '../compiled/foo';
+```
+
+## Dependency Config
+
+Supported dependency config:
+
+### externals
+
+Externals to leave as requires of the build.
+
+```ts
+dependencies: [
+  {
+    name: 'foo',
+    externals: {
+      webpack: '../webpack',
+    },
+  },
+];
+```
+
+### minify
+
+Whether to minify the code, default `true`.
+
+```ts
+dependencies: [
+  {
+    name: 'foo',
+    minify: false,
+  },
+];
+```
+
+### packageJsonField
+
+Copy extra fields from original package.json to target package.json.
+
+```ts
+dependencies: [
+  {
+    name: 'foo',
+    packageJsonField: ['options'],
+  },
+];
+```
+
+Following fields will be copied by default:
+
+- `name`
+- `author`
+- `version`
+- `funding`
+- `license`
+- `types`
+- `typing`
+- `typings`
+
+### beforeBundle
+
+Callback before bundle.
+
+```ts
+dependencies: [
+  {
+    name: 'foo',
+    beforeBundle(task) {
+      console.log('do something');
+    },
+  },
+];
+```
+
+### emitFiles
+
+Emit extra entry files to map imports.
+
+```ts
+dependencies: [
+  {
+    name: 'foo',
+    emitFiles: [
+      {
+        path: 'foo.js',
+        content: `module.exports = require('./').foo;`,
+      },
+    ],
+  },
+];
+```
+
+### ignoreDts
+
+Ignore the original .d.ts declaration file, then generate a fake .d.ts file.
+
+This can be used to reduce file size for the packages that do not require type definitions, such as webpack plugin.
+
+```ts
+dependencies: [
+  {
+    name: 'foo',
+    ignoreDts: true,
+  },
+];
+```
+
+## Note
+
+We will not prebundle the following packages because their dependencies are complex or are depended by many community packages:
+
+- @babel/some-package
+- webpack
+- lodash
+- caniuse-lite

package/bin.js

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/constant.d.ts

@@ -0,0 +1,20 @@
+import type { TaskConfig } from './types';
+export declare const ROOT_DIR: string;
+export declare const PACKAGES_DIR: string;
+export declare const DIST_DIR = "compiled";
+export declare const DEFAULT_EXTERNALS: {
+    'caniuse-lite': string;
+    '/^caniuse-lite(/.*)/': string;
+    webpack: string;
+    '/^webpack(/.*)/': string;
+    lodash: string;
+    '/^lodash(/.*)/': string;
+    esbuild: string;
+    './package.json': string;
+    '../package.json': string;
+    '../../package.json': string;
+    postcss: string;
+    typescript: string;
+    '@babel/core': string;
+};
+export declare const TASKS: TaskConfig[];

package/dist/constant.js

@@ -0,0 +1,358 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TASKS = exports.DEFAULT_EXTERNALS = exports.DIST_DIR = exports.PACKAGES_DIR = exports.ROOT_DIR = void 0;
+const node_path_1 = __importStar(require("node:path"));
+const fs_extra_1 = __importStar(require("fs-extra"));
+const helper_1 = require("./helper");
+exports.ROOT_DIR = (0, node_path_1.join)(__dirname, '..', '..', '..');
+exports.PACKAGES_DIR = (0, node_path_1.join)(exports.ROOT_DIR, 'packages');
+exports.DIST_DIR = 'compiled';
+exports.DEFAULT_EXTERNALS = {
+    // External caniuse-lite data, so users can update it manually.
+    'caniuse-lite': 'caniuse-lite',
+    '/^caniuse-lite(/.*)/': 'caniuse-lite$1',
+    // External webpack, it's hard to bundle.
+    webpack: 'webpack',
+    '/^webpack(/.*)/': 'webpack$1',
+    // External lodash because lots of packages will depend on it.
+    lodash: 'lodash',
+    '/^lodash(/.*)/': 'lodash$1',
+    esbuild: 'esbuild',
+    // ncc bundled wrong package.json, using external to avoid this problem
+    './package.json': './package.json',
+    '../package.json': './package.json',
+    '../../package.json': './package.json',
+    postcss: 'postcss',
+    typescript: 'typescript',
+    '@babel/core': '@babel/core',
+};
+const writeEmptySchemaUtils = (task) => {
+    // The package size of `schema-utils` is large, and validate has a performance overhead of tens of ms.
+    // So we skip the validation and let TypeScript to ensure type safety.
+    const schemaUtilsPath = (0, node_path_1.join)(task.distPath, 'schema-utils.js');
+    fs_extra_1.default.outputFileSync(schemaUtilsPath, 'module.exports.validate = () => {};');
+};
+exports.TASKS = [
+    {
+        packageDir: 'core',
+        packageName: '@rsbuild/core',
+        dependencies: [
+            'open',
+            'commander',
+            'dotenv',
+            'dotenv-expand',
+            'ws',
+            'on-finished',
+            {
+                name: 'launch-editor-middleware',
+                ignoreDts: true,
+                externals: {
+                    picocolors: '@rsbuild/shared/picocolors',
+                },
+            },
+            {
+                name: 'sirv',
+                afterBundle(task) {
+                    (0, helper_1.replaceFileContent)((0, node_path_1.join)(task.distPath, 'sirv.d.ts'), (content) => `${content.replace("declare module 'sirv'", 'declare namespace sirv')}\nexport = sirv;`);
+                },
+            },
+            {
+                name: 'http-compression',
+                ignoreDts: true,
+            },
+            {
+                name: 'connect-history-api-fallback',
+                ignoreDts: true,
+            },
+        ],
+    },
+    {
+        packageDir: 'shared',
+        packageName: '@rsbuild/shared',
+        dependencies: [
+            'jiti',
+            'rslog',
+            'deepmerge',
+            'fs-extra',
+            'chokidar',
+            'webpack-merge',
+            'mime-types',
+            'connect',
+            'browserslist',
+            'gzip-size',
+            'json5',
+            {
+                name: 'webpack-chain',
+                externals: {
+                    deepmerge: '../deepmerge',
+                },
+            },
+            {
+                name: 'yaml',
+                ignoreDts: true,
+                afterBundle(task) {
+                    fs_extra_1.default.writeFileSync((0, node_path_1.join)(task.distPath, 'index.d.ts'), 'export declare function parse(src: string, options?: any): any;');
+                },
+            },
+            {
+                name: 'line-diff',
+                ignoreDts: true,
+            },
+            {
+                name: 'semver',
+                ignoreDts: true,
+            },
+            {
+                name: 'icss-utils',
+                ignoreDts: true,
+            },
+            {
+                name: 'postcss-value-parser',
+                ignoreDts: true,
+            },
+            {
+                name: 'postcss-modules-local-by-default',
+                ignoreDts: true,
+                externals: {
+                    'icss-utils': '../icss-utils',
+                    'postcss-value-parser': '../postcss-value-parser',
+                },
+            },
+            {
+                name: 'postcss-modules-extract-imports',
+                ignoreDts: true,
+            },
+            {
+                name: 'postcss-modules-scope',
+                ignoreDts: true,
+            },
+            {
+                name: 'postcss-modules-values',
+                ignoreDts: true,
+                externals: {
+                    'icss-utils': '../icss-utils',
+                },
+            },
+            {
+                name: 'sass-loader',
+                externals: {
+                    sass: '../sass',
+                },
+            },
+            {
+                name: 'sass',
+                externals: {
+                    chokidar: '../chokidar',
+                },
+                afterBundle(task) {
+                    (0, fs_extra_1.copySync)((0, node_path_1.join)(task.depPath, 'types'), (0, node_path_1.join)(task.distPath, 'types'));
+                },
+            },
+            {
+                name: 'style-loader',
+                ignoreDts: true,
+                afterBundle: (task) => {
+                    fs_extra_1.default.copySync((0, node_path_1.join)(task.depPath, 'dist/runtime'), (0, node_path_1.join)(task.distPath, 'runtime'));
+                },
+            },
+            {
+                name: 'less',
+                externals: {
+                    // needle is an optional dependency and no need to bundle it.
+                    needle: 'needle',
+                },
+                afterBundle(task) {
+                    (0, helper_1.replaceFileContent)((0, node_path_1.join)(task.distPath, 'index.d.ts'), (content) => content.replace(`declare module "less" {\n    export = less;\n}`, 'export = Less;'));
+                },
+            },
+            {
+                name: 'less-loader',
+                ignoreDts: true,
+                externals: {
+                    less: '../less',
+                },
+            },
+            {
+                name: 'css-loader',
+                ignoreDts: true,
+                externals: {
+                    semver: '../semver',
+                    'postcss-value-parser': '../postcss-value-parser',
+                    'postcss-modules-local-by-default': '../postcss-modules-local-by-default',
+                    'postcss-modules-extract-imports': '../postcss-modules-extract-imports',
+                    'postcss-modules-scope': '../postcss-modules-scope',
+                    'postcss-modules-values': '../postcss-modules-values',
+                    'icss-utils': '../icss-utils',
+                },
+            },
+            {
+                name: 'postcss-loader',
+                externals: {
+                    jiti: '../jiti',
+                    semver: '../semver',
+                },
+                ignoreDts: true,
+            },
+            {
+                name: 'postcss-load-config',
+                externals: {
+                    jiti: '../jiti',
+                    yaml: '../yaml',
+                },
+                ignoreDts: true,
+                // this is a trick to avoid ncc compiling the dynamic import syntax
+                // https://github.com/vercel/ncc/issues/935
+                beforeBundle(task) {
+                    (0, helper_1.replaceFileContent)((0, node_path_1.join)(task.depPath, 'src/req.js'), (content) => `${content.replace('await import', 'await __import')}`);
+                },
+                afterBundle(task) {
+                    (0, helper_1.replaceFileContent)((0, node_path_1.join)(task.distPath, 'index.js'), (content) => `${content.replace('await __import', 'await import')}`);
+                },
+            },
+            {
+                name: 'loader-utils2',
+                ignoreDts: true,
+                externals: {
+                    json5: '../json5',
+                },
+            },
+            {
+                name: 'picocolors',
+                beforeBundle({ depPath }) {
+                    const typesFile = node_path_1.default.join(depPath, 'types.ts');
+                    // Fix type bundle
+                    if (fs_extra_1.default.existsSync(typesFile)) {
+                        fs_extra_1.default.renameSync(typesFile, node_path_1.default.join(depPath, 'types.d.ts'));
+                    }
+                },
+            },
+            {
+                name: 'resolve-url-loader',
+                ignoreDts: true,
+                externals: {
+                    'loader-utils': '../loader-utils2',
+                },
+            },
+            {
+                name: 'webpack-dev-middleware',
+                externals: {
+                    'schema-utils': './schema-utils',
+                    'schema-utils/declarations/validate': 'schema-utils/declarations/validate',
+                    'mime-types': '../mime-types',
+                },
+                afterBundle: writeEmptySchemaUtils,
+            },
+            {
+                name: 'autoprefixer',
+                externals: {
+                    picocolors: '../picocolors',
+                    browserslist: '../browserslist',
+                    'postcss-value-parser': '../postcss-value-parser',
+                },
+            },
+            {
+                name: 'http-proxy-middleware',
+                externals: {
+                    // express is a peer dependency, no need to provide express type
+                    express: 'express',
+                },
+            },
+            {
+                // The webpack-bundle-analyzer version was locked to v4.9.0 to be compatible with Rspack
+                // If we need to upgrade the version, please check if the chunk detail can be displayed correctly
+                name: 'webpack-bundle-analyzer',
+                externals: {
+                    'gzip-size': '../gzip-size',
+                },
+            },
+        ],
+    },
+    {
+        packageDir: 'plugin-babel',
+        packageName: '@rsbuild/plugin-babel',
+        dependencies: [
+            {
+                name: 'babel-loader',
+                ignoreDts: true,
+                externals: {
+                    'schema-utils': './schema-utils',
+                },
+                afterBundle: writeEmptySchemaUtils,
+            },
+        ],
+    },
+    {
+        packageDir: 'plugin-svgr',
+        packageName: '@rsbuild/plugin-svgr',
+        dependencies: [
+            {
+                name: 'file-loader',
+                ignoreDts: true,
+                externals: {
+                    'schema-utils': './schema-utils',
+                    'loader-utils': '@rsbuild/shared/loader-utils2',
+                },
+                afterBundle: writeEmptySchemaUtils,
+            },
+            {
+                name: 'url-loader',
+                ignoreDts: true,
+                externals: {
+                    'schema-utils': './schema-utils',
+                    'loader-utils': '@rsbuild/shared/loader-utils2',
+                    'mime-types': '@rsbuild/shared/mime-types',
+                },
+                afterBundle(task) {
+                    writeEmptySchemaUtils(task);
+                    (0, helper_1.replaceFileContent)((0, node_path_1.join)(task.distPath, 'index.js'), (content) => {
+                        // use prebundle file-loader
+                        return content.replace('"file-loader"', 'require.resolve("../file-loader")');
+                    });
+                },
+            },
+        ],
+    },
+    {
+        packageDir: 'plugin-yaml',
+        packageName: '@rsbuild/plugin-yaml',
+        dependencies: [
+            {
+                name: 'yaml-loader',
+                ignoreDts: true,
+            },
+        ],
+    },
+    {
+        packageDir: 'plugin-rem',
+        packageName: '@rsbuild/plugin-rem',
+        dependencies: [
+            {
+                name: 'postcss-pxtorem',
+                ignoreDts: true,
+            },
+        ],
+    },
+];

package/dist/helper.d.ts

@@ -0,0 +1,5 @@
+import type { ParsedTask } from './types';
+export declare function findDepPath(name: string): string;
+export declare function parseTasks(): ParsedTask[];
+export declare function pick<T, U extends keyof T>(obj: T, keys: ReadonlyArray<U>): Pick<T, U>;
+export declare function replaceFileContent(filePath: string, replaceFn: (content: string) => string): void;

package/dist/helper.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceFileContent = exports.pick = exports.parseTasks = exports.findDepPath = void 0;
+const node_path_1 = require("node:path");
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const constant_1 = require("./constant");
+function findDepPath(name) {
+    let entry = (0, node_path_1.dirname)(require.resolve((0, node_path_1.join)(name)));
+    while (!(0, node_path_1.dirname)(entry).endsWith('node_modules')) {
+        entry = (0, node_path_1.dirname)(entry);
+    }
+    if (name.includes('/')) {
+        return (0, node_path_1.join)((0, node_path_1.dirname)(entry), name);
+    }
+    return entry;
+}
+exports.findDepPath = findDepPath;
+function parseTasks() {
+    const result = [];
+    for (const { packageName, packageDir, dependencies } of constant_1.TASKS) {
+        for (const dep of dependencies) {
+            const depName = typeof dep === 'string' ? dep : dep.name;
+            const importPath = (0, node_path_1.join)(packageName, constant_1.DIST_DIR, depName);
+            const packagePath = (0, node_path_1.join)(constant_1.PACKAGES_DIR, packageDir);
+            const distPath = (0, node_path_1.join)(packagePath, constant_1.DIST_DIR, depName);
+            const depPath = findDepPath(depName);
+            const depEntry = require.resolve(depName);
+            const info = {
+                depName,
+                depPath,
+                depEntry,
+                distPath,
+                importPath,
+                packageDir,
+                packagePath,
+                packageName,
+            };
+            if (typeof dep === 'string') {
+                result.push({
+                    minify: true,
+                    externals: {},
+                    emitFiles: [],
+                    packageJsonField: [],
+                    ...info,
+                });
+            }
+            else {
+                result.push({
+                    minify: dep.minify ?? true,
+                    ignoreDts: dep.ignoreDts,
+                    externals: dep.externals ?? {},
+                    emitFiles: dep.emitFiles ?? [],
+                    afterBundle: dep.afterBundle,
+                    beforeBundle: dep.beforeBundle,
+                    packageJsonField: dep.packageJsonField ?? [],
+                    ...info,
+                });
+            }
+        }
+    }
+    return result;
+}
+exports.parseTasks = parseTasks;
+function pick(obj, keys) {
+    return keys.reduce((ret, key) => {
+        if (obj[key] !== undefined) {
+            ret[key] = obj[key];
+        }
+        return ret;
+    }, {});
+}
+exports.pick = pick;
+function replaceFileContent(filePath, replaceFn) {
+    const content = fs_extra_1.default.readFileSync(filePath, 'utf-8');
+    const newContent = replaceFn(content);
+    if (newContent !== content) {
+        fs_extra_1.default.writeFileSync(filePath, newContent);
+    }
+}
+exports.replaceFileContent = replaceFileContent;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helper_1 = require("./helper");
+const prebundle_1 = require("./prebundle");
+async function run() {
+    const parsedTasks = (0, helper_1.parseTasks)();
+    for (const task of parsedTasks) {
+        await (0, prebundle_1.prebundle)(task);
+    }
+}
+run();

package/dist/prebundle.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedTask } from './types';
+export declare function prebundle(task: ParsedTask): Promise<void>;

package/dist/prebundle.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prebundle = void 0;
+const node_path_1 = require("node:path");
+const ncc_1 = __importDefault(require("@vercel/ncc"));
+const dts_packer_1 = require("dts-packer");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const constant_1 = require("./constant");
+const helper_1 = require("./helper");
+function emitAssets(assets, distPath) {
+    for (const key of Object.keys(assets)) {
+        const asset = assets[key];
+        fs_extra_1.default.outputFileSync((0, node_path_1.join)(distPath, key), asset.source);
+    }
+}
+function emitIndex(code, distPath) {
+    const distIndex = (0, node_path_1.join)(distPath, 'index.js');
+    fs_extra_1.default.outputFileSync(distIndex, code);
+}
+function fixTypeExternalPath(file, task, externals) {
+    const filepath = (0, node_path_1.join)(task.distPath, file);
+    (0, helper_1.replaceFileContent)(filepath, (content) => {
+        let newContent = content;
+        for (const name of Object.keys(externals)) {
+            newContent = newContent.replace(new RegExp(`../../${name}`, 'g'), externals[name]);
+        }
+        return newContent;
+    });
+}
+function emitDts(task) {
+    if (task.ignoreDts) {
+        fs_extra_1.default.writeFileSync((0, node_path_1.join)(task.distPath, 'index.d.ts'), 'export = any;\n');
+        return;
+    }
+    try {
+        const externals = {
+            ...constant_1.DEFAULT_EXTERNALS,
+            ...task.externals,
+        };
+        const { files } = new dts_packer_1.Package({
+            cwd: process.cwd(),
+            name: task.depName,
+            typesRoot: task.distPath,
+            externals: Object.keys(externals),
+        });
+        for (const file of Object.keys(files)) {
+            fixTypeExternalPath(file, task, externals);
+        }
+    }
+    catch (error) {
+        console.error(`DtsPacker failed: ${task.depName}`);
+        console.error(error);
+    }
+}
+function emitPackageJson(task) {
+    const packageJsonPath = (0, node_path_1.join)(task.depPath, 'package.json');
+    const packageJson = fs_extra_1.default.readJsonSync(packageJsonPath, 'utf-8');
+    const outputPath = (0, node_path_1.join)(task.distPath, 'package.json');
+    const pickedPackageJson = (0, helper_1.pick)(packageJson, [
+        'name',
+        'author',
+        'version',
+        'funding',
+        'license',
+        'types',
+        'typing',
+        'typings',
+        ...task.packageJsonField,
+    ]);
+    if (task.depName !== pickedPackageJson.name) {
+        pickedPackageJson.name = task.depName;
+    }
+    if (task.ignoreDts) {
+        delete pickedPackageJson.typing;
+        delete pickedPackageJson.typings;
+        pickedPackageJson.types = 'index.d.ts';
+    }
+    fs_extra_1.default.writeJSONSync(outputPath, pickedPackageJson);
+}
+function emitLicense(task) {
+    const licensePath = (0, node_path_1.join)(task.depPath, 'LICENSE');
+    if (fs_extra_1.default.existsSync(licensePath)) {
+        fs_extra_1.default.copySync(licensePath, (0, node_path_1.join)(task.distPath, 'license'));
+    }
+}
+function emitExtraFiles(task) {
+    const { emitFiles } = task;
+    for (const item of emitFiles) {
+        const path = (0, node_path_1.join)(task.distPath, item.path);
+        fs_extra_1.default.outputFileSync(path, item.content);
+    }
+}
+function removeSourceMap(task) {
+    const maps = fast_glob_1.default.sync((0, node_path_1.join)(task.distPath, '**/*.map'));
+    for (const mapPath of maps) {
+        fs_extra_1.default.removeSync(mapPath);
+    }
+}
+function renameDistFolder(task) {
+    const pkgPath = (0, node_path_1.join)(task.distPath, 'package.json');
+    const pkgJson = fs_extra_1.default.readJsonSync(pkgPath, 'utf-8');
+    for (const key of ['types', 'typing', 'typings']) {
+        if (pkgJson[key]?.startsWith('dist/')) {
+            pkgJson[key] = pkgJson[key].replace('dist/', 'types/');
+            const distFolder = (0, node_path_1.join)(task.distPath, 'dist');
+            const typesFolder = (0, node_path_1.join)(task.distPath, 'types');
+            if (fs_extra_1.default.existsSync(distFolder)) {
+                fs_extra_1.default.renameSync(distFolder, typesFolder);
+            }
+        }
+    }
+    // compiled packages are always use commonjs
+    pkgJson.type = 'commonjs';
+    fs_extra_1.default.writeJSONSync(pkgPath, pkgJson);
+}
+const pkgName = process.argv[2];
+async function prebundle(task) {
+    if (pkgName && task.depName !== pkgName) {
+        return;
+    }
+    console.log(`==== Start prebundle "${task.depName}" ====`);
+    fs_extra_1.default.removeSync(task.distPath);
+    if (task.beforeBundle) {
+        await task.beforeBundle(task);
+    }
+    const { code, assets } = await (0, ncc_1.default)(task.depEntry, {
+        minify: task.minify,
+        target: 'es2019',
+        externals: {
+            ...constant_1.DEFAULT_EXTERNALS,
+            ...task.externals,
+        },
+        assetBuilds: false,
+    });
+    emitIndex(code, task.distPath);
+    emitAssets(assets, task.distPath);
+    emitDts(task);
+    emitLicense(task);
+    emitPackageJson(task);
+    removeSourceMap(task);
+    renameDistFolder(task);
+    emitExtraFiles(task);
+    if (task.afterBundle) {
+        await task.afterBundle(task);
+    }
+    console.log(`==== Finish prebundle "${task.depName}" ====\n\n`);
+}
+exports.prebundle = prebundle;

package/dist/types.d.ts

@@ -0,0 +1,42 @@
+export type ImportMap = {
+    path: string;
+    content: string;
+};
+export type DependencyConfig = {
+    /** Name of dependency */
+    name: string;
+    /** Whether to minify the code. */
+    minify?: boolean;
+    /** Externals to leave as requires of the build. */
+    externals?: Record<string, string>;
+    /** Emit extra entry files to map imports. */
+    emitFiles?: ImportMap[];
+    /** Copy extra fields from original package.json to target package.json. */
+    packageJsonField?: string[];
+    /** Whether to ignore type definitions */
+    ignoreDts?: boolean;
+    beforeBundle?: (task: ParsedTask) => void | Promise<void>;
+    afterBundle?: (task: ParsedTask) => void | Promise<void>;
+};
+export type TaskConfig = {
+    packageDir: string;
+    packageName: string;
+    dependencies: Array<string | DependencyConfig>;
+};
+export type ParsedTask = {
+    depPath: string;
+    depEntry: string;
+    distPath: string;
+    importPath: string;
+    packageDir: string;
+    ignoreDts?: boolean;
+    packagePath: string;
+    packageName: string;
+    minify: NonNullable<DependencyConfig['minify']>;
+    depName: NonNullable<DependencyConfig['name']>;
+    externals: NonNullable<DependencyConfig['externals']>;
+    emitFiles: NonNullable<DependencyConfig['emitFiles']>;
+    afterBundle?: NonNullable<DependencyConfig['afterBundle']>;
+    beforeBundle?: NonNullable<DependencyConfig['beforeBundle']>;
+    packageJsonField: NonNullable<DependencyConfig['packageJsonField']>;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "prebundle",
+  "version": "0.0.1",
+  "main": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "prebundle": "./bin.js"
+  },
+  "dependencies": {
+    "@vercel/ncc": "0.38.1",
+    "dts-packer": "0.0.3",
+    "fast-glob": "^3.3.2",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "18.x",
+    "typescript": "^5.4.2"
+  },
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "tsc",
+    "start": "pnpm build && node ./dist/index.js"
+  }
+}