prebundle 0.0.1 → 0.0.3

package/README.md

@@ -15,46 +15,16 @@ Prebundle is used to:
 Run following command to prebundle all dependencies:
 
 ```bash
-pnpm start
+npx prebundle
 ```
 
 Run following command to prebundle single dependencies:
 
 ```bash
-pnpm start <pkgName>
+npx prebundle <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';
+npx prebundle commander
 ```
 
 ## Dependency Config
@@ -160,12 +130,3 @@ dependencies: [
   },
 ];
 ```
-
-## 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

@@ -1 +1,4 @@
 #!/usr/bin/env node
+import { run } from './dist/index.js';
+
+run();

package/dist/constant.d.ts

@@ -1,20 +1,7 @@
-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[];
+export declare const cwd: string;

package/dist/constant.js

@@ -1,358 +1,8 @@
-"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',
+export const DIST_DIR = 'compiled';
+export const DEFAULT_EXTERNALS = {
     // 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,
-            },
-        ],
-    },
-];
+export const cwd = process.cwd();

package/dist/helper.d.ts

@@ -1,5 +1,6 @@
-import type { ParsedTask } from './types';
+import type { DependencyConfig, ParsedTask } from './types.js';
 export declare function findDepPath(name: string): string;
-export declare function parseTasks(): ParsedTask[];
+export declare const resolveConfig: () => Promise<any>;
+export declare function parseTasks(dependencies: Array<string | DependencyConfig>): 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

@@ -1,70 +1,63 @@
-"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);
+import { dirname, join } from 'node:path';
+import fs from 'fs-extra';
+import { cwd, DIST_DIR } from './constant.js';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+export function findDepPath(name) {
+    let entry = dirname(require.resolve(join(name), { paths: [cwd] }));
+    while (!dirname(entry).endsWith('node_modules')) {
+        entry = dirname(entry);
     }
     if (name.includes('/')) {
-        return (0, node_path_1.join)((0, node_path_1.dirname)(entry), name);
+        return join(dirname(entry), name);
     }
     return entry;
 }
-exports.findDepPath = findDepPath;
-function parseTasks() {
+export const resolveConfig = async () => {
+    const configPath = join(cwd, 'prebundle.config.mjs');
+    const config = await import(configPath);
+    return config.default;
+};
+export function parseTasks(dependencies) {
     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,
-                });
-            }
+    for (const dep of dependencies) {
+        const depName = typeof dep === 'string' ? dep : dep.name;
+        const importPath = join(cwd, DIST_DIR, depName);
+        const distPath = join(cwd, DIST_DIR, depName);
+        const depPath = findDepPath(depName);
+        const depEntry = require.resolve(depName, { paths: [cwd] });
+        const info = {
+            depName,
+            depPath,
+            depEntry,
+            distPath,
+            importPath,
+        };
+        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) {
+export function pick(obj, keys) {
     return keys.reduce((ret, key) => {
         if (obj[key] !== undefined) {
             ret[key] = obj[key];
@@ -72,12 +65,10 @@ function pick(obj, keys) {
         return ret;
     }, {});
 }
-exports.pick = pick;
-function replaceFileContent(filePath, replaceFn) {
-    const content = fs_extra_1.default.readFileSync(filePath, 'utf-8');
+export function replaceFileContent(filePath, replaceFn) {
+    const content = fs.readFileSync(filePath, 'utf-8');
     const newContent = replaceFn(content);
     if (newContent !== content) {
-        fs_extra_1.default.writeFileSync(filePath, newContent);
+        fs.writeFileSync(filePath, newContent);
     }
 }
-exports.replaceFileContent = replaceFileContent;

package/dist/index.d.ts

@@ -1 +1 @@
-export {};
+export declare function run(): Promise<void>;

package/dist/index.js

@@ -1,11 +1,9 @@
-"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)();
+import { parseTasks, resolveConfig } from './helper.js';
+import { prebundle } from './prebundle.js';
+export async function run() {
+    const config = await resolveConfig();
+    const parsedTasks = parseTasks(config.dependencies);
     for (const task of parsedTasks) {
-        await (0, prebundle_1.prebundle)(task);
+        await prebundle(task);
     }
 }
-run();

package/dist/prebundle.d.ts

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

package/dist/prebundle.js

@@ -1,29 +1,23 @@
-"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");
+import { join } from 'node:path';
+import ncc from '@vercel/ncc';
+import { Package as DtsPacker } from 'dts-packer';
+import fastGlob from 'fast-glob';
+import fs from 'fs-extra';
+import { cwd, DEFAULT_EXTERNALS } from './constant.js';
+import { pick, replaceFileContent } from './helper.js';
 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);
+        fs.outputFileSync(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);
+    const distIndex = join(distPath, 'index.js');
+    fs.outputFileSync(distIndex, code);
 }
 function fixTypeExternalPath(file, task, externals) {
-    const filepath = (0, node_path_1.join)(task.distPath, file);
-    (0, helper_1.replaceFileContent)(filepath, (content) => {
+    const filepath = join(task.distPath, file);
+    replaceFileContent(filepath, (content) => {
         let newContent = content;
         for (const name of Object.keys(externals)) {
             newContent = newContent.replace(new RegExp(`../../${name}`, 'g'), externals[name]);
@@ -33,16 +27,16 @@ function fixTypeExternalPath(file, task, externals) {
 }
 function emitDts(task) {
     if (task.ignoreDts) {
-        fs_extra_1.default.writeFileSync((0, node_path_1.join)(task.distPath, 'index.d.ts'), 'export = any;\n');
+        fs.writeFileSync(join(task.distPath, 'index.d.ts'), 'export = any;\n');
         return;
     }
     try {
         const externals = {
-            ...constant_1.DEFAULT_EXTERNALS,
+            ...DEFAULT_EXTERNALS,
             ...task.externals,
         };
-        const { files } = new dts_packer_1.Package({
-            cwd: process.cwd(),
+        const { files } = new DtsPacker({
+            cwd,
             name: task.depName,
             typesRoot: task.distPath,
             externals: Object.keys(externals),
@@ -57,10 +51,10 @@ function emitDts(task) {
     }
 }
 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, [
+    const packageJsonPath = join(task.depPath, 'package.json');
+    const packageJson = fs.readJsonSync(packageJsonPath, 'utf-8');
+    const outputPath = join(task.distPath, 'package.json');
+    const pickedPackageJson = pick(packageJson, [
         'name',
         'author',
         'version',
@@ -79,59 +73,59 @@ function emitPackageJson(task) {
         delete pickedPackageJson.typings;
         pickedPackageJson.types = 'index.d.ts';
     }
-    fs_extra_1.default.writeJSONSync(outputPath, pickedPackageJson);
+    fs.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'));
+    const licensePath = join(task.depPath, 'LICENSE');
+    if (fs.existsSync(licensePath)) {
+        fs.copySync(licensePath, 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);
+        const path = join(task.distPath, item.path);
+        fs.outputFileSync(path, item.content);
     }
 }
 function removeSourceMap(task) {
-    const maps = fast_glob_1.default.sync((0, node_path_1.join)(task.distPath, '**/*.map'));
+    const maps = fastGlob.sync(join(task.distPath, '**/*.map'));
     for (const mapPath of maps) {
-        fs_extra_1.default.removeSync(mapPath);
+        fs.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');
+    const pkgPath = join(task.distPath, 'package.json');
+    const pkgJson = fs.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);
+            const distFolder = join(task.distPath, 'dist');
+            const typesFolder = join(task.distPath, 'types');
+            if (fs.existsSync(distFolder)) {
+                fs.renameSync(distFolder, typesFolder);
             }
         }
     }
     // compiled packages are always use commonjs
     pkgJson.type = 'commonjs';
-    fs_extra_1.default.writeJSONSync(pkgPath, pkgJson);
+    fs.writeJSONSync(pkgPath, pkgJson);
 }
 const pkgName = process.argv[2];
-async function prebundle(task) {
+export async function prebundle(task) {
     if (pkgName && task.depName !== pkgName) {
         return;
     }
     console.log(`==== Start prebundle "${task.depName}" ====`);
-    fs_extra_1.default.removeSync(task.distPath);
+    fs.removeSync(task.distPath);
     if (task.beforeBundle) {
         await task.beforeBundle(task);
     }
-    const { code, assets } = await (0, ncc_1.default)(task.depEntry, {
+    const { code, assets } = await ncc(task.depEntry, {
         minify: task.minify,
         target: 'es2019',
         externals: {
-            ...constant_1.DEFAULT_EXTERNALS,
+            ...DEFAULT_EXTERNALS,
             ...task.externals,
         },
         assetBuilds: false,
@@ -149,4 +143,3 @@ async function prebundle(task) {
     }
     console.log(`==== Finish prebundle "${task.depName}" ====\n\n`);
 }
-exports.prebundle = prebundle;

package/dist/types.d.ts

@@ -18,9 +18,7 @@ export type DependencyConfig = {
     beforeBundle?: (task: ParsedTask) => void | Promise<void>;
     afterBundle?: (task: ParsedTask) => void | Promise<void>;
 };
-export type TaskConfig = {
-    packageDir: string;
-    packageName: string;
+export type Config = {
     dependencies: Array<string | DependencyConfig>;
 };
 export type ParsedTask = {
@@ -28,10 +26,7 @@ export type ParsedTask = {
     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']>;

package/dist/types.js

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

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "prebundle",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "main": "./dist/index.js",
+  "type": "module",
   "files": [
-    "dist"
+    "dist",
+    "bin.js"
   ],
   "bin": {
     "prebundle": "./bin.js"
@@ -17,11 +19,14 @@
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/node": "18.x",
+    "prettier": "^3.2.5",
     "typescript": "^5.4.2"
   },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
   "scripts": {
     "dev": "tsc --watch",
-    "build": "tsc",
-    "start": "pnpm build && node ./dist/index.js"
+    "build": "tsc"
   }
 }