@roots/bud-build 6.13.0 → 6.13.1

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`),
         },
     ]),
     {

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/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

@@ -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

@@ -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

@@ -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),

package/lib/rule/index.d.ts

@@ -1,125 +1,125 @@
 import type { Bud } from '@roots/bud-framework';
-import type { Options, Output, Parser, Rule as Interface } from '@roots/bud-framework/services/build/rule';
-import type { RuleSetRule } from '@roots/bud-support/webpack';
+import type { RuleSetRule } from '@roots/bud-framework/config';
+import type { Rule as Interface, Options, Output, Parser } from '@roots/bud-framework/services/build/rule';
 import Base from '../shared/base.js';
 /**
  * RuleSetRule
  */
 declare class Rule extends Base implements Interface {
     /**
-     * RuleSetRule resolve
-     */
-    resolve?: Options[`resolve`];
-    /**
-     * RuleSetRule test
+     * RuleSetRule exclude
      */
-    test: Options[`test`];
+    exclude?: Options[`exclude`];
     /**
-     * RuleSetRule use
+     * RuleSetRule generator
      */
-    use?: Options[`use`];
+    generator?: Options[`generator`];
     /**
      * RuleSetRule include
      */
     include?: Options[`include`];
     /**
-     * RuleSetRule exclude
+     * RuleSetRule parser
      */
-    exclude?: Options[`exclude`];
+    parser?: Options[`parser`];
     /**
-     * RuleSetRule type
+     * RuleSetRule resolve
      */
-    type?: Options[`type`];
+    resolve?: Options[`resolve`];
     /**
      * RuleSetRule resourceQuery
      */
     resourceQuery?: Options[`resourceQuery`];
     /**
-     * RuleSetRule parser
+     * RuleSetRule test
      */
-    parser?: Options[`parser`];
+    test: Options[`test`];
     /**
-     * RuleSetRule generator
+     * RuleSetRule type
      */
-    generator?: Options[`generator`];
+    type?: Options[`type`];
     /**
-     * Class constructor
+     * RuleSetRule use
      */
-    constructor(_app: () => Bud, options?: Options);
+    use?: Options[`use`];
     /**
-     * Set resolve value
+     * Class constructor
      */
-    getResolve(): Output[`resolve`];
+    constructor(_app: () => Bud, options?: Options);
     /**
-     * Set resolve value
+     * Get `exclude` value
      */
-    setResolve(resolve: Options[`resolve`]): this;
+    getExclude(): Array<RegExp | string>;
     /**
-     * Get `test` value
+     * Get generator value
      */
-    getTest(): Output['test'];
+    getGenerator(): {
+        [index: string]: any;
+    };
     /**
-     * Set `test` value
+     * Get `include` value
      */
-    setTest(test: Options['test']): this;
+    getInclude(): Array<RegExp | string>;
     /**
      * Get `parser` value
      */
     getParser(): Output['parser'];
     /**
-     * Set `parser` value
+     * Set resolve value
      */
-    setParser(parser: Interface['parser']): this;
+    getResolve(): Output[`resolve`];
+    /**
+     * Get `include` value
+     */
+    getResourceQuery(): Output[`resourceQuery`];
+    /**
+     * Get `test` value
+     */
+    getTest(): Output['test'];
+    /**
+     * Get `type` value
+     */
+    getType(): string;
     /**
      * Get `use` value
      */
     getUse(): Options[`use`];
     /**
-     * Set `use` value
+     * Set exclude value
      */
-    setUse(use: Options[`use`] | ((use: Options[`use`]) => Options[`use`])): this;
+    setExclude(excludes: ((excludes: Options['exclude']) => Options['exclude']) | Options['exclude']): this;
     /**
-     * Get `include` value
+     * Set generator value
      */
-    getInclude(): Array<string | RegExp>;
+    setGenerator(generator: Options['generator']): this;
     /**
      * Set `include` value
      */
     setInclude(includes: Options['include']): this;
     /**
-     * Get `include` value
-     */
-    getResourceQuery(): Output[`resourceQuery`];
-    /**
-     * Set `include` value
+     * Set `parser` value
      */
-    setResourceQuery(query: Options['resourceQuery']): this;
+    setParser(parser: Interface['parser']): this;
     /**
-     * Get `exclude` value
+     * Set resolve value
      */
-    getExclude(): Array<string | RegExp>;
+    setResolve(resolve: Options[`resolve`]): this;
     /**
-     * Set exclude value
+     * Set `include` value
      */
-    setExclude(excludes: Options['exclude'] | ((excludes: Options['exclude']) => Options['exclude'])): this;
+    setResourceQuery(query: Options['resourceQuery']): this;
     /**
-     * Get `type` value
+     * Set `test` value
      */
-    getType(): string;
+    setTest(test: Options['test']): this;
     /**
      * Set type value
      */
     setType(type: Options[`type`]): this;
     /**
-     * Get generator value
-     */
-    getGenerator(): {
-        [index: string]: any;
-    };
-    /**
-     * Set generator value
+     * Set `use` value
      */
-    setGenerator(generator: Options['generator']): this;
+    setUse(use: ((use: Options[`use`]) => Options[`use`]) | Options[`use`]): this;
     /**
      * Produce final Base output
      */