@roots/bud-build 6.13.0 → 6.14.0

package/lib/config/experiments.js

@@ -1,3 +1,7 @@
-export const experiments = async ({ hooks }) => hooks.filter(`build.experiments`, {
+export const experiments = async ({ hooks, isDevelopment, }) => hooks.filter(`build.experiments`, {
     backCompat: false,
+    lazyCompilation: isDevelopment
+        ? { entries: false, imports: true }
+        : false,
+    topLevelAwait: true,
 });

package/lib/config/index.d.ts

@@ -1,5 +1,5 @@
 import type { Bud } from '@roots/bud-framework';
-import type { Configuration } from '@roots/bud-support/webpack';
+import type { Configuration } from '@roots/bud-framework/config';
 import { bail } from './bail.js';
 import { cache } from './cache.js';
 import { context } from './context.js';

package/lib/config/infrastructureLogging.js

@@ -1,19 +1,19 @@
-import logger from '@roots/bud-support/utilities/logger';
+import logger from '@roots/bud-support/logger';
 export const infrastructureLogging = async (bud) => bud.hooks.filter(`build.infrastructureLogging`, {
     console: bud.hooks.filter(`build.infrastructureLogging.console`, {
         ...console,
-        log: (...args) => {
-            logger.scope(`webpack`).log(...args);
-        },
-        warn: (...args) => {
-            logger.scope(`webpack`).info(...args);
-        },
         error: (...args) => {
             logger.scope(`webpack`).error(...args);
         },
         info: (...args) => {
             logger.scope(`webpack`).info(...args);
         },
+        log: (...args) => {
+            logger.scope(`webpack`).log(...args);
+        },
+        warn: (...args) => {
+            logger.scope(`webpack`).info(...args);
+        },
     }),
     level: bud.hooks.filter(`build.infrastructureLogging.level`, `log`),
 });

package/lib/config/module.js

@@ -6,9 +6,9 @@ export const module = async ({ build: { rules }, hooks: { filter }, path, }) =>
 const getRules = ({ filter, path, rules }) => [
     ...filter(`build.module.rules.before`, [
         {
-            test: filter(`pattern.js`),
             include: [path(`@src`)],
             parser: { requireEnsure: false },
+            test: filter(`pattern.js`),
         },
     ]),
     {

package/lib/config/optimization.js

@@ -6,15 +6,15 @@ export const optimization = async ({ hooks: { filter }, isDevelopment, isProduct
     minimizer: filter(`build.optimization.minimizer`, []),
     moduleIds: filter(`build.optimization.moduleIds`, `named`),
     nodeEnv: filter(`build.optimization.nodeEnv`, mode),
-    removeEmptyChunks: filter(`build.optimization.removeEmptyChunks`, isProduction),
+    providedExports: filter(`build.optimization.providedExports`, isProduction),
     /**
      * Will be new default in webpack 6
      * @see {@link https://webpack.js.org/configuration/optimization/#optimizationremoveavailablemodules}
      */
     removeAvailableModules: filter(`build.optimization.removeAvailableModules`, false),
+    removeEmptyChunks: filter(`build.optimization.removeEmptyChunks`, isProduction),
     runtimeChunk: filter(`build.optimization.runtimeChunk`, `single`),
     sideEffects: filter(`build.optimization.sideEffects`, isProduction),
     splitChunks: filter(`build.optimization.splitChunks`, false),
-    providedExports: filter(`build.optimization.providedExports`, isProduction),
     usedExports: filter(`build.optimization.usedExports`, isProduction),
 });

package/lib/config/output/index.js

@@ -1,17 +1,22 @@
 import { isMjs } from '../../helpers/isMjs.js';
 import { assetModuleFilename } from './assetModuleFilename.js';
-import { chunkFilename } from './chunkFilename.js';
 import { filename } from './filename.js';
 export const output = async ({ hooks: { filter }, isProduction, path, relPath, }) => filter(`build.output`, {
     assetModuleFilename: assetModuleFilename({ filter, relPath }),
-    chunkFilename: chunkFilename({ filter, relPath }),
+    /**
+     * This should be kept undefined as documented here:
+     * {@see https://webpack.js.org/plugins/split-chunks-plugin/#splitchunkscachegroupscachegroupfilename}
+     */
+    // chunkFilename: chunkFilename({filter, relPath}),
     clean: filter(`build.output.clean`, isProduction),
     environment: filter(`build.output.environment`, undefined),
     filename: filename({ filter, relPath }),
+    hashFunction: filter(`build.output.hashFunction`, `xxhash64`),
+    iife: filter(`build.output.iife`, undefined),
     module: filter(`build.output.module`, false),
     path: filter(`build.output.path`, path(`@dist`)),
     pathinfo: filter(`build.output.pathinfo`, false),
     publicPath: filter(`build.output.publicPath`, `auto`),
-    scriptType: filter(`build.output.scriptType`, isMjs(filter) ? `module` : false),
+    scriptType: filter(`build.output.scriptType`, isMjs(filter) ? `module` : `text/javascript`),
     uniqueName: filter(`build.output.uniqueName`, `@roots/bud`),
 });

package/lib/config/parallelism.js

@@ -1,2 +1,9 @@
 import { cpus } from 'node:os';
-export const parallelism = async ({ hooks }) => hooks.filter(`build.parallelism`, 10 * Math.max(cpus().length - 1, 1));
+export const parallelism = async ({ hooks, root, }) => {
+    const factor = 10;
+    const procs = Math.min(cpus().length - 1, 1);
+    const comps = root.hasChildren
+        ? Math.min(Object.keys(root.children).length)
+        : 1;
+    return hooks.filter(`build.parallelism`, (procs * factor) / comps);
+};

package/lib/config/resolve.js

@@ -1,3 +1,4 @@
+import isString from '@roots/bud-support/lodash/isString';
 export const resolve = async (bud) => {
     return await bud.hooks.filterAsync(`build.resolve`, {
         alias: {
@@ -12,7 +13,7 @@ export const resolve = async (bud) => {
         modules: await bud.hooks.filterAsync(`build.resolve.modules`, [
             bud.hooks.filter(`location.@src`),
             bud.hooks.filter(`location.@modules`),
-        ]),
+        ].filter(v => isString(v) && v.length > 0)),
         /**
          * Leave `undefined` to use webpack default (true in dev, false in production)
          */

package/lib/config/resolveLoader.js

@@ -1,3 +1,11 @@
-export const resolveLoader = async ({ hooks }) => hooks.filter(`build.resolveLoader`, {
-    alias: hooks.filter(`build.resolveLoader.alias`, {}),
+export const resolveLoader = async ({ hooks, module, }) => hooks.filter(`build.resolveLoader`, {
+    alias: hooks.filter(`build.resolveLoader.alias`, {
+        'css-loader': await module.resolve(`@roots/bud-support/css-loader`),
+        'file-loader': await module.resolve(`@roots/bud-support/file-loader`),
+        'html-loader': await module.resolve(`@roots/bud-support/html-loader`),
+        json5: await module.resolve(`@roots/bud-support/json5`),
+        'mini-svg-data-uri': await module.resolve(`mini-svg-data-uri`),
+        'style-loader': await module.resolve(`@roots/bud-support/style-loader`),
+        toml: await module.resolve(`@roots/bud-support/toml`),
+    }),
 });

package/lib/config/snapshot.js

@@ -1,9 +1,9 @@
 export const snapshot = async ({ env, hooks, path }) => hooks.filter(`build.snapshot`, {
+    buildDependencies: hooks.filter(`build.snapshot.buildDependencies`, env.isTrue(`CI`) ? { hash: true } : { timestamp: true }),
     immutablePaths: hooks.filter(`build.snapshot.immutablePaths`, []),
     managedPaths: hooks.filter(`build.snapshot.managedPaths`, [
         ...new Set([path(`@modules`)]),
     ]),
-    buildDependencies: hooks.filter(`build.snapshot.buildDependencies`, env.isTrue(`CI`) ? { hash: true } : { timestamp: true }),
     module: hooks.filter(`build.snapshot.module`, env.isTrue(`CI`) ? { hash: true } : { timestamp: true }),
     resolve: hooks.filter(`build.snapshot.resolve`, env.isTrue(`CI`) ? { hash: true } : { timestamp: true }),
     resolveBuildDependencies: hooks.filter(`build.snapshot.resolveBuildDependencies`, env.isTrue(`CI`) ? { hash: true } : { timestamp: true }),

package/lib/config/stats.js

@@ -2,13 +2,16 @@ export const stats = async (app) => app.hooks.filter(`build.stats`, app.isProduc
     ? {
         all: false,
         assets: true,
+        assetsSort: `size`,
+        builtAt: false,
         children: false,
+        chunks: false,
         entrypoints: true,
         errors: true,
         errorsCount: true,
         hash: true,
-        outputPath: true,
         modules: true,
+        outputPath: true,
         timings: true,
         warnings: true,
         warningsCount: true,

package/lib/handlers/index.d.ts

@@ -6,10 +6,10 @@ import { register } from './register.js';
 import { rules } from './rules/index.js';
 export interface Props {
     filter: Bud[`hooks`][`filter`];
+    isProduction: Bud[`isProduction`];
     makeItem: Bud[`build`][`makeItem`];
     makeLoader: Bud[`build`][`makeLoader`];
     makeRule: Bud[`build`][`makeRule`];
-    isProduction: Bud[`isProduction`];
     path: Bud[`path`];
     resolve: Bud[`module`][`resolve`];
 }

package/lib/handlers/items/items.d.ts

@@ -33,13 +33,9 @@ export declare const minicss: Factory<Item>;
  */
 export declare const raw: Factory<Item>;
 /**
- * File loader
+ * file-loader
  */
 export declare const file: Factory<Item>;
-/**
- * Xml loader
- */
-export declare const xml: Factory<Item>;
 /**
  * Yml loader
  */

package/lib/handlers/items/items.js

@@ -55,13 +55,9 @@ export const minicss = async ({ makeItem }) => makeItem()
  */
 export const raw = async ({ makeItem }) => makeItem().setLoader(`raw`).setIdent(`raw`);
 /**
- * File loader
+ * file-loader
  */
 export const file = async ({ makeItem }) => makeItem().setLoader(`file`).setIdent(`file`);
-/**
- * Xml loader
- */
-export const xml = async ({ makeItem }) => makeItem().setLoader(`xml`).setIdent(`xml`);
 /**
  * Yml loader
  */

package/lib/handlers/loaders/loaders.d.ts

@@ -7,5 +7,4 @@ export declare const html: Factory<Loader>;
 export declare const remark: Factory<Loader>;
 export declare const minicss: Factory<Loader>;
 export declare const style: Factory<Loader>;
-export declare const xml: Factory<Loader>;
 export declare const yml: Factory<Loader>;

package/lib/handlers/loaders/loaders.js

@@ -6,5 +6,4 @@ export const html = async ({ makeLoader, resolve }) => makeLoader(await resolve(
 export const remark = async ({ makeLoader, resolve }) => makeLoader(await resolve(`@roots/bud-support/remark-loader`, import.meta.url));
 export const minicss = async ({ makeLoader, resolve }) => makeLoader(MiniCss.loader);
 export const style = async ({ makeLoader, resolve }) => makeLoader(await resolve(`@roots/bud-support/style-loader`, import.meta.url));
-export const xml = async ({ makeLoader, resolve }) => makeLoader(await resolve(`@roots/bud-support/xml-loader`, import.meta.url));
 export const yml = async ({ makeLoader, resolve }) => makeLoader(await resolve(`@roots/bud-support/yml-loader`, import.meta.url));

package/lib/handlers/register.js

@@ -17,12 +17,12 @@ export async function register(bud) {
         : bud.build.items.style;
     Object.entries(rules).map(makeRegister(bud, bud.build.setRule));
 }
-export const makeRegister = ({ build, hooks, isProduction, path, module: { resolve } }, setRule) => async ([key, factory]) => setRule(key, await factory({
+export const makeRegister = ({ build, hooks, isProduction, module: { resolve }, path }, setRule) => async ([key, factory]) => setRule(key, await factory({
     filter: hooks.filter,
+    isProduction,
     makeItem: build.makeItem,
     makeLoader: build.makeLoader,
     makeRule: build.makeRule,
-    isProduction,
     path,
     resolve,
 }));

package/lib/handlers/rules/csv.js

@@ -1,4 +1,4 @@
-export const csv = async ({ makeRule, path, filter }) => makeRule()
+export const csv = async ({ filter, makeRule, path }) => makeRule()
     .setInclude([path()])
     .setTest(() => filter(`pattern.csv`))
     .setUse([`csv`]);

package/lib/handlers/rules/index.d.ts

@@ -1,18 +1,17 @@
 export declare const rules: {
-    toml: import("../index.js").Factory<import("../../rule/index.js").Rule>;
-    xml: import("../index.js").Factory<import("../../rule/index.js").Rule>;
+    css: import("../index.js").Factory<import("../../rule/index.js").Rule>;
+    cssModule: import("../index.js").Factory<import("../../rule/index.js").Rule>;
     csv: import("../index.js").Factory<import("../../rule/index.js").Rule>;
-    yml: import("../index.js").Factory<import("../../rule/index.js").Rule>;
-    html: import("../index.js").Factory<import("../../rule/index.js").Rule>;
-    json: import("../index.js").Factory<import("../../rule/index.js").Rule>;
     font: import("../index.js").Factory<import("../../rule/index.js").Rule>;
-    svg: import("../index.js").Factory<import("../../rule/index.js").Rule>;
-    webp: import("../index.js").Factory<import("../../rule/index.js").Rule>;
+    html: import("../index.js").Factory<import("../../rule/index.js").Rule>;
     image: import("../index.js").Factory<import("../../rule/index.js").Rule>;
     inlineFont: import("../index.js").Factory<import("../../rule/index.js").Rule>;
-    inlineSvg: import("../index.js").Factory<import("../../rule/index.js").Rule>;
     inlineImage: import("../index.js").Factory<import("../../rule/index.js").Rule>;
-    cssModule: import("../index.js").Factory<import("../../rule/index.js").Rule>;
-    css: import("../index.js").Factory<import("../../rule/index.js").Rule>;
+    inlineSvg: import("../index.js").Factory<import("../../rule/index.js").Rule>;
     js: import("../index.js").Factory<import("../../rule/index.js").Rule>;
+    json: import("../index.js").Factory<import("../../rule/index.js").Rule>;
+    svg: import("../index.js").Factory<import("../../rule/index.js").Rule>;
+    toml: import("../index.js").Factory<import("../../rule/index.js").Rule>;
+    webp: import("../index.js").Factory<import("../../rule/index.js").Rule>;
+    yml: import("../index.js").Factory<import("../../rule/index.js").Rule>;
 };

package/lib/handlers/rules/index.js

@@ -12,23 +12,21 @@ import { inlineSvg } from './svg.inline.js';
 import { svg } from './svg.js';
 import { toml } from './toml.js';
 import { webp } from './webp.js';
-import { xml } from './xml.js';
 import { yml } from './yml.js';
 export const rules = {
-    toml,
-    xml,
+    css,
+    cssModule,
     csv,
-    yml,
-    html,
-    json,
     font,
-    svg,
-    webp,
+    html,
     image,
     inlineFont,
-    inlineSvg,
     inlineImage,
-    cssModule,
-    css,
+    inlineSvg,
     js,
+    json,
+    svg,
+    toml,
+    webp,
+    yml,
 };

package/lib/index.d.ts

@@ -4,10 +4,10 @@
  * @see https://bud.js.org
  * @see https://github.com/roots/bud
  */
-import './types.js';
 import { Item } from './item/index.js';
 import { Loader } from './loader/index.js';
 import { Rule } from './rule/index.js';
 import { Build } from './service.js';
+import './types.js';
 export default Build;
 export { Item, Loader, Rule };

package/lib/index.js

@@ -6,10 +6,10 @@
  * @see https://bud.js.org
  * @see https://github.com/roots/bud
  */
-import './types.js';
 import { Item } from './item/index.js';
 import { Loader } from './loader/index.js';
 import { Rule } from './rule/index.js';
 import { Build } from './service.js';
+import './types.js';
 export default Build;
 export { Item, Loader, Rule };

package/lib/item/index.d.ts

@@ -15,7 +15,7 @@ declare class Item extends Base implements Build.Item {
     /**
      * Loader
      */
-    loader: Loader | `${keyof Loaders & string}`;
+    loader: `${keyof Loaders & string}` | Loader;
     /**
      * Loader options
      */
@@ -25,31 +25,31 @@ declare class Item extends Base implements Build.Item {
      */
     constructor(_app: () => Bud, constructorParams?: {
         ident?: string;
-        loader?: Loader | `${keyof Loaders & string}`;
+        loader?: `${keyof Loaders & string}` | Loader;
         options?: Item['options'];
     });
     getIdent(): Build.Item['ident'];
-    setIdent(ident: Build.Item['ident']): this;
     /**
      * Get rule set item loader
      */
     getLoader(): Loader;
-    /**
-     * Set rule set item loader
-     */
-    setLoader(loader: Loader | `${keyof Loaders & string}`): this;
     /**
      * Get rule set item options
      */
     getOptions(): Item['options'];
-    /**
-     * Set rule set item options
-     */
-    setOptions(options: Item['options']): this;
     /**
      * Merge rule set item options
      */
     mergeOptions(options: Build.Item.Options): this;
+    setIdent(ident: Build.Item['ident']): this;
+    /**
+     * Set rule set item loader
+     */
+    setLoader(loader: `${keyof Loaders & string}` | Loader): this;
+    /**
+     * Set rule set item options
+     */
+    setOptions(options: Item['options']): this;
     /**
      * Produce rule set item object for Webpack
      */

package/lib/item/index.js

@@ -1,7 +1,7 @@
 import { __decorate, __metadata } from "tslib";
+import { basename } from 'path';
 import { bind } from '@roots/bud-support/decorators/bind';
 import isString from '@roots/bud-support/lodash/isString';
-import { basename } from 'path';
 import { Loader } from '../loader/index.js';
 import Base from '../shared/base.js';
 /**
@@ -40,10 +40,6 @@ class Item extends Base {
     getIdent() {
         return this.ident;
     }
-    setIdent(ident) {
-        this.ident = ident;
-        return this;
-    }
     /**
      * Get rule set item loader
      */
@@ -52,28 +48,12 @@ class Item extends Base {
             ? this.loader
             : this.app.build.loaders[this.loader];
     }
-    /**
-     * Set rule set item loader
-     */
-    setLoader(loader) {
-        this.loader = loader;
-        if (!this.ident)
-            this.setIdent(basename(isString(loader) ? loader : loader.getSrc()));
-        return this;
-    }
     /**
      * Get rule set item options
      */
     getOptions() {
         return this.unwrap(this.options);
     }
-    /**
-     * Set rule set item options
-     */
-    setOptions(options) {
-        this.options = options;
-        return this;
-    }
     /**
      * Merge rule set item options
      */
@@ -84,6 +64,26 @@ class Item extends Base {
         });
         return this;
     }
+    setIdent(ident) {
+        this.ident = ident;
+        return this;
+    }
+    /**
+     * Set rule set item loader
+     */
+    setLoader(loader) {
+        this.loader = loader;
+        if (!this.ident)
+            this.setIdent(basename(isString(loader) ? loader : loader.getSrc()));
+        return this;
+    }
+    /**
+     * Set rule set item options
+     */
+    setOptions(options) {
+        this.options = options;
+        return this;
+    }
     /**
      * Produce rule set item object for Webpack
      */
@@ -115,39 +115,39 @@ __decorate([
 __decorate([
     bind,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Object)
-], Item.prototype, "setIdent", null);
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Loader)
+], Item.prototype, "getLoader", null);
 __decorate([
     bind,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Loader)
-], Item.prototype, "getLoader", null);
+    __metadata("design:returntype", Object)
+], Item.prototype, "getOptions", null);
 __decorate([
     bind,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Object)
-], Item.prototype, "setLoader", null);
+], Item.prototype, "mergeOptions", null);
 __decorate([
     bind,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
+    __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Object)
-], Item.prototype, "getOptions", null);
+], Item.prototype, "setIdent", null);
 __decorate([
     bind,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", void 0)
-], Item.prototype, "setOptions", null);
+    __metadata("design:returntype", Object)
+], Item.prototype, "setLoader", null);
 __decorate([
     bind,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Object)
-], Item.prototype, "mergeOptions", null);
+    __metadata("design:returntype", void 0)
+], Item.prototype, "setOptions", null);
 __decorate([
     bind,
     __metadata("design:type", Function),