@roots/bud-build 6.12.3 → 6.13.1

package/lib/config/experiments.js

@@ -1 +1,3 @@
-export const experiments = async ({ hooks }) => hooks.filter(`build.experiments`, undefined);
+export const experiments = async ({ hooks }) => hooks.filter(`build.experiments`, {
+    backCompat: false,
+});

package/lib/config/externalsType.js

@@ -1 +1 @@
-export const externalsType = async (app) => `var`;
+export const externalsType = async (app) => undefined;

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

@@ -2,18 +2,18 @@ import logger from '@roots/bud-support/utilities/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`),
         },
     ]),
     {
@@ -19,4 +19,8 @@ const getRules = ({ filter, path, rules }) => [
     ...filter(`build.module.rules.after`, []),
 ];
 const getNoParse = (filter) => filter(`build.module.noParse`, undefined);
-const getUnsafeCache = (filter) => filter(`build.module.unsafeCache`, false);
+/**
+ * By leaving undefined, webpack will strongly cache parsed modules from node_modules
+ * but leave the rest. This is the default behavior.
+ */
+const getUnsafeCache = (filter) => filter(`build.module.unsafeCache`, undefined);

package/lib/config/optimization.js

@@ -1,10 +1,20 @@
-export const optimization = async ({ hooks: { filter }, isDevelopment, isProduction, }) => filter(`build.optimization`, {
+export const optimization = async ({ hooks: { filter }, isDevelopment, isProduction, mode, }) => filter(`build.optimization`, {
     emitOnErrors: filter(`build.optimization.emitOnErrors`, isDevelopment),
+    innerGraph: filter(`build.optimization.innerGraph`, isProduction),
+    mergeDuplicateChunks: filter(`build.optimization.mergeDuplicateChunks`, isProduction),
     minimize: filter(`build.optimization.minimize`, isProduction),
     minimizer: filter(`build.optimization.minimizer`, []),
     moduleIds: filter(`build.optimization.moduleIds`, `named`),
-    removeEmptyChunks: filter(`build.optimization.removeEmptyChunks`, false),
-    runtimeChunk: filter(`build.optimization.runtimeChunk`, false),
+    nodeEnv: filter(`build.optimization.nodeEnv`, mode),
+    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),
     usedExports: filter(`build.optimization.usedExports`, isProduction),
 });

package/lib/config/output/index.js

@@ -10,7 +10,7 @@ export const output = async ({ hooks: { filter }, isProduction, path, relPath, }
     filename: filename({ filter, relPath }),
     module: filter(`build.output.module`, false),
     path: filter(`build.output.path`, path(`@dist`)),
-    pathinfo: filter(`build.output.pathinfo`),
+    pathinfo: filter(`build.output.pathinfo`, false),
     publicPath: filter(`build.output.publicPath`, `auto`),
     scriptType: filter(`build.output.scriptType`, isMjs(filter) ? `module` : false),
     uniqueName: filter(`build.output.uniqueName`, `@roots/bud`),

package/lib/config/performance.js

@@ -1 +1 @@
-export const performance = async ({ hooks }) => hooks.filter(`build.performance`, { hints: false });
+export const performance = async ({ hooks }) => hooks.filter(`build.performance`, false);

package/lib/config/profile.js

@@ -1 +1 @@
-export const profile = async (app) => app.hooks.filter(`build.profile`, undefined);
+export const profile = async (bud) => bud.hooks.filter(`build.profile`, bud.context.debug);

package/lib/config/resolve.js

@@ -1,29 +1,21 @@
 export const resolve = async (bud) => {
-    const modules = await getModules(bud);
-    const value = {
-        alias: await getAlias(bud),
-        extensions: getExtensions(bud),
-        modules,
-    };
-    return await bud.hooks.filterAsync(`build.resolve`, value);
+    return await bud.hooks.filterAsync(`build.resolve`, {
+        alias: {
+            [`@src`]: bud.path(`@src`),
+            ...(await bud.hooks.filterAsync(`build.resolve.alias`, {})),
+        },
+        extensionAlias: await bud.hooks.filterAsync(`build.resolve.extensionAlias`, {
+            [`.js`]: [`.ts`, `.tsx`, `.js`],
+            [`.mjs`]: [`.mts`, `.mtx`, `.mjs`],
+        }),
+        extensions: Array.from(bud.hooks.filter(`build.resolve.extensions`, new Set([`.js`, `.mjs`, `.jsx`, `.css`]))),
+        modules: await bud.hooks.filterAsync(`build.resolve.modules`, [
+            bud.hooks.filter(`location.@src`),
+            bud.hooks.filter(`location.@modules`),
+        ]),
+        /**
+         * Leave `undefined` to use webpack default (true in dev, false in production)
+         */
+        unsafeCache: bud.hooks.filter(`build.module.unsafeCache`, undefined),
+    });
 };
-const getAlias = async (bud) => await bud.hooks.filterAsync(`build.resolve.alias`, {
-    '@src': bud.path(`@src`),
-});
-const getExtensions = (bud) => Array.from(bud.hooks.filter(`build.resolve.extensions`, new Set([
-    `.mjs`,
-    `.js`,
-    `.jsx`,
-    `.css`,
-    `.json`,
-    `.wasm`,
-    `.yml`,
-    `.yaml`,
-    `.xml`,
-    `.toml`,
-    `.csv`,
-])));
-const getModules = async (bud) => await bud.hooks.filterAsync(`build.resolve.modules`, [
-    bud.hooks.filter(`location.@src`),
-    bud.hooks.filter(`location.@modules`),
-]);

package/lib/config/resolveLoader.js

@@ -1,3 +1,3 @@
-export const resolveLoader = async (bud) => bud.hooks.filter(`build.resolveLoader`, {
-    alias: {},
+export const resolveLoader = async ({ hooks }) => hooks.filter(`build.resolveLoader`, {
+    alias: hooks.filter(`build.resolveLoader.alias`, {}),
 });

package/lib/config/snapshot.js

@@ -1,5 +1,10 @@
-export const snapshot = async (app) => app.hooks.filter(`build.snapshot`, {
-    managedPaths: app.hooks.filter(`build.snapshot.managedPaths`, [
-        ...new Set([app.path(`@modules`)]),
+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`)]),
     ]),
+    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

@@ -7,8 +7,8 @@ export const stats = async (app) => app.hooks.filter(`build.stats`, app.isProduc
         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

@@ -48,20 +48,16 @@ export const minicss = async ({ makeItem }) => makeItem()
     .setLoader(`minicss`)
     .setIdent(`minicss`)
     .setOptions(app => ({
-    publicPath: app.hooks.filter(`build.output.publicPath`),
+    publicPath: app.publicPath(),
 }));
 /**
  * Raw loader
  */
 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/handlers/rules/js.js

@@ -1,4 +1,6 @@
 export const js = async ({ filter, makeRule, path }) => makeRule()
     .setTest(filter(`pattern.js`))
     .setInclude([() => path(`@src`)])
-    .setUse([]);
+    .setResolve({
+    fullySpecified: false,
+});

package/lib/handlers/rules/json.js

@@ -3,4 +3,6 @@ export const json = async ({ filter, makeRule, path }) => makeRule()
     .setType(`json`)
     .setInclude([() => path()])
     .setTest(filter(`pattern.json`))
-    .setParser({ parse: json5.parse });
+    .setParser({
+    parse: json5.parse,
+});

package/lib/handlers/rules/toml.js

@@ -3,4 +3,6 @@ export const toml = async ({ filter, makeRule, path }) => makeRule()
     .setType(`json`)
     .setInclude([() => path()])
     .setTest(() => filter(`pattern.toml`))
-    .setParser({ parse: tomlParser.parse });
+    .setParser({
+    parse: tomlParser.parse,
+});

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

@@ -8,6 +8,19 @@ import Base from '../shared/base.js';
  * Item class
  */
 class Item extends Base {
+    _app;
+    /**
+     * Identifier
+     */
+    ident;
+    /**
+     * Loader
+     */
+    loader;
+    /**
+     * Loader options
+     */
+    options;
     /**
      * Class constructor
      */
@@ -27,10 +40,6 @@ class Item extends Base {
     getIdent() {
         return this.ident;
     }
-    setIdent(ident) {
-        this.ident = ident;
-        return this;
-    }
     /**
      * Get rule set item loader
      */
@@ -39,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
      */
@@ -71,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
      */
@@ -102,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),

package/lib/loader/index.js

@@ -3,6 +3,11 @@ import Base from '../shared/base.js';
  * Bud Loader
  */
 class Loader extends Base {
+    _app;
+    /**
+     * Factory returning the loader path
+     */
+    src;
     /**
      * Class constructor
      *