@roots/bud-build 5.3.2 → 5.6.0

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const builder_unwrap_1 = require("./builder.unwrap");
+const filenameFormat_1 = require("./filenameFormat");
+/**
+ * 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
+        .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'),
+    }))
+        .hooks.on('build.module.rules', () => [
+        ...app.hooks.filter('build.module.rules.before'),
+        {
+            oneOf: app.hooks.filter('build.module.rules.oneOf'),
+        },
+        ...app.hooks.filter('build.module.rules.after'),
+    ])
+        .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'),
+        clean: app.hooks.filter('build.output.clean'),
+        filename: app.hooks.filter('build.output.filename'),
+        path: app.hooks.filter('build.output.path'),
+        pathinfo: app.hooks.filter('build.output.pathinfo'),
+        publicPath: app.hooks.filter('build.output.publicPath'),
+    }))
+        .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.filename', () => (0, filenameFormat_1.filenameFormat)(app))
+        .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())
+        .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 = 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.modules', async (value) => {
+        return Array.from(new Set([
+            ...(value ?? []),
+            app.hooks.filter('location.@src'),
+            app.hooks.filter('location.@modules'),
+        ]));
+    })
+        .hooks.on('build.target', () => app.project.has('manifest.browserslist') &&
+        app.project.isArray('manifest.browserslist')
+        ? `browserslist:${app.path('package.json')}`
+        : undefined)
+        .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/config/filenameFormat.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filenameFormat = void 0;
+/**
+ * Filename
+ *
+ * @param app - Framework
+ * @param ext - Filename extension
+ *
+ * @returns filename format
+ *
+ * @public
+ */
+const filenameFormat = (app, ext) => app.store.is('features.hash', true)
+    ? app.store.get('hashFormat').concat(ext ?? '.js')
+    : app.store.get('fileFormat').concat(ext ?? '.js');
+exports.filenameFormat = filenameFormat;

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

@@ -0,0 +1,24 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = void 0;
+const builder = __importStar(require("./builder"));
+exports.builder = builder;

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 lodash_1 = require("lodash");
+const Item_1 = require("../Item");
+const Loader_1 = require("../Loader");
 const Rule_1 = require("../Rule");
-const config_1 = require("./config");
-const items_1 = __importDefault(require("./items"));
-const loaders_1 = __importDefault(require("./loaders"));
+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,39 +143,92 @@ 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),
         });
-        await (0, config_1.config)(this.app);
+        await config.builder.build(this.app);
     }
     /**
      * 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 Rule_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 = (${(0, bud_support_1.prettyFormat)(this.config)})`);
+            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);