bunchee 3.0.0-beta.11 → 3.0.0-beta.12

package/README.md

@@ -22,31 +22,19 @@ npm install --save-dev bunchee
 ```
 
 ## Usage
-### Package.json Configuration
 
-Declare the main and module fields in your package.json file, then call the bunchee CLI in the build scripts. If you are using TypeScript, types will be generated automatically based on the typings or types field in your package.json file.
+Create your library
 
-#### Configure `main` and `module` fields
-
-You can have Commonjs + ESModules output as the simple config
-
-```json
-{
-  "main": "dist/pkg.cjs.js",
-  "module": "dist/pkg.esm.js",
-  "scripts": {
-    "build": "bunchee ./src/index.js"
-  },
-  "types": "dist/types/index.d.ts"
-}
+```sh
+cd ./my-lib && mkdir src
+touch ./src/index.js
+touch package.json
 ```
-
-#### Configure `exports` field
+Configure module exports
 
 [exports sugar in Node.js](https://nodejs.org/api/packages.html#exports-sugar)
 
-You can use the exports field to support different conditions and leverage the same functionality as other bundlers, such as webpack. The exports field allows you to define multiple conditions.
-
+You can use the `exports` field to support different conditions and leverage the same functionality as other bundlers, such as webpack. The exports field allows you to define multiple conditions.
 
 ```json
 {
@@ -56,102 +44,96 @@ You can use the exports field to support different conditions and leverage the s
     "module": "dist/index.esm.js"
   },
   "scripts": {
-    "build": "bunchee ./src/index.js"
+    "build": "bunchee"
   },
 }
 ```
 
-### CLI
+Using pure ESM package?
 
+```json
+{
+  "type": "module",
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "bunchee"
+  }
+}
 ```
-Usage: bunchee [options]
-
-Options:
-  -v, --version          output the version number
-  -w, --watch            watch src files changes
-  -m, --minify           compress output. default: false
-  -o, --output <file>    specify output filename
-  -f, --format <format>  type of output (esm, amd, cjs, iife, umd, system), default: esm
-  -e, --external <mod>   specify an external dependency
-  -h, --help             output usage information
-  --target <target>      js features target: swc target es versions. default: es2015
-  --runtime <runtime>    build runtime (nodejs, browser). default: browser
-  --cwd <cwd>            specify current working directory
-  --sourcemap            enable sourcemap generation, default: false
-  --dts                  determine if need to generate types, default: false
-
-Usage:
-  $ bunchee ./src/index.js # if you set main fields in package.json
-  $ bunchee ./src/index.ts -o ./dist/bundle.js # specify the dist file path
-```
 
-Run bunchee via CLI
+Then just run `npm run build`, or `pnpm build` / `yarn build` if you're using these package managers.
+
+## Configuration
+
+`bunchee` CLI provides few options to create different bundles or generating types.
+
+### CLI Options
+
+- Output (`-o <file>`): Specify output filename.
+- Format (`-f <format>`): Set output format (default: `'esm'`).
+- External (`--external <dep,>`): Specifying extra external dependencies, by default it is the list of `dependencies` and `peerDependencies` from `package.json`. Values are separate by comma.
+- Target (`--target <target>`): Set ECMAScript target (default: `'es2016'`).
+- Runtime (`--runtime <runtime>`): Set build runtime (default: `'browser'`).
+- Environment (`--env <env,>`): Define environment variables. (default: `NODE_ENV`, separate by comma)
+- Working Directory (`--cwd <cwd>`): Set current working directory where containing `package.json`.
+- Types only (`--dts`): Generate TypeScript declaration files without assets.
+- Minify (`-m`): Compress output.
+- Watch (`-w`): Watch for source file changes.
+
+### Basic Example
 
 ```sh
 cd <project-root-dir>
-bunchee ./src/index.js -f cjs -o ./dist/bundle.js
 
+# specifying input, output and format
+
+bunchee ./src/index.js -f cjs -o ./dist/bundle.js
 bunchee ./src/index.js -f esm -o ./dist/bundle.esm.js
-# if you don't specify format type, default format is ESModule
-# bunchee ./src/index.js -o ./dist/bundle.esm.js
+
+# build node.js library, or change target to es2019
+bunchee ./src/index.js --runtime node --target es2019
 ```
 
-### Node.js API
+#### Specifying extra external dependencies
 
-```js
-import path from 'path'
-import { bundle } from 'bunchee'
+If you want to mark specific dependencies as external and not include them in the bundle, use the `--external` option followed by a comma-separated list of dependency names:
 
-// The definition of these options can be found in help information
-await bundle(path.resolve('./src/index.ts'), {
-  dts: false,
-  watch: false,
-  minify: false,
-  sourcemap: false,
-  external: [],
-  format: 'esm',
-  target: 'es2016',
-  runtime: 'nodejs',
-})
+```sh
+bunchee --external=dependency1,dependency2,dependency3
 ```
 
-#### Watch Mode
-
-Bunchee offers a convenient watch mode for rebuilding your library whenever changes are made to the source files. To enable this feature, use either -w or --watch.
+Replace `dependency1`, `dependency2`, and `dependency3` with the names of the dependencies you want to exclude from the bundle.
 
-### Typescript
-
-By default bunchee includes Typescript v3.9.x inside as a dependency. If you want to use your own version, just install typescript as another dev dependency then bunchee will automatically pick it.
+#### Bundling everything without external dependencies
+To bundle your library without external dependencies, use the `--no-external` option:
 
 ```sh
-yarn add -D bunchee typescript
+bunchee --no-external
 ```
+This will include all dependencies within your output bundle.
 
-Create `tsconfig.json` to specify any compiler options for TypeScript.
-
-This library requires at least [TypeScript 3.7](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html).
-
+### Environment Variables
+To pass environment variables to your bundled code, use the --env option followed by a comma-separated list of environment variable names:
 
-#### `target`
+```bash
+bunchee --env=ENV1,ENV2,ENV3
+```
 
-If you specify `target` option in `tsconfig.json`, then you don't have to pass it again through CLI.
+Replace `ENV1`, `ENV2`, and `ENV3` with the names of the environment variables you want to include in your bundled code. These environment variables will be inlined during the bundling process.
 
-## Advanced
 
-### Multiple Exports
+### Entry Files Convention
 
 While `exports` filed is becoming the standard of exporting in node.js, bunchee also supports to build multiple exports all in one command.
 
 What you need to do is just add an entry file with the name (`[name].[ext]`) that matches the exported name from exports field in package.json. For instance:
 
-* `index.ts` will match `"."` export name or the if there's only one main export.
-* `lite.ts` will match `"./lite"` export name.
+* `<cwd>/src/index.ts` will match `"."` export name or the if there's only one main export.
+* `<cwd>/src/lite.ts` will match `"./lite"` export name.
 
 The build script will be simplified to just `bunchee` in package.json without configure any input sources for each exports. Of course you can still specify other arguments as you need.
 
-#### How it works
-
-Assuming you have main entry export `"."` and subpath export `"./lite"` with different exports condition listed in package.json
+Assuming you have default export package as `"."` and subpath export `"./lite"` with different exports condition listed in package.json
 
 ```json
 {
@@ -172,13 +154,66 @@ Assuming you have main entry export `"."` and subpath export `"./lite"` with dif
 Then you need to add two entry files `index.ts` and `lite.ts` in project root directory to match the export name `"."` and `"./lite"`, bunchee will associate these entry files with export names then use them as input source and output paths information.
 
 ```
-- example/
-  |- lite.ts
-  |- index.ts
+- my-lib/
   |- src/
+    |- lite.ts
+    |- index.ts
   |- package.json
 ```
 
+#### Package lint
+
+`bunchee` has support for checking the package bundles are matched with package exports configuration.
+
+### TypeScript
+
+By default bunchee includes Typescript v3.9.x inside as a dependency. If you want to use your own version, just install typescript as another dev dependency then bunchee will automatically pick it.
+
+```sh
+yarn add -D bunchee typescript
+```
+
+Create `tsconfig.json` to specify any compiler options for TypeScript.
+
+This library requires at least [TypeScript 3.7](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html).
+
+
+Adding `"types"` or `"typing"` field in your package.json, types will be generated with that path.
+
+```json
+{
+  "types": "dist/types/index.d.ts"
+}
+```
+
+### Node.js API
+
+```ts
+import path from 'path'
+import { bundle, type BundleConfig } from 'bunchee'
+
+// The definition of these options can be found in help information
+await bundle(path.resolve('./src/index.ts'), {
+  dts: false, // Boolean
+  watch: false, // Boolean
+  minify: false, // Boolean
+  sourcemap: false, // Boolean
+  external: [], // string[]
+  format: 'esm', // 'esm' | 'cjs'
+  target: 'es2016', // ES syntax target
+  runtime: 'nodejs', // 'browser' | 'nodejs'
+  cwd: process.cwd(), // string
+})
+```
+
+#### Watch Mode
+
+Bunchee offers a convenient watch mode for rebuilding your library whenever changes are made to the source files. To enable this feature, use either -w or --watch.
+
+#### `target`
+
+If you specify `target` option in `tsconfig.json`, then you don't have to pass it again through CLI.
+
 ### License
 
 MIT

package/dist/cli.js

@@ -1,22 +1,57 @@
 #!/usr/bin/env node
 var path = require('path');
 var arg = require('arg');
-var fs = require('fs');
+var fs = require('fs/promises');
 
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
 function exit(err) {
     logger.error(err);
     process.exit(1);
 }
 const formatDuration = (duration)=>duration >= 1000 ? `${duration / 1000}s` : `${duration}ms`;
 function getPackageMeta(cwd) {
-    const pkgFilePath = path.resolve(cwd, 'package.json');
-    let targetPackageJson = {};
-    try {
-        targetPackageJson = JSON.parse(fs.readFileSync(pkgFilePath, {
-            encoding: 'utf-8'
-        }));
-    } catch (_) {}
-    return targetPackageJson;
+    return _getPackageMeta.apply(this, arguments);
+}
+function _getPackageMeta() {
+    _getPackageMeta = _async_to_generator$1(function*(cwd) {
+        const pkgFilePath = path.resolve(cwd, 'package.json');
+        let targetPackageJson = {};
+        try {
+            targetPackageJson = JSON.parse((yield fs.readFile(pkgFilePath, {
+                encoding: 'utf-8'
+            })));
+        } catch (_) {}
+        return targetPackageJson;
+    });
+    return _getPackageMeta.apply(this, arguments);
 }
 const logger = {
     log (arg) {
@@ -30,7 +65,7 @@ const logger = {
     }
 };
 
-var version = "3.0.0-beta.11";
+var version = "3.0.0-beta.12";
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -46,7 +81,7 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _asyncToGenerator(fn) {
+function _async_to_generator(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
@@ -70,10 +105,12 @@ Options:
   -m, --minify           compress output. default: false
   -o, --output <file>    specify output filename
   -f, --format <format>  type of output (esm, amd, cjs, iife, umd, system), default: esm
-  -e, --external <mod>   specify an external dependency
   -h, --help             output usage information
-  --target <target>      js features target: swc target es versions. default: es2015
+  --external <mod>       specify an external dependency, separate by comma
+  --no-external          do not bundle external dependencies
+  --target <target>      js features target: swc target es versions. default: es2016
   --runtime <runtime>    build runtime (nodejs, browser). default: browser
+  --env <env>            inlined process env variables, separate by comma. default: NODE_ENV
   --cwd <cwd>            specify current working directory
   --sourcemap            enable sourcemap generation, default: false
   --dts                  determine if need to generate types, default: false
@@ -85,14 +122,14 @@ function lintPackage(cwd) {
     return _lintPackage.apply(this, arguments);
 }
 function _lintPackage() {
-    _lintPackage = _asyncToGenerator(function*(cwd) {
+    _lintPackage = _async_to_generator(function*(cwd) {
         const { publint  } = yield import('publint');
         const { printMessage  } = yield import('publint/utils');
         const messages = yield publint({
             pkgDir: cwd,
             level: 'error'
         });
-        const pkg = getPackageMeta(cwd);
+        const pkg = yield getPackageMeta(cwd);
         for (const message of messages){
             console.log(printMessage(message, pkg));
         }
@@ -113,16 +150,15 @@ function parseCliArgs(argv) {
         '--runtime': String,
         '--target': String,
         '--sourcemap': Boolean,
-        '--external': [
-            String
-        ],
+        '--env': String,
+        '--external': String,
+        '--no-external': Boolean,
         '-h': '--help',
         '-v': '--version',
         '-w': '--watch',
         '-o': '--output',
         '-f': '--format',
-        '-m': '--minify',
-        '-e': '--external'
+        '-m': '--minify'
     }, {
         permissive: true,
         argv
@@ -141,7 +177,8 @@ function parseCliArgs(argv) {
         version: args['--version'],
         runtime: args['--runtime'],
         target: args['--target'],
-        external: args['--external']
+        external: !!args['--no-external'] ? null : args['--external'],
+        env: args['--env']
     };
     return parsedArgs;
 }
@@ -149,21 +186,23 @@ function run(args) {
     return _run.apply(this, arguments);
 }
 function _run() {
-    _run = _asyncToGenerator(function*(args) {
-        const { source , format , watch , minify , sourcemap , target , runtime , dts  } = args;
+    _run = _async_to_generator(function*(args) {
+        var _args_external;
+        const { source , format , watch , minify , sourcemap , target , runtime , dts , env  } = args;
         const cwd = args.cwd || process.cwd();
         const file = args.file ? path.resolve(cwd, args.file) : undefined;
-        const cliArgs = {
+        const bundleConfig = {
             dts,
             file,
             format,
             cwd,
             target,
             runtime,
-            external: args.external || [],
+            external: ((_args_external = args.external) == null ? void 0 : _args_external.split(',')) || [],
             watch: !!watch,
             minify: !!minify,
-            sourcemap: sourcemap === false ? false : true
+            sourcemap: sourcemap === false ? false : true,
+            env: (env == null ? void 0 : env.split(',')) || []
         };
         if (args.version) {
             return logger.log(version);
@@ -172,11 +211,11 @@ function _run() {
             return help();
         }
         const entry = source ? path.resolve(cwd, source) : '';
-        const bundle = require('./lib').bundle;
+        const bundle = require('./index').bundle;
         let timeStart = Date.now();
         let timeEnd;
         try {
-            yield bundle(entry, cliArgs);
+            yield bundle(entry, bundleConfig);
             timeEnd = Date.now();
         } catch (err) {
             if (err.name === 'NOT_EXISTED') {
@@ -201,7 +240,7 @@ function main() {
     return _main.apply(this, arguments);
 }
 function _main() {
-    _main = _asyncToGenerator(function*() {
+    _main = _async_to_generator(function*() {
         let params, error;
         try {
             params = parseCliArgs(process.argv.slice(2));

package/dist/{lib.d.ts → index.d.ts}

@@ -1,13 +1,19 @@
 import { JscTarget } from '@swc/core';
-import { RollupOptions, InputOptions, OutputOptions } from 'rollup';
+import { OutputOptions } from 'rollup';
 
 type ExportType = 'require' | 'export' | 'default' | string;
-type CommonConfig = {
-    dts?: boolean;
+type BundleConfig = {
+    file?: string;
+    cwd?: string;
+    watch?: boolean;
+    target?: JscTarget;
     format?: OutputOptions['format'];
     minify?: boolean;
     sourcemap?: boolean;
     external?: string[];
+    noExternal?: boolean;
+    env?: string[];
+    dts?: boolean;
     runtime?: string;
     exportCondition?: {
         source: string;
@@ -16,19 +22,7 @@ type CommonConfig = {
     };
 };
 type ExportCondition = string | Record<ExportType, string>;
-type BuncheeRollupConfig = Partial<Omit<RollupOptions, 'input' | 'output'>> & {
-    exportName?: string;
-    input: InputOptions;
-    output: OutputOptions[];
-    dtsOnly: boolean;
-};
-type CliArgs = CommonConfig & {
-    file?: string;
-    watch?: boolean;
-    cwd?: string;
-    target?: JscTarget;
-};
 
-declare function bundle(entryPath: string, { cwd, ...options }?: CliArgs): Promise<any>;
+declare function bundle(entryPath: string, { cwd, ...options }?: BundleConfig): Promise<any>;
 
-export { BuncheeRollupConfig, CliArgs, bundle };
+export { BundleConfig, bundle };

package/dist/{lib.js → index.js}

@@ -1,14 +1,16 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var fs = require('fs');
+var fs = require('fs/promises');
 var path = require('path');
 var rollup = require('rollup');
+var fs$1 = require('fs');
 var module$1 = require('module');
 var rollupPluginSwc3 = require('rollup-plugin-swc3');
 var commonjs = require('@rollup/plugin-commonjs');
 var shebang = require('rollup-plugin-preserve-shebang');
 var json = require('@rollup/plugin-json');
 var pluginNodeResolve = require('@rollup/plugin-node-resolve');
+var replace = require('@rollup/plugin-replace');
 
 const rootDir = process.cwd();
 var config = {
@@ -134,20 +136,55 @@ function getExportConditionDist(pkg, exportCondition) {
     return dist;
 }
 
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
 function exit(err) {
     logger.error(err);
     process.exit(1);
 }
 const formatDuration = (duration)=>duration >= 1000 ? `${duration / 1000}s` : `${duration}ms`;
 function getPackageMeta(cwd) {
-    const pkgFilePath = path.resolve(cwd, 'package.json');
-    let targetPackageJson = {};
-    try {
-        targetPackageJson = JSON.parse(fs.readFileSync(pkgFilePath, {
-            encoding: 'utf-8'
-        }));
-    } catch (_) {}
-    return targetPackageJson;
+    return _getPackageMeta.apply(this, arguments);
+}
+function _getPackageMeta() {
+    _getPackageMeta = _async_to_generator$1(function*(cwd) {
+        const pkgFilePath = path.resolve(cwd, 'package.json');
+        let targetPackageJson = {};
+        try {
+            targetPackageJson = JSON.parse((yield fs.readFile(pkgFilePath, {
+                encoding: 'utf-8'
+            })));
+        } catch (_) {}
+        return targetPackageJson;
+    });
+    return _getPackageMeta.apply(this, arguments);
 }
 const logger = {
     log (arg) {
@@ -164,6 +201,23 @@ function isTypescript(filename) {
     const ext = path.extname(filename);
     return ext === '.ts' || ext === '.tsx';
 }
+function fileExists(filePath) {
+    return _fileExists.apply(this, arguments);
+}
+function _fileExists() {
+    _fileExists = _async_to_generator$1(function*(filePath) {
+        try {
+            yield fs.access(filePath);
+            return true;
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                return false;
+            }
+            throw err;
+        }
+    });
+    return _fileExists.apply(this, arguments);
+}
 const isNotNull = (n)=>Boolean(n);
 
 function _extends$1() {
@@ -207,9 +261,22 @@ function resolveTypescript(cwd) {
     }
     return ts;
 }
+function getBuildEnv(envs) {
+    if (!envs.includes('NODE_ENV')) {
+        envs.push('NODE_ENV');
+    }
+    const envVars = envs.reduce((acc, key)=>{
+        const value = process.env[key];
+        if (typeof value !== 'undefined') {
+            acc['process.env.' + key] = JSON.stringify(value);
+        }
+        return acc;
+    }, {});
+    return envVars;
+}
 function buildInputConfig(entry, pkg, options, { tsConfigPath , tsCompilerOptions , dtsOnly  }) {
     var _options_external;
-    const externals = [
+    const externals = options.noExternal ? [] : [
         pkg.peerDependencies,
         pkg.dependencies,
         pkg.peerDependenciesMeta
@@ -237,6 +304,10 @@ function buildInputConfig(entry, pkg, options, { tsConfigPath , tsCompilerOption
             })
         })
     ] : [
+        replace({
+            values: getBuildEnv(options.env || []),
+            preventAssignment: true
+        }),
         pluginNodeResolve.nodeResolve({
             preferBuiltins: runtime === 'node',
             extensions: [
@@ -337,11 +408,11 @@ function buildOutputConfigs(options, pkg, { tsCompilerOptions , dtsOnly  }) {
         sourcemap: options.sourcemap
     });
 }
-function buildConfig(entry, pkg, cliArgs, dtsOnly) {
+function buildConfig(entry, pkg, bundleConfig, dtsOnly) {
     var _options_exportCondition;
-    const { file  } = cliArgs;
+    const { file  } = bundleConfig;
     const useTypescript = isTypescript(entry);
-    const options = _extends$1({}, cliArgs, {
+    const options = _extends$1({}, bundleConfig, {
         useTypescript
     });
     let tsCompilerOptions = {};
@@ -349,7 +420,7 @@ function buildConfig(entry, pkg, cliArgs, dtsOnly) {
     if (useTypescript) {
         const ts = resolveTypescript(config.rootDir);
         tsConfigPath = path.resolve(config.rootDir, 'tsconfig.json');
-        if (fs.existsSync(tsConfigPath)) {
+        if (fs$1.existsSync(tsConfigPath)) {
             const basePath = tsConfigPath ? path.dirname(tsConfigPath) : config.rootDir;
             const tsconfigJSON = ts.readConfigFile(tsConfigPath, ts.sys.readFile).config;
             tsCompilerOptions = ts.parseJsonConfigFileContent(tsconfigJSON, ts.sys, basePath).options;
@@ -369,7 +440,7 @@ function buildConfig(entry, pkg, cliArgs, dtsOnly) {
     // Generate dts job - single config
     if (dtsOnly) {
         outputConfigs = [
-            buildOutputConfigs(_extends$1({}, cliArgs, {
+            buildOutputConfigs(_extends$1({}, bundleConfig, {
                 format: 'es',
                 useTypescript
             }), pkg, typescriptOptions)
@@ -377,7 +448,7 @@ function buildConfig(entry, pkg, cliArgs, dtsOnly) {
     } else {
         // multi outputs with specified format
         outputConfigs = outputExports.map((exportDist)=>{
-            return buildOutputConfigs(_extends$1({}, cliArgs, {
+            return buildOutputConfigs(_extends$1({}, bundleConfig, {
                 file: exportDist.file,
                 format: exportDist.format,
                 useTypescript
@@ -388,9 +459,9 @@ function buildConfig(entry, pkg, cliArgs, dtsOnly) {
             var _outputExports_;
             const fallbackFormat = (_outputExports_ = outputExports[0]) == null ? void 0 : _outputExports_.format;
             outputConfigs = [
-                buildOutputConfigs(_extends$1({}, cliArgs, {
+                buildOutputConfigs(_extends$1({}, bundleConfig, {
                     file,
-                    format: cliArgs.format || fallbackFormat,
+                    format: bundleConfig.format || fallbackFormat,
                     useTypescript
                 }), pkg, typescriptOptions)
             ];
@@ -418,7 +489,7 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
         Promise.resolve(value).then(_next, _throw);
     }
 }
-function _asyncToGenerator(fn) {
+function _async_to_generator(fn) {
     return function() {
         var self = this, args = arguments;
         return new Promise(function(resolve, reject) {
@@ -447,7 +518,7 @@ function _extends() {
     };
     return _extends.apply(this, arguments);
 }
-function _objectWithoutPropertiesLoose(source, excluded) {
+function _object_without_properties_loose(source, excluded) {
     if (source == null) return {};
     var target = {};
     var sourceKeys = Object.keys(source);
@@ -459,6 +530,8 @@ function _objectWithoutPropertiesLoose(source, excluded) {
     }
     return target;
 }
+const SRC = 'src' // resolve from src/ directory
+;
 function logBuild(exportPath, dtsOnly, duration) {
     logger.log(` ✓  ${dtsOnly ? 'Typed' : 'Built'} ${exportPath} ${formatDuration(duration)}`);
 }
@@ -467,35 +540,44 @@ function assignDefault(options, name, defaultValue) {
         options[name] = defaultValue;
     }
 }
-// Map '.' -> './index.[ext]'
-// Map './lite' -> './lite.[ext]'
-// Return undefined if no match or if it's package.json exports
+function resolveSourceFile(cwd, filename) {
+    return path.resolve(cwd, SRC, filename);
+}
 function getSourcePathFromExportPath(cwd, exportPath) {
-    const exts = [
-        'js',
-        'cjs',
-        'mjs',
-        'jsx',
-        'ts',
-        'tsx'
-    ];
-    for (const ext of exts){
-        // ignore package.json
-        if (exportPath.endsWith('package.json')) return;
-        if (exportPath === '.') exportPath = './index';
-        const filename = path.resolve(cwd, `${exportPath}.${ext}`);
-        if (fs.existsSync(filename)) {
-            return filename;
+    return _getSourcePathFromExportPath.apply(this, arguments);
+}
+function _getSourcePathFromExportPath() {
+    _getSourcePathFromExportPath = // Map '.' -> './index.[ext]'
+    // Map './lite' -> './lite.[ext]'
+    // Return undefined if no match or if it's package.json exports
+    _async_to_generator(function*(cwd, exportPath) {
+        const exts = [
+            'js',
+            'cjs',
+            'mjs',
+            'jsx',
+            'ts',
+            'tsx'
+        ];
+        for (const ext of exts){
+            // ignore package.json
+            if (exportPath.endsWith('package.json')) return;
+            if (exportPath === '.') exportPath = './index';
+            const filename = resolveSourceFile(cwd, `${exportPath}.${ext}`);
+            if (yield fileExists(filename)) {
+                return filename;
+            }
         }
-    }
-    return;
+        return;
+    });
+    return _getSourcePathFromExportPath.apply(this, arguments);
 }
 function bundle(entryPath) {
     return _bundle.apply(this, arguments);
 }
 function _bundle() {
-    _bundle = _asyncToGenerator(function*(entryPath, _param = {}) {
-        var { cwd  } = _param, options = _objectWithoutPropertiesLoose(_param, [
+    _bundle = _async_to_generator(function*(entryPath, _param = {}) {
+        var { cwd  } = _param, options = _object_without_properties_loose(_param, [
             "cwd"
         ]);
         config.rootDir = path.resolve(process.cwd(), cwd || '');
@@ -505,30 +587,36 @@ function _bundle() {
         if (options.dts === undefined && isTypescript(entryPath)) {
             options.dts = true;
         }
-        const pkg = getPackageMeta(config.rootDir);
+        const pkg = yield getPackageMeta(config.rootDir);
         const packageExports = pkg.exports || {};
         const isSingleEntry = typeof packageExports === 'string';
         const hasMultiEntries = packageExports && !isSingleEntry && Object.keys(packageExports).length > 0;
         if (isSingleEntry) {
             // Use specified string file path if possible, then fallback to the default behavior entry picking logic
             // e.g. "exports": "./dist/index.js" -> use "./index.<ext>" as entry
-            entryPath = entryPath || getSourcePathFromExportPath(config.rootDir, '.') || '';
+            entryPath = entryPath || (yield getSourcePathFromExportPath(config.rootDir, '.')) || '';
         }
         function buildEntryConfig(packageExports, dtsOnly) {
-            const configs = Object.keys(packageExports).map((entryExport)=>{
-                const source = getSourcePathFromExportPath(config.rootDir, entryExport);
-                if (!source) return undefined;
-                if (dtsOnly && !isTypescript(source)) return;
-                options.exportCondition = {
-                    source,
-                    name: entryExport,
-                    export: packageExports[entryExport]
-                };
-                const entry = path.resolve(cwd, source);
-                const rollupConfig = buildConfig(entry, pkg, options, dtsOnly);
-                return rollupConfig;
-            }).filter((v)=>!!v);
-            return configs;
+            return _buildEntryConfig.apply(this, arguments);
+        }
+        function _buildEntryConfig() {
+            _buildEntryConfig = _async_to_generator(function*(packageExports, dtsOnly) {
+                const configs = Object.keys(packageExports).map(/*#__PURE__*/ _async_to_generator(function*(entryExport) {
+                    const source = yield getSourcePathFromExportPath(config.rootDir, entryExport);
+                    if (!source) return undefined;
+                    if (dtsOnly && !isTypescript(source)) return;
+                    options.exportCondition = {
+                        source,
+                        name: entryExport,
+                        export: packageExports[entryExport]
+                    };
+                    const entry = resolveSourceFile(cwd, source);
+                    const rollupConfig = buildConfig(entry, pkg, options, dtsOnly);
+                    return rollupConfig;
+                }));
+                return (yield Promise.all(configs)).filter((n)=>Boolean(n));
+            });
+            return _buildEntryConfig.apply(this, arguments);
         }
         const bundleOrWatch = (rollupConfig)=>{
             const { input , exportName  } = rollupConfig;
@@ -543,8 +631,8 @@ function _bundle() {
             }
             return runBundle(rollupConfig, buildMetadata);
         };
-        if (!fs.existsSync(entryPath)) {
-            const hasSpecifiedEntryFile = entryPath === '' ? false : fs.statSync(entryPath).isFile();
+        if (!(yield fileExists(entryPath))) {
+            const hasSpecifiedEntryFile = entryPath === '' ? false : (yield fs.stat(entryPath)).isFile();
             if (!hasSpecifiedEntryFile && !hasMultiEntries) {
                 const err = new Error(`Entry file \`${entryPath}\` is not existed`);
                 err.name = 'NOT_EXISTED';
