@roots/bud-build 5.4.0 → 5.6.1

package/README.md

@@ -24,7 +24,7 @@ yarn add @roots/bud-build --dev
 
 ## Documentation
 
-For more information on utilizing this package [check out our dedicated docs](https://budjs.netlify.app)
+For more information on utilizing this package [check out our dedicated docs](https://bud.js.org)
 
 ## Community
 

package/lib/cjs/Build/config/builder.js

@@ -1,74 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = void 0;
-const bud_support_1 = require("@roots/bud-support");
-const path_1 = require("path");
+const builder_unwrap_1 = require("./builder.unwrap");
 const filenameFormat_1 = require("./filenameFormat");
-const { dirname } = path_1.posix;
 /**
- * Filters framework values and returns a webpack configuration
+ * Initializes configuration builder hooks
+ *
+ * @remarks
+ * All hooks in the `build` namespace are initialized here with
+ * the exception of `build.cache` which is handled in {@link Framework.cache}
  *
  * @param app - the Framework instance
+ * @returns Promise
  *
  * @public
  */
 async function build(app) {
+    /**
+     * App bound unwrap
+     */
+    const unwrap = builder_unwrap_1.unwrap.bind(app);
     app.hooks
-        .async('build', async () => {
-        const entry = await app.hooks.filterAsync('build.entry');
-        const plugins = await app.hooks.filterAsync('build.plugins');
-        const resolve = await app.hooks.filterAsync('build.resolve');
-        return {
-            entry,
-            plugins,
-            resolve,
-            bail: app.hooks.filter('build.bail'),
-            cache: app.hooks.filter('build.cache'),
-            context: app.hooks.filter('build.context'),
-            devtool: app.hooks.filter('build.devtool'),
-            experiments: app.hooks.filter('build.experiments'),
-            externals: app.hooks.filter('build.externals'),
-            infrastructureLogging: app.hooks.filter('build.infrastructureLogging'),
-            mode: app.hooks.filter('build.mode'),
-            module: app.hooks.filter('build.module'),
-            name: app.hooks.filter('build.name'),
-            node: app.hooks.filter('build.node'),
-            output: app.hooks.filter('build.output'),
-            optimization: app.hooks.filter('build.optimization'),
-            parallelism: app.hooks.filter('build.parallelism'),
-            performance: app.hooks.filter('build.performance'),
-            profile: app.hooks.filter('build.profile'),
-            recordsPath: app.hooks.filter('build.recordsPath'),
-            stats: app.hooks.filter('build.stats'),
-            target: app.hooks.filter('build.target'),
-            watch: app.hooks.filter('build.watch'),
-            watchOptions: app.hooks.filter('build.watchOptions'),
-        };
-    })
-        /**
-         * build.bail
-         */
-        .hooks.on('build.bail', () => app.store.get('build.bail'))
-        /**
-         * build.context
-         */
-        .hooks.on('build.context', () => app.path('project'))
-        /**
-         * build.devtool
-         */
-        .hooks.on('build.devtool', () => app.store.get('build.devtool'))
-        /**
-         * build.infrastructureLogging
-         */
-        .hooks.on('build.infrastructureLogging', () => app.store.get('build.infrastructureLogging'))
-        /**
-         * build.mode
-         */
-        .hooks.on('build.mode', () => app.mode)
-        /**
-         * build.module
-         */
+        .on('build.cache', () => app.cache.configuration)
+        .hooks.on('build.context', () => app.context.projectDir)
+        .hooks.on('build.mode', app.mode)
         .hooks.on('build.module', () => ({
+        noParse: app.hooks.filter('build.module.noParse'),
         rules: app.hooks.filter('build.module.rules'),
         unsafeCache: app.hooks.filter('build.module.unsafeCache'),
     }))
@@ -79,48 +36,8 @@ async function build(app) {
         },
         ...app.hooks.filter('build.module.rules.after'),
     ])
-        .hooks.on('build.module.rules.oneOf', () => Object.values(app.build.rules).map(rule => rule.make()))
-        .hooks.on('build.module.rules.before', () => [
-        {
-            test: /\.[cm]?(jsx?|tsx?)$/,
-            parser: {
-                requireEnsure: false,
-            },
-        },
-    ])
-        .hooks.on('build.module.rules.after', () => [])
-        .hooks.on('build.module.unsafeCache', () => app.store.get('build.module.unsafeCache'))
-        /**
-         * build.name
-         */
-        .hooks.on('build.name', () => app.name)
-        /**
-         * build.node
-         */
-        .hooks.on('build.node', () => false)
-        /**
-         * build.optimization
-         */
-        .hooks.on('build.optimization', () => ({
-        emitOnErrors: app.hooks.filter('build.optimization.emitOnErrors'),
-        minimize: app.hooks.filter('build.optimization.minimize'),
-        minimizer: app.hooks.filter('build.optimization.minimizer'),
-        moduleIds: app.hooks.filter('build.optimization.moduleIds'),
-        runtimeChunk: app.hooks.filter('build.optimization.runtimeChunk'),
-        splitChunks: app.hooks.filter('build.optimization.splitChunks'),
-    }))
-        .hooks.on('build.optimization.emitOnErrors', () => app.store.get('build.optimization.emitOnErrors'))
-        .hooks.on('build.optimization.minimize', () => app.store.is('features.minimize', true))
-        .hooks.on('build.optimization.minimizer', () => ['...'])
-        .hooks.on('build.optimization.moduleIds', () => app.store.get('build.optimization.moduleIds'))
-        .hooks.on('build.optimization.removeEmptyChunks', () => app.store.get('build.optimization.removeEmptyChunks'))
-        .hooks.on('build.optimization.runtimeChunk', () => app.store.is('features.runtimeChunk', true))
-        .hooks.on('build.optimization.splitChunks', () => app.store.is('features.splitChunks', true)
-        ? app.store.get('build.optimization.splitChunks')
-        : undefined)
-        /**
-         * build.output
-         */
+        .hooks.on('build.module.rules.oneOf', () => Object.values(app.build.rules).map(rule => rule.toWebpack()))
+        .hooks.on('build.name', app.name)
         .hooks.on('build.output', () => ({
         assetModuleFilename: app.hooks.filter('build.output.assetModuleFilename'),
         chunkFilename: app.hooks.filter('build.output.chunkFilename'),
@@ -132,79 +49,69 @@ async function build(app) {
     }))
         .hooks.on('build.output.assetModuleFilename', () => (0, filenameFormat_1.filenameFormat)(app, '[ext]'))
         .hooks.on('build.output.chunkFilename', () => (0, filenameFormat_1.filenameFormat)(app))
-        .hooks.on('build.output.clean', () => app.store.get('build.output.clean'))
         .hooks.on('build.output.filename', () => (0, filenameFormat_1.filenameFormat)(app))
-        .hooks.on('build.output.path', () => app.path('dist'))
-        .hooks.on('build.output.pathinfo', () => app.store.get('build.output.pathinfo'))
-        .hooks.on('build.output.publicPath', () => app.store.get('build.output.publicPath'))
-        /**
-         * Parallelism
-         */
-        .hooks.on('build.parallelism', () => app.store.get('build.parallelism'))
-        /**
-         * build.performance
-         */
-        .hooks.on('build.performance', () => app.store.get('build.performance'))
-        /**
-         * build.plugins
-         */
+        .hooks.on('build.output.path', () => app.path('@dist'))
+        .hooks.on('build.optimization', () => ({
+        emitOnErrors: app.hooks.filter('build.optimization.emitOnErrors'),
+        minimize: app.hooks.filter('build.optimization.minimize'),
+        minimizer: app.hooks.filter('build.optimization.minimizer'),
+        moduleIds: app.hooks.filter('build.optimization.moduleIds'),
+        runtimeChunk: app.hooks.filter('build.optimization.runtimeChunk'),
+        splitChunks: app.hooks.filter('build.optimization.splitChunks'),
+    }))
         .hooks.async('build.plugins', async () => await app.extensions.make())
-        /**
-         * build.profile
-         */
-        .hooks.on('build.profile', () => app.store.get('build.profile'))
-        /**
-         * build.recordsPath
-         */
-        .hooks.on('build.recordsPath', () => app.path('storage', app.name, `modules.json`))
-        /**
-         * build.resolve
-         */
+        .hooks.on('build.recordsPath', () => app.path(`@storage/${app.name}/modules.json`))
         .hooks.async('build.resolve', async () => {
         const alias = await app.hooks.filterAsync('build.resolve.alias');
-        const extensions = app.hooks.filter('build.resolve.extensions');
+        const extensions = Array.from(app.hooks.filter('build.resolve.extensions'));
         const modules = await app.hooks.filterAsync('build.resolve.modules');
         return { alias, extensions, modules };
     })
-        .hooks.async('build.resolve.alias', async () => ({}))
         .hooks.async('build.resolve.modules', async (value) => {
-        const budPath = dirname(await bud_support_1.pkgUp.pkgUp({
-            cwd: require.resolve('@roots/bud'),
-        }));
-        const peersPath = budPath
-            .split('/')
-            .splice(0, budPath.split('/').length - 2)
-            .join('/');
-        return [
-            ...new Set([
-                ...(value ?? []),
-                app.hooks.filter('location.src'),
-                app.hooks.filter('location.modules'),
-                peersPath,
-                ...(app.project?.get('resolve') ?? []),
-                ...(app.root?.project.get('resolve') ?? []),
-            ]),
-        ];
+        return Array.from(new Set([
+            ...(value ?? []),
+            app.hooks.filter('location.@src'),
+            app.hooks.filter('location.@modules'),
+        ]));
     })
-        .hooks.on('build.resolve.extensions', () => app.store.get('build.resolve.extensions'))
-        /**
-         * build.stats
-         */
-        .hooks.on('build.stats', () => app.store.get('build.stats'))
-        /**
-         * build.target
-         */
         .hooks.on('build.target', () => app.project.has('manifest.browserslist') &&
         app.project.isArray('manifest.browserslist')
-        ? `browserslist:${app.path('project', 'package.json')}`
+        ? `browserslist:${app.path('package.json')}`
         : undefined)
-        /**
-         * build.watch
-         */
-        .hooks.on('build.watch', () => app.store.get('build.watch'))
-        /**
-         * build.watchOptions
-         */
-        .hooks.on('build.watchOptions', () => app.store.get('build.watchOptions'));
+        .hooks.on('build.infrastructureLogging', () => ({
+        console: app.hooks.filter('build.infrastructureLogging.console'),
+    }));
+    /**
+     * Safe
+     */
+    app.hooks
+        .on('build.bail', unwrap('build.bail'))
+        .hooks.on('build.devtool', unwrap('build.devtool'))
+        .hooks.on('build.loader', unwrap('build.loader'))
+        .hooks.on('build.module.rules.before', unwrap('build.module.rules.before'))
+        .hooks.on('build.module.rules.after', unwrap('build.module.rules.after'))
+        .hooks.on('build.module.unsafeCache', unwrap('build.module.unsafeCache'))
+        .hooks.on('build.module.noParse', unwrap('build.module.noParse'))
+        .hooks.on('build.infrastructureLogging.level', unwrap('build.infrastructureLogging.level'))
+        .hooks.on('build.infrastructureLogging.console', unwrap('build.infrastructureLogging.console'))
+        .hooks.on('build.node', unwrap('build.node'))
+        .hooks.on('build.optimization.emitOnErrors', unwrap('build.optimization.emitOnErrors'))
+        .hooks.on('build.optimization.minimize', unwrap('build.optimization.minimize'))
+        .hooks.on('build.optimization.minimizer', unwrap('build.optimization.minimizer'))
+        .hooks.on('build.optimization.moduleIds', unwrap('build.optimization.moduleIds'))
+        .hooks.on('build.optimization.removeEmptyChunks', unwrap('build.optimization.removeEmptyChunks'))
+        .hooks.on('build.optimization.runtimeChunk', unwrap('build.optimization.runtimeChunk'))
+        .hooks.on('build.optimization.splitChunks', unwrap('build.optimization.splitChunks'))
+        .hooks.on('build.output.clean', unwrap('build.output.clean'))
+        .hooks.on('build.output.pathinfo', unwrap('build.output.pathinfo'))
+        .hooks.on('build.output.publicPath', unwrap('build.output.publicPath', 'auto'))
+        .hooks.on('build.parallelism', unwrap('build.parallelism'))
+        .hooks.on('build.performance', unwrap('build.performance'))
+        .hooks.on('build.profile', unwrap('build.profile'))
+        .hooks.async('build.resolve.alias', unwrap('build.resolve.alias'))
+        .hooks.on('build.resolve.extensions', unwrap('build.resolve.extensions'))
+        .hooks.on('build.stats', unwrap('build.stats'))
+        .hooks.on('build.watch', unwrap('build.watch'))
+        .hooks.on('build.watchOptions', unwrap('build.watchOptions'));
 }
 exports.build = build;

package/lib/cjs/Build/config/builder.unwrap.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrap = void 0;
+const bud_support_1 = require("@roots/bud-support");
+const { isUndefined } = bud_support_1.lodash;
+/**
+ * Unwrap initialValue
+ *
+ * @remarks
+ * Returns the initializing value for a hook
+ * If the value is available from {@link Framework.store}, the store value is used.
+ * Otherwise, it will return the fallback value (if supplied)
+ *
+ * @param this - Application
+ * @param key - store key
+ * @param fallback - fallback value
+ * @returns hook function
+ *
+ * @public
+ */
+function unwrap(key, fallback) {
+    return (value) => {
+        const initValue = this.store.has(key)
+            ? this.maybeCall(this.store.get(key))
+            : value;
+        if (!isUndefined(initValue)) {
+            return initValue;
+        }
+        if (!isUndefined(fallback)) {
+            return fallback;
+        }
+        return undefined;
+    };
+}
+exports.unwrap = unwrap;

package/lib/cjs/Build/index.js

@@ -24,26 +24,33 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 bud_framework_1 = require("@roots/bud-framework");
+const Framework = __importStar(require("@roots/bud-framework"));
 const bud_support_1 = require("@roots/bud-support");
-const index_1 = require("../Rule/index");
-const config = __importStar(require("./config/index"));
-const items_1 = __importDefault(require("./items"));
-const loaders_1 = __importDefault(require("./loaders"));
+const lodash_1 = require("lodash");
+const Item_1 = require("../Item");
+const Loader_1 = require("../Loader");
+const Rule_1 = require("../Rule");
+const config = __importStar(require("./config"));
+const items = __importStar(require("./items"));
+const loaders = __importStar(require("./loaders"));
 const rules = __importStar(require("./rules"));
-const { isNull, isUndefined } = bud_support_1.lodash;
+const { isUndefined } = bud_support_1.lodash;
 const { ensureFile, writeFile } = bud_support_1.fs;
 /**
  * Webpack configuration builder class
  *
  * @public
  */
-class Build extends bud_framework_1.Service {
+class Build extends Framework.Service {
+    constructor() {
+        super(...arguments);
+        /**
+         * @public
+         */
+        this.config = {};
+    }
     /**
      * Service booted event
      *
@@ -51,7 +58,10 @@ class Build extends bud_framework_1.Service {
      * @decorator `@bind`
      */
     async registered() {
-        this.app.hooks.on('event.build.make.after', this.writeFinalConfig);
+        this.app.hooks
+            .action('event.build.before', async (app) => app.time(`build.make`))
+            .hooks.action('event.build.after', async (app) => app.timeEnd(`build.make`))
+            .hooks.action('event.build.after', this.writeFinalConfig);
     }
     /**
      * Make webpack configuration
@@ -60,28 +70,58 @@ class Build extends bud_framework_1.Service {
      * @decorator `@bind`
      */
     async make() {
-        await this.app.hooks.filterAsync('event.build.make.before', this.app);
-        const build = await this.app.hooks.filterAsync('build');
-        if (!build) {
-            throw new Error('Configuration could not be processed');
-        }
-        this.config = await this.app.hooks.filterAsync('event.build.override', Object.entries(build).reduce((all, [key, value]) => {
-            if (isUndefined(value) || isNull(value)) {
-                this.log(`warn`, {
-                    message: `build.make: excluding ${key}`,
-                    suffix: `value is undefined`,
-                });
-                return all;
-            }
-            this.app.dump(value, {
-                prefix: `${bud_support_1.chalk.bgBlue(this.app.name)} config.${key}`,
-                maxDepth: 2,
-            });
-            return { ...all, [key]: value };
-        }, {}));
-        await this.app.hooks.filterAsync('event.build.make.after', async () => null);
+        await this.app.hooks.fire('event.build.before');
+        await Promise.all([
+            ['entry', true],
+            ['plugins', true],
+            ['resolve', true],
+            ['bail'],
+            ['cache'],
+            ['context'],
+            ['devtool'],
+            ['experiments'],
+            ['externals'],
+            ['infrastructureLogging'],
+            ['loader'],
+            ['mode'],
+            ['module'],
+            ['name'],
+            ['node'],
+            ['output'],
+            ['optimization'],
+            ['parallelism'],
+            ['performance'],
+            ['profile'],
+            ['recordsPath'],
+            ['stats'],
+            ['target'],
+            ['watch'],
+            ['watchOptions'],
+        ]
+            .map(this.memoMap)
+            .filter(Boolean)
+            .map(this.memoMapValue));
+        await this.app.hooks.fire('event.build.after');
         return this.config;
     }
+    memoMap(...args) {
+        const [[key, ...rest]] = args;
+        if (!this.app.hooks.has(`build.${key}`))
+            return false;
+        const type = rest.length && rest.shift() ? 'async' : 'sync';
+        const count = this.app.hooks.count(`build.${key}`);
+        return [key, type, count];
+    }
+    async memoMapValue([propKey, type, _count]) {
+        const propValue = type == 'async'
+            ? await this.app.hooks.filterAsync(`build.${propKey}`)
+            : this.app.hooks.filter(`build.${propKey}`);
+        if (isUndefined(propValue))
+            return;
+        Object.assign(this.config, {
+            [propKey]: propValue,
+        });
+    }
     /**
      * Service register event
      *
@@ -95,7 +135,7 @@ class Build extends bud_framework_1.Service {
         });
         Object.assign(this, {
             loaders: this.app
-                .container(loaders_1.default)
+                .container(loaders)
                 .getEntries()
                 .reduce(reducer, this.loaders),
             rules: this.app
@@ -103,7 +143,7 @@ class Build extends bud_framework_1.Service {
                 .getEntries()
                 .reduce(reducer, this.rules),
             items: this.app
-                .container(items_1.default)
+                .container(items)
                 .getEntries()
                 .reduce(reducer, this.items),
         });
@@ -113,29 +153,82 @@ class Build extends bud_framework_1.Service {
      * Set a rule
      *
      * @param name - rule key
-     * @param constructorProperties - rule constructor properties
+     * @param options - rule constructor properties
      * @returns the rule
      *
      * @public
      * @decorator `@bind`
      */
-    setRule(name, constructorProperties) {
-        Object.assign(this.rules, {
-            [name]: this.makeRule(constructorProperties),
-        });
-        return this.rules[name];
+    setRule(name, options) {
+        Object.assign(this.rules, { [name]: this.makeRule(options) });
+        return this;
+    }
+    /**
+     * Make a rule
+     *
+     * @param options - rule constructor properties
+     * @returns the rule
+     *
+     * @public
+     * @decorator `@bind`
+     */
+    makeRule(options) {
+        return new Rule_1.Rule(() => this.app, options);
+    }
+    /**
+     * Set a rule
+     *
+     * @param name - rule key
+     * @param options - rule constructor properties
+     * @returns the rule
+     *
+     * @public
+     * @decorator `@bind`
+     */
+    setLoader(name, options) {
+        Object.assign(this.loaders, { [name]: this.makeLoader(options) });
+        return this;
+    }
+    /**
+     * Make a rule
+     *
+     * @param options - rule constructor properties
+     * @returns the rule
+     *
+     * @public
+     * @decorator `@bind`
+     */
+    makeLoader(options) {
+        return new Loader_1.Loader(() => this.app, options);
+    }
+    /**
+     * Set a rule
+     *
+     * @param name - rule key
+     * @param options - rule constructor properties
+     * @returns the rule
+     *
+     * @public
+     * @decorator `@bind`
+     */
+    setItem(name, options) {
+        const processedOptions = (0, lodash_1.isFunction)(options)
+            ? options(this.makeItem())
+            : this.makeItem(options);
+        Object.assign(this.items, { [name]: processedOptions });
+        return this;
     }
     /**
      * Make a rule
      *
-     * @param constructorProperties - rule constructor properties
+     * @param options - rule constructor properties
      * @returns the rule
      *
      * @public
      * @decorator `@bind`
      */
-    makeRule(constructorProperties) {
-        return new index_1.Rule(this.app, constructorProperties);
+    makeItem(options) {
+        return new Item_1.Item(() => this.app, options);
     }
     /**
      * Write final configuration to storage directory
@@ -145,17 +238,12 @@ class Build extends bud_framework_1.Service {
      */
     async writeFinalConfig() {
         try {
-            const filePath = this.app.path('storage', this.config.name, 'webpack.config.js');
-            this.log('log', {
-                message: `writing webpack dump to disk`,
-                suffix: filePath,
-            });
+            const filePath = this.app.path(`@storage/${this.config.name}/webpack.config.js`);
             await ensureFile(filePath);
             await writeFile(filePath, `module.exports = ${this.app.json.stringify(this.config, null, 2)}`);
         }
         catch (error) {
-            this.log('error', `failed to write webpack.config.json`);
-            this.log(`error`, error);
+            this.app.error(`failed to write webpack.config.json`);
         }
     }
 }
@@ -165,6 +253,13 @@ __decorate([
 __decorate([
     bud_support_1.bind
 ], Build.prototype, "make", null);
+__decorate([
+    bud_support_1.bind
+], Build.prototype, "memoMap", null);
+__decorate([
+    bud_support_1.bind,
+    (0, bud_support_1.memo)()
+], Build.prototype, "memoMapValue", null);
 __decorate([
     bud_support_1.bind
 ], Build.prototype, "register", null);
@@ -174,6 +269,18 @@ __decorate([
 __decorate([
     bud_support_1.bind
 ], Build.prototype, "makeRule", null);
+__decorate([
+    bud_support_1.bind
+], Build.prototype, "setLoader", null);
+__decorate([
+    bud_support_1.bind
+], Build.prototype, "makeLoader", null);
+__decorate([
+    bud_support_1.bind
+], Build.prototype, "setItem", null);
+__decorate([
+    bud_support_1.bind
+], Build.prototype, "makeItem", null);
 __decorate([
     bud_support_1.bind
 ], Build.prototype, "writeFinalConfig", null);