@umijs/bundler-esbuild 4.0.0-beta.10

package/README.md

@@ -0,0 +1,3 @@
+# @umijs/bundler-esbuild
+
+See our website [umijs](https://umijs.org) for more information.

package/bin/bundler-esbuild.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/cli');

package/dist/build.d.ts

@@ -0,0 +1,19 @@
+import { Format } from '@umijs/bundler-utils/compiled/esbuild';
+import { IBabelPlugin, IConfig } from './types';
+interface IOpts {
+    cwd: string;
+    entry: Record<string, string>;
+    config: IConfig;
+    mode?: string;
+    onBuildComplete?: Function;
+    clean?: boolean;
+    format?: Format;
+    sourcemap?: boolean | 'inline' | 'external' | 'both';
+    beforeBabelPlugins?: any[];
+    beforeBabelPresets?: any[];
+    extraBabelPlugins?: IBabelPlugin[];
+    extraBabelPresets?: IBabelPlugin[];
+    inlineStyle?: boolean;
+}
+export declare function build(opts: IOpts): Promise<import("@umijs/bundler-utils/compiled/esbuild").BuildResult>;
+export {};

package/dist/build.js

@@ -0,0 +1,61 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const esbuild_1 = require("@umijs/bundler-utils/compiled/esbuild");
+const utils_1 = require("@umijs/utils");
+const path_1 = require("path");
+const alias_1 = __importDefault(require("./plugins/alias"));
+const externals_1 = __importDefault(require("./plugins/externals"));
+const less_1 = __importDefault(require("./plugins/less"));
+const style_1 = require("./plugins/style");
+function build(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const outputPath = opts.config.outputPath || (0, path_1.join)(opts.cwd, 'dist');
+        if (opts.clean) {
+            utils_1.rimraf.sync(outputPath);
+        }
+        return yield (0, esbuild_1.build)({
+            entryPoints: opts.entry,
+            bundle: true,
+            format: opts.format || 'iife',
+            logLevel: 'error',
+            // splitting: true,
+            sourcemap: opts.sourcemap,
+            outdir: outputPath,
+            metafile: true,
+            plugins: [
+                (0, less_1.default)(Object.assign({ modifyVars: opts.config.theme, javascriptEnabled: true }, opts.config.lessLoader)),
+                opts.config.alias && (0, alias_1.default)(addCwdPrefix(opts.config.alias, opts.cwd)),
+                opts.config.externals && (0, externals_1.default)(opts.config.externals),
+                opts.inlineStyle && (0, style_1.inlineStyle)(),
+            ].filter(Boolean),
+            define: {
+                // __dirname sham
+                __dirname: JSON.stringify('__dirname'),
+                'process.env.NODE_ENV': JSON.stringify(opts.mode || 'development'),
+            },
+        });
+    });
+}
+exports.build = build;
+// TODO: move to api.describe({ config: { format } })
+function addCwdPrefix(obj, cwd) {
+    Object.keys(obj).forEach((key) => {
+        if (obj[key].startsWith('.')) {
+            obj[key] = (0, utils_1.winPath)((0, path_1.join)(cwd, obj[key]));
+        }
+    });
+    return obj;
+}

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const esbuild_1 = __importDefault(require("@umijs/bundler-utils/compiled/esbuild"));
+const utils_1 = require("@umijs/utils");
+const assert_1 = __importDefault(require("assert"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const build_1 = require("./build");
+const args = (0, utils_1.yParser)(process.argv.slice(2), {});
+const command = args._[0];
+const cwd = process.cwd();
+const entry = tryPaths([
+    (0, path_1.join)(cwd, 'src/index.tsx'),
+    (0, path_1.join)(cwd, 'src/index.ts'),
+    (0, path_1.join)(cwd, 'index.tsx'),
+    (0, path_1.join)(cwd, 'index.ts'),
+]);
+let config = {};
+const configFile = (0, path_1.join)(cwd, args.config || 'config.ts');
+utils_1.register.register({
+    implementor: esbuild_1.default,
+});
+utils_1.register.clearFiles();
+if ((0, fs_1.existsSync)(configFile)) {
+    config = require(configFile).default;
+}
+Object.assign(config, args);
+if (command === 'build') {
+    (() => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.NODE_ENV = 'production';
+        (0, assert_1.default)(entry, `Build failed: entry not found.`);
+        try {
+            yield (0, build_1.build)({
+                config,
+                cwd,
+                entry: {
+                    [getEntryKey(entry)]: entry,
+                },
+            });
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }))();
+}
+else {
+    error(`Unsupported command ${command}.`);
+}
+function error(msg) {
+    console.error(utils_1.chalk.red(msg));
+}
+function tryPaths(paths) {
+    for (const path of paths) {
+        if ((0, fs_1.existsSync)(path))
+            return path;
+    }
+}
+function getEntryKey(path) {
+    return (0, path_1.basename)(path, (0, path_1.extname)(path));
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './build';

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./build"), exports);

package/dist/plugins/__sample.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '@umijs/bundler-utils/compiled/esbuild';
+export declare function Sample(): Plugin;

package/dist/plugins/__sample.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sample = void 0;
+function Sample() {
+    return { name: '', setup() { } };
+}
+exports.Sample = Sample;

package/dist/plugins/alias.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '@umijs/bundler-utils/compiled/esbuild';
+declare const _default: (options?: Record<string, string>) => Plugin;
+export default _default;

package/dist/plugins/alias.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const enhanced_resolve_1 = __importDefault(require("enhanced-resolve"));
+const fs_1 = require("fs");
+const sortByAffix_1 = require("../utils/sortByAffix");
+const resolver = enhanced_resolve_1.default.create({
+    mainFields: ['module', 'browser', 'main'],
+    extensions: ['.json', '.js', '.jsx', '.ts', '.tsx', '.cjs', '.mjs'],
+    // TODO: support exports
+    exportsFields: [],
+});
+function resolve(context, path) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            resolver(context, path, (err, result) => err ? reject(err) : resolve(result));
+        });
+    });
+}
+// https://esbuild.github.io/plugins/#resolve-callbacks
+exports.default = (options = {}) => {
+    return {
+        name: 'alias',
+        setup({ onResolve }) {
+            const keys = (0, sortByAffix_1.sortByAffix)({ arr: Object.keys(options), affix: '$' });
+            keys.forEach((key) => {
+                let value = options[key];
+                let filter;
+                if (key.endsWith('$')) {
+                    filter = new RegExp(`^${key}`);
+                }
+                else {
+                    filter = new RegExp(`^${key}$`);
+                }
+                onResolve({ filter: filter }, (args) => __awaiter(this, void 0, void 0, function* () {
+                    const path = yield resolve(args.importer, args.path.replace(filter, value));
+                    return {
+                        path,
+                    };
+                }));
+                if (!key.endsWith('/') &&
+                    (0, fs_1.existsSync)(value) &&
+                    (0, fs_1.statSync)(value).isDirectory()) {
+                    const filter = new RegExp(`^${addSlashAffix(key)}`);
+                    onResolve({ filter }, (args) => __awaiter(this, void 0, void 0, function* () {
+                        const path = yield resolve(args.importer, args.path.replace(filter, addSlashAffix(value)));
+                        return {
+                            path,
+                        };
+                    }));
+                }
+            });
+        },
+    };
+};
+function addSlashAffix(key) {
+    if (key.endsWith('/')) {
+        return key;
+    }
+    return `${key}/`;
+}