@@ -557,8 +645,9 @@ function _bundle() {
                 options.dts = hasTypings;
             }
             if (hasMultiEntries) {
-                const assetsJobs = buildEntryConfig(packageExports, false).map((rollupConfig)=>bundleOrWatch(rollupConfig));
-                const typesJobs = options.dts ? buildEntryConfig(packageExports, true).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
+                const buildConfigs = yield buildEntryConfig(packageExports, false);
+                const assetsJobs = buildConfigs.map((rollupConfig)=>bundleOrWatch(rollupConfig));
+                const typesJobs = options.dts ? (yield buildEntryConfig(packageExports, true)).map((rollupConfig)=>bundleOrWatch(rollupConfig)) : [];
                 return yield Promise.all(assetsJobs.concat(typesJobs));
             }
         }

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "bunchee",
-  "version": "3.0.0-beta.11",
+  "version": "3.0.0-beta.12",
   "description": "zero config bundler for js/ts/jsx libraries",
   "bin": {
     "bunchee": "./dist/cli.js"
   },
-  "main": "./dist/lib.js",
-  "types": "./dist/lib.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "scripts": {
     "test": "jest --env node",
     "test:update": "TEST_UPDATE_SNAPSHOT=1 yarn test",
     "clean": "rm -rf ./dist",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "yarn clean && yarn build && chmod +x ./dist/cli.js && yarn test",
