bunchee 2.0.4 → 2.1.2

package/README.md

@@ -70,15 +70,16 @@ Usage: bunchee [options]
 Options:
   -v, --version          output the version number
   -w, --watch            watch src files changes
-  -m, --minify           compress output. false by default
+  -m, --minify           compress output. default: false
   -o, --output <file>    specify output filename
-  -f, --format <format>  specify bundle type: "esm", "cjs", "umd". "esm" by default
+  -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. "es5" by default
-  --runtime <runtime>    build runtime: "nodejs", "browser". "browser" by default
-  --sourcemap            enable sourcemap generation, false by default
+  --target <target>      js features target: swc target es versions. default: es5
+  --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

package/dist/cli.js

@@ -1,20 +1,164 @@
 #!/usr/bin/env node
-var tslib = require('tslib');
 var path = require('path');
-require('fs');
 var arg = require('arg');
+require('fs');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var arg__default = /*#__PURE__*/_interopDefaultLegacy(arg);
 
-process.cwd();
+function exit(err) {
+    logger.error(err);
+    process.exit(1);
+}
+var logger = {
+    log: function log(arg) {
+        console.log(arg);
+    },
+    warn: function warn(arg) {
+        console.log("\x1b[33m" + arg + "\x1b[0m");
+    },
+    error: function error(arg) {
+        console.error("\x1b[31m" + arg + "\x1b[0m");
+    }
+};
+
+var version = "2.1.2";
 