package/dist/plugins/externals.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from '@umijs/bundler-utils/compiled/esbuild';
+declare const _default: (options?: Record<string, string> | undefined) => Plugin;
+export default _default;

package/dist/plugins/externals.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (options) => {
+    return {
+        name: 'externals',
+        setup({ onLoad, onResolve }) {
+            if (!options || Object.keys(options).length === 0) {
+                return;
+            }
+            Object.keys(options).forEach((key) => {
+                onResolve({ filter: new RegExp(`^${key}$`) }, (args) => ({
+                    path: args.path,
+                    namespace: key,
+                }));
+                onLoad({ filter: /.*/, namespace: key }, () => ({
+                    contents: `module.export=${options[key]}`,
+                    loader: 'js',
+                }));
+            });
+        },
+    };
+};

package/dist/plugins/less.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="less" />
+import { Plugin } from '@umijs/bundler-utils/compiled/esbuild';
+declare const _default: (options?: Less.Options) => Plugin;
+export default _default;

package/dist/plugins/less.js

@@ -0,0 +1,53 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const less_1 = __importDefault(require("less"));
+const path_1 = __importDefault(require("path"));
+exports.default = (options = {}) => {
+    return {
+        name: 'less',
+        setup({ onLoad }) {
+            onLoad({ filter: /\.less$/, namespace: 'file' }, (args) => __awaiter(this, void 0, void 0, function* () {
+                const content = yield fs_1.promises.readFile(args.path, 'utf-8');
+                const dir = path_1.default.dirname(args.path);
+                const filename = path_1.default.basename(args.path);
+                try {
+                    const result = yield less_1.default.render(content, Object.assign(Object.assign({ filename, rootpath: dir }, options), { paths: [...(options.paths || []), dir] }));
+                    return {
+                        contents: result.css,
+                        loader: 'css',
+                        resolveDir: dir,
+                    };
+                }
+                catch (error) {
+                    return {
+                        errors: [
+                            {
+                                text: error.message,
+                                location: {
+                                    namespace: 'file',
+                                    file: error.filename,
+                                    line: error.line,
+                                    column: error.column,
+                                },
+                            },
+                        ],
+                        resolveDir: dir,
+                    };
+                }
+            }));
+        },
+    };
+};