-    "build:cli": "tsx ./cli.ts ./cli.ts --runtime node -f cjs -o ./dist/cli.js",
-    "build:main": "tsx ./cli.ts ./lib.ts --runtime node -f cjs",
+    "build:cli": "tsx ./src/cli.ts ./src/cli.ts --runtime node -f cjs -o ./dist/cli.js",
+    "build:main": "tsx ./src/cli.ts ./src/index.ts --runtime node -f cjs",
     "build": "yarn build:main && yarn build:cli"
   },
   "type": "commonjs",
@@ -43,15 +43,16 @@
   "dependencies": {
     "@rollup/plugin-commonjs": "24.0.1",
     "@rollup/plugin-json": "6.0.0",
-    "@rollup/plugin-node-resolve": "15.0.1",
-    "@swc/core": "1.3.35",
+    "@rollup/plugin-node-resolve": "15.0.2",
+    "@rollup/plugin-replace": "5.0.2",
+    "@swc/core": "1.3.46",
     "arg": "5.0.2",
     "publint": "0.1.11",
-    "rollup": "3.15.0",
-    "rollup-plugin-dts": "5.1.1",
+    "rollup": "3.20.2",
+    "rollup-plugin-dts": "5.3.0",
     "rollup-plugin-preserve-shebang": "1.0.1",
-    "rollup-plugin-swc3": "0.8.0",
-    "tslib": "2.4.0"
+    "rollup-plugin-swc3": "0.8.1",
+    "tslib": "2.5.0"
   },
   "peerDependencies": {
     "typescript": ">= 3.7.0"
@@ -62,6 +63,7 @@
     }
   },
   "devDependencies": {
+    "@huozhi/testing-package": "1.0.0",
     "@swc/jest": "0.2.22",
     "@types/jest": "29.0.0",
     "jest": "29.0.1",
@@ -74,7 +76,7 @@
       "node_modules"
     ],
     "moduleNameMapper": {
-      "bunchee": "<rootDir>/lib.ts"
+      "bunchee": "<rootDir>/src/index.ts"
     },
     "transform": {
       "^.+\\.(t|j)sx?$": [