+function asyncGeneratorStep(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 _asyncToGenerator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+var __generator = undefined && undefined.__generator || function(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+};
+var helpMessage = "\nUsage: bunchee [options]\n\nOptions:\n  -v, --version          output the version number\n  -w, --watch            watch src files changes\n  -m, --minify           compress output. default: false\n  -o, --output <file>    specify output filename\n  -f, --format <format>  type of output (esm, amd, cjs, iife, umd, system), default: esm\n  -e, --external <mod>   specify an external dependency\n  -h, --help             output usage information\n  --target <target>      js features target: swc target es versions. default: es5\n  --runtime <runtime>    build runtime (nodejs, browser). default: browser\n  --cwd <cwd>            specify current working directory\n  --sourcemap            enable sourcemap generation, default: false\n  --dts                  determine if need to generate types, default: false\n";
+function help() {
+    logger.log(helpMessage);
+}
 function parseCliArgs(argv) {
     var args;
     args = arg__default["default"]({
         "--cwd": String,
+        "--dts": Boolean,
         "--output": String,
         "--format": String,
         "--watch": Boolean,
@@ -47,6 +191,7 @@ function parseCliArgs(argv) {
         minify: args["--minify"],
         sourcemap: !!args["--sourcemap"],
         cwd: args["--cwd"],
+        dts: args["--dts"],
         help: args["--help"],
         version: args["--version"],
         runtime: args["--runtime"],
@@ -55,72 +200,24 @@ function parseCliArgs(argv) {
     };
     return parsedArgs;
 }
-var logger = {
-    log: function log() {
-        var args = [];
-        for(var _i = 0; _i < arguments.length; _i++){
-            args[_i] = arguments[_i];
-        }
-        console.log.apply(console, args);
-    },
-    warn: function warn() {
-        var args = [];
-        for(var _i = 0; _i < arguments.length; _i++){
-            args[_i] = arguments[_i];
-        }
-        console.log.apply(console, tslib.__spreadArray(tslib.__spreadArray([
-            "\x1b[33m"
-        ], args, false), [
-            "\x1b[0m"
-        ], false));
-    },
-    error: function error() {
-        var args = [];
-        for(var _i = 0; _i < arguments.length; _i++){
-            args[_i] = arguments[_i];
-        }
-        console.error.apply(console, tslib.__spreadArray(tslib.__spreadArray([
-            "\x1b[31m"
-        ], args, false), [
-            "\x1b[0m"
-        ], false));
-    }
-};
-
-var version = "2.0.4";
-
-var helpMessage = '\nUsage: bunchee [options]\n\nOptions:\n  -v, --version          output the version number\n  -w, --watch            watch src files changes\n  -m, --minify           compress output. false by default\n  -o, --output <file>    specify output filename\n  -f, --format <format>  specify bundle type: "esm", "cjs", "umd". "esm" by default\n  -e, --external <mod>   specify an external dependency\n  --target <target>      js features target: swc target es versions. "es5" by default\n  --runtime <runtime>    build runtime: "nodejs", "browser". "browser" by default\n  --sourcemap            enable sourcemap generation, false by default\n  --cwd <cwd>            specify current working directory\n  -h, --help             output usage information\n';
-function help() {
-    console.log(helpMessage);
-}
-function exit(err) {
-    logger.error(err);
-    process.exit(1);
-}
 function run(args) {
-    return tslib.__awaiter(this, void 0, void 0, function() {
-        var source, format, watch, minify, sourcemap, target, runtime, cwd, file, outputConfig, entry, bundle, timeStart, timeEnd, err_1, duration;
-        return tslib.__generator(this, function(_a) {
-            switch(_a.label){
+    return _run.apply(this, arguments);
+}
+function _run() {
+    _run = _asyncToGenerator(function(args) {
+        var source, format, watch, minify, sourcemap, target, runtime, dts, cwd, file, cliArgs, _tmp, entry, bundle, timeStart, timeEnd, err, duration;
+        return __generator(this, function(_state) {
+            switch(_state.label){
                 case 0:
-                    source = args.source, format = args.format, watch = args.watch, minify = args.minify, sourcemap = args.sourcemap, target = args.target, runtime = args.runtime;
+                    source = args.source, format = args.format, watch = args.watch, minify = args.minify, sourcemap = args.sourcemap, target = args.target, runtime = args.runtime, dts = args.dts;
                     cwd = args.cwd || process.cwd();
-                    file = args.file ? path__default["default"].resolve(cwd, args.file) : args.file;
-                    outputConfig = {
-                        file: file,
-                        format: format,
-                        cwd: cwd,
-                        target: target,
-                        runtime: runtime,
-                        external: args.external || [],
-                        watch: !!watch,
-                        minify: !!minify,
-                        sourcemap: sourcemap === false ? false : true
-                    };
+                    file = args.file ? path__default["default"].resolve(cwd, args.file) : undefined;
+                    _tmp = {};
+                    cliArgs = (_tmp.dts = dts, _tmp.file = file, _tmp.format = format, _tmp.cwd = cwd, _tmp.target = target, _tmp.runtime = runtime, _tmp.external = args.external || [], _tmp.watch = !!watch, _tmp.minify = !!minify, _tmp.sourcemap = sourcemap === false ? false : true, _tmp);
                     if (args.version) {
                         return [
                             2,
-                            console.log(version)
+                            logger.log(version)
                         ];
                     }
                     if (args.help) {
@@ -132,9 +229,9 @@ function run(args) {
                     entry = source ? path__default["default"].resolve(cwd, source) : "";
                     bundle = require("./lib").bundle;
                     timeStart = Date.now();
-                    _a.label = 1;
+                    _state.label = 1;
                 case 1:
-                    _a.trys.push([
+                    _state.trys.push([
                         1,
                         3,
                         ,
@@ -142,29 +239,29 @@ function run(args) {
                     ]);
                     return [
                         4,
-                        bundle(entry, outputConfig)
+                        bundle(entry, cliArgs)
                     ];
                 case 2:
-                    _a.sent();
+                    _state.sent();
                     timeEnd = Date.now();
                     return [
                         3,
                         4
                     ];
                 case 3:
-                    err_1 = _a.sent();
-                    if (err_1.name === "NOT_EXISTED") {
+                    err = _state.sent();
+                    if (err.name === "NOT_EXISTED") {
                         help();
                         return [
                             2,
-                            exit(err_1)
+                            exit(err)
                         ];
                     }
-                    throw err_1;
+                    throw err;
                 case 4:
                     duration = timeEnd - timeStart;
                     if (!watch) {
-                        logger.log("✅ Finished in ".concat(duration, " ms"));
+                        logger.log("✨  Finished in " + duration + " ms");
                     }
                     return [
                         2
@@ -172,12 +269,16 @@ function run(args) {
             }
         });
     });
+    return _run.apply(this, arguments);
 }
 function main() {
-    return tslib.__awaiter(this, void 0, void 0, function() {
+    return _main.apply(this, arguments);
+}
+function _main() {
+    _main = _asyncToGenerator(function() {
         var params, error;
-        return tslib.__generator(this, function(_a) {
-            switch(_a.label){
+        return __generator(this, function(_state) {
+            switch(_state.label){
                 case 0:
                     try {
                         params = parseCliArgs(process.argv.slice(2));
@@ -196,12 +297,13 @@ function main() {
                         run(params)
                     ];
                 case 1:
-                    _a.sent();
+                    _state.sent();
                     return [
                         2
                     ];
             }
         });
     });
+    return _main.apply(this, arguments);
 }
 main().catch(exit);

package/dist/lib.d.ts

@@ -1,2 +1,126 @@
-export type { CliArgs, BuncheeRollupConfig } from './src/types';
-export { default as bundle } from './src/bundle';
+import * as url from 'url';
+import * as worker_threads from 'worker_threads';
+import * as _babel_core from '@babel/core';
+
+declare const spread: {
+    globalThis: typeof globalThis;
+    eval(x: string): any;
+    parseInt(string: string, radix?: number | undefined): number;
+    parseFloat(string: string): number;
+    isNaN(number: number): boolean;
+    isFinite(number: number): boolean;
+    decodeURI(encodedURI: string): string;
+    decodeURIComponent(encodedURIComponent: string): string;
+    encodeURI(uri: string): string;
+    encodeURIComponent(uriComponent: string | number | boolean): string;
+    escape(string: string): string;
+    unescape(string: string): string;
+    NaN: number;
+    Infinity: number;
+    Symbol: SymbolConstructor;
+    Object: ObjectConstructor;
+    Function: FunctionConstructor;
+    String: StringConstructor;
+    Boolean: BooleanConstructor;
+    Number: NumberConstructor;
+    Math: Math;
+    Date: DateConstructor;
+    RegExp: RegExpConstructor;
+    Error: ErrorConstructor;
+    EvalError: EvalErrorConstructor;
+    RangeError: RangeErrorConstructor;
+    ReferenceError: ReferenceErrorConstructor;
+    SyntaxError: SyntaxErrorConstructor;
+    TypeError: TypeErrorConstructor;
+    URIError: URIErrorConstructor;
+    JSON: JSON;
+    Array: ArrayConstructor;
+    Promise: PromiseConstructor;
+    ArrayBuffer: ArrayBufferConstructor;
+    DataView: DataViewConstructor;
+    Int8Array: Int8ArrayConstructor;
+    Uint8Array: Uint8ArrayConstructor;
+    Uint8ClampedArray: Uint8ClampedArrayConstructor;
+    Int16Array: Int16ArrayConstructor;
+    Uint16Array: Uint16ArrayConstructor;
+    Int32Array: Int32ArrayConstructor;
+    Uint32Array: Uint32ArrayConstructor;
+    Float32Array: Float32ArrayConstructor;
+    Float64Array: Float64ArrayConstructor;
+    Intl: typeof Intl;
+    Map: MapConstructor;
+    WeakMap: WeakMapConstructor;
+    Set: SetConstructor;
+    WeakSet: WeakSetConstructor;
+    Proxy: ProxyConstructor;
+    Reflect: typeof Reflect;
+    SharedArrayBuffer: SharedArrayBufferConstructor;
+    Atomics: Atomics;
+    BigInt: BigIntConstructor;
+    BigInt64Array: BigInt64ArrayConstructor;
+    BigUint64Array: BigUint64ArrayConstructor;
+    babel: typeof _babel_core;
+    structuredClone<T>(value: T, transfer?: {
+        transfer: readonly worker_threads.TransferListItem[];
+    } | undefined): T;
+    process: NodeJS.Process;
+    console: Console;
+    __filename: string;
+    __dirname: string;
+    require: NodeRequire;
+    module: NodeModule;
+    exports: any;
+    gc: (() => void) | undefined;
+    AbortController: {
+        new (): AbortController;
+        prototype: AbortController;
+    };
+    AbortSignal: {
+        new (): AbortSignal;
+        prototype: AbortSignal;
+    };
+    global: typeof globalThis;
+    spyOn<T_1>(object: T_1, method: keyof T_1): jasmine.Spy;
+    pending(reason?: string | undefined): void;
+    fail(error?: any): never;
+    beforeAll: jest.Lifecycle;
+    beforeEach: jest.Lifecycle;
+    afterAll: jest.Lifecycle;
+    afterEach: jest.Lifecycle;
+    describe: jest.Describe;
+    fdescribe: jest.Describe;
+    xdescribe: jest.Describe;
+    it: jest.It;
+    fit: jest.It;
+    xit: jest.It;
+    test: jest.It;
+    xtest: jest.It;
+    jest: typeof jest;
+    jasmine: typeof jasmine;
+    atob(data: string): string;
+    btoa(data: string): string;
+    Buffer: BufferConstructor;
+    setTimeout: typeof setTimeout;
+    clearTimeout(timeoutId: string | number | NodeJS.Timeout | undefined): void;
+    setInterval: typeof setInterval;
+    clearInterval(intervalId: string | number | NodeJS.Timeout | undefined): void;
+    setImmediate: typeof setImmediate;
+    clearImmediate(immediateId: NodeJS.Immediate | undefined): void;
+    queueMicrotask(callback: () => void): void;
+    URLSearchParams: typeof url.URLSearchParams;
+    URL: typeof url.URL;
+    undefined: undefined;
+};
+declare function loadList(): Promise<number[]>;
+declare const optionalChainFn: {
+    <T>(this: T, thisArg: ThisParameterType<T>): OmitThisParameter<T>;
+    <T_1, A0, A_1 extends any[], R>(this: (this: T_1, arg0: A0, ...args: A_1) => R, thisArg: T_1, arg0: A0): (...args: A_1) => R;
+    <T_2, A0_1, A1, A_2 extends any[], R_1>(this: (this: T_2, arg0: A0_1, arg1: A1, ...args: A_2) => R_1, thisArg: T_2, arg0: A0_1, arg1: A1): (...args: A_2) => R_1;
+    <T_3, A0_2, A1_1, A2, A_3 extends any[], R_2>(this: (this: T_3, arg0: A0_2, arg1: A1_1, arg2: A2, ...args: A_3) => R_2, thisArg: T_3, arg0: A0_2, arg1: A1_1, arg2: A2): (...args: A_3) => R_2;
+    <T_4, A0_3, A1_2, A2_1, A3, A_4 extends any[], R_3>(this: (this: T_4, arg0: A0_3, arg1: A1_2, arg2: A2_1, arg3: A3, ...args: A_4) => R_3, thisArg: T_4, arg0: A0_3, arg1: A1_2, arg2: A2_1, arg3: A3): (...args: A_4) => R_3;
+    <T_5, AX, R_4>(this: (this: T_5, ...args: AX[]) => R_4, thisArg: T_5, ...args: AX[]): (...args: AX[]) => R_4;
+};
+declare class A {
+}
+
+export { A, loadList, optionalChainFn, spread };