package/dist/plugins/nodeGlobalsPolyfill.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from '@umijs/bundler-utils/compiled/esbuild';
+export declare function nodeGlobalsPolyfill(): Plugin;

package/dist/plugins/nodeGlobalsPolyfill.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeGlobalsPolyfill = void 0;
+function nodeGlobalsPolyfill() {
+    return {
+        name: 'node-globals-polyfill',
+        setup({ initialOptions, onResolve, onLoad }) {
+            onResolve;
+            onLoad;
+            initialOptions.inject || (initialOptions.inject = []);
+        },
+    };
+}
+exports.nodeGlobalsPolyfill = nodeGlobalsPolyfill;

package/dist/plugins/style.d.ts

@@ -0,0 +1,14 @@
+import { Charset, Plugin } from '@umijs/bundler-utils/compiled/esbuild';
+export interface StylePluginOptions {
+    /**
+     * whether to minify the css code.
+     * @default true
+     */
+    minify?: boolean;
+    /**
+     * css charset.
+     * @default 'utf8'
+     */
+    charset?: Charset;
+}
+export declare function inlineStyle({ minify, charset, }?: StylePluginOptions): Plugin;

package/dist/plugins/style.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inlineStyle = void 0;
+// ref: https://github.com/hyrious/esbuild-plugin-style/blob/main/index.ts
+const esbuild_1 = __importDefault(require("@umijs/bundler-utils/compiled/esbuild"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// https://github.com/evanw/esbuild/issues/20#issuecomment-802269745
+function inlineStyle({ minify = true, charset = 'utf8', } = {}) {
+    return {
+        name: 'style',
+        setup({ onResolve, onLoad }) {
+            const cwd = process.cwd();
+            const opt = {
+                logLevel: 'silent',
+                bundle: true,
+                write: false,
+                charset,
+                minify,
+            };
+            onResolve({ filter: /\.css$/, namespace: 'file' }, (args) => {
+                const absPath = path_1.default.join(args.resolveDir, args.path);
+                const relPath = path_1.default.relative(cwd, absPath);
+                const resolved = fs_1.default.existsSync(absPath) ? relPath : args.path;
+                return { path: resolved, namespace: 'style-stub' };
+            });
+            onResolve({ filter: /\.css$/, namespace: 'style-stub' }, (args) => {
+                return { path: args.path, namespace: 'style-content' };
+            });
+            onResolve({ filter: /^__style_helper__$/, namespace: 'style-stub' }, (args) => ({
+                path: args.path,
+                namespace: 'style-helper',
+                sideEffects: false,
+            }));
+            onLoad({ filter: /.*/, namespace: 'style-helper' }, () => __awaiter(this, void 0, void 0, function* () {
+                return ({
+                    contents: `
+          export function injectStyle(text) {
+            if (typeof document !== 'undefined') {
+              var style = document.createElement('style')
+              var node = document.createTextNode(text)
+              style.appendChild(node)
+              document.head.appendChild(style)
+            }
+          }
+        `,
+                });
+            }));
+            onLoad({ filter: /.*/, namespace: 'style-stub' }, (args) => __awaiter(this, void 0, void 0, function* () {
+                return ({
+                    contents: `
+          import { injectStyle } from "__style_helper__"
+          import css from ${JSON.stringify(args.path)}
+          injectStyle(css)
+        `,
+                });
+            }));
+            onLoad({ filter: /.*/, namespace: 'style-content' }, (args) => __awaiter(this, void 0, void 0, function* () {
+                const options = Object.assign({ entryPoints: [args.path] }, opt);
+                const { errors, warnings, outputFiles } = yield esbuild_1.default.build(options);
+                return {
+                    errors,
+                    warnings,
+                    contents: outputFiles[0].text,
+                    loader: 'text',
+                };
+            }));
+        },
+    };
+}
+exports.inlineStyle = inlineStyle;

package/dist/types.d.ts

@@ -0,0 +1,52 @@
+import { TransformOptions } from '@umijs/bundler-utils/compiled/esbuild';
+export declare enum Env {
+    development = "development",
+    production = "production"
+}
+export declare enum JSMinifier {
+    terser = "terser",
+    esbuild = "esbuild"
+}
+export interface ICopy {
+    from: string;
+    to: string;
+}
+export declare type IBabelPlugin = string | [string, {
+    [key: string]: any;
+}];
+export interface IConfig {
+    alias?: Record<string, string>;
+    autoCSSModules?: boolean;
+    autoprefixer?: any;
+    copy?: ICopy[] | string[];
+    define?: {
+        [key: string]: any;
+    };
+    extraBabelPlugins?: IBabelPlugin[];
+    extraBabelPresets?: IBabelPlugin[];
+    extraPostCSSPlugins?: any[];
+    extraVitePlugins?: Plugin[];
+    hash?: boolean;
+    inlineLimit?: number;
+    manifest?: boolean;
+    jsMinifier?: JSMinifier | boolean;
+    jsMinifierOptions?: {
+        [key: string]: any;
+    };
+    lessLoader?: {
+        lessOptions: any;
+    };
+    outputPath?: string;
+    polyfill?: {
+        imports: string[];
+    };
+    postcssLoader?: {
+        postcssOptions: any;
+    };
+    publicPath?: string;
+    svgr?: TransformOptions;
+    targets?: {
+        [key: string]: any;
+    };
+    [key: string]: any;
+}

package/dist/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSMinifier = exports.Env = void 0;
+var Env;
+(function (Env) {
+    Env["development"] = "development";
+    Env["production"] = "production";
+})(Env = exports.Env || (exports.Env = {}));
+var JSMinifier;
+(function (JSMinifier) {
+    JSMinifier["terser"] = "terser";
+    JSMinifier["esbuild"] = "esbuild";
+})(JSMinifier = exports.JSMinifier || (exports.JSMinifier = {}));

package/dist/utils/sortByAffix.d.ts

@@ -0,0 +1,4 @@
+export declare function sortByAffix(opts: {
+    arr: string[];
+    affix: string;
+}): string[];

package/dist/utils/sortByAffix.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortByAffix = void 0;
+function sortByAffix(opts) {
+    return opts.arr.sort((a, b) => {
+        if (a.endsWith(opts.affix) && b.endsWith(opts.affix))
+            return 0;
+        if (a.endsWith(opts.affix))
+            return -1;
+        if (b.endsWith(opts.affix))
+            return 1;
+        else
+            return 0;
+    });
+}
+exports.sortByAffix = sortByAffix;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@umijs/bundler-esbuild",
+  "version": "4.0.0-beta.10",
+  "description": "@umijs/bundler-esbuild",
+  "homepage": "https://github.com/umijs/umi-next/tree/master/packages/bundler-esbuild#readme",
+  "bugs": "https://github.com/umijs/umi-next/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/umijs/umi-next"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "bundler-esbuild": "bin/bundler-esbuild.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "pnpm tsc",
+    "build:deps": "pnpm esno ../../scripts/bundleDeps.ts",
+    "dev": "pnpm build -- --watch"
+  },
+  "dependencies": {
+    "@umijs/bundler-utils": "4.0.0-beta.10",
+    "@umijs/utils": "4.0.0-beta.10",
+    "enhanced-resolve": "5.8.3",
+    "less": "4.1.2"
+  },
+  "devDependencies": {
+    "@types/less": "^3.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "authors": [
+    "chencheng <sorrycc@gmail.com> (https://github.com/sorrycc)"
+  ]
+}