@roots/bud-build 6.14.2 → 6.15.0

package/src/config/index.ts

@@ -1,69 +1,39 @@
 import type {Bud} from '@roots/bud-framework'
 import type {Configuration} from '@roots/bud-framework/config'
 
-import {bail} from './bail.js'
-import {cache} from './cache.js'
-import {context} from './context.js'
-import {dependencies} from './dependencies.js'
-import {devtool} from './devtool.js'
-import {entry} from './entry.js'
-import {experiments} from './experiments.js'
-import {externals} from './externals.js'
-import {externalsType} from './externalsType.js'
-import {infrastructureLogging} from './infrastructureLogging.js'
-import {loader} from './loader.js'
-import {mode} from './mode.js'
-import {module} from './module.js'
-import {name} from './name.js'
-import {node} from './node.js'
-import {optimization} from './optimization.js'
-import {output} from './output/index.js'
-import {parallelism} from './parallelism.js'
-import {performance} from './performance.js'
-import {plugins} from './plugins.js'
-import {profile} from './profile.js'
-import {recordsPath} from './recordsPath.js'
-import {resolve} from './resolve.js'
-import {resolveLoader} from './resolveLoader.js'
-import {snapshot} from './snapshot.js'
-import {stats} from './stats.js'
-import {target} from './target.js'
-
-export {
-  bail,
-  cache,
-  context,
-  dependencies,
-  devtool,
-  entry,
-  experiments,
-  externals,
-  externalsType,
-  infrastructureLogging,
-  loader,
-  mode,
-  module,
-  name,
-  node,
-  optimization,
-  output,
-  parallelism,
-  performance,
-  plugins,
-  profile,
-  recordsPath,
-  resolve,
-  resolveLoader,
-  snapshot,
-  stats,
-  target,
-}
+export {bail} from './bail.js'
+export {cache} from './cache.js'
+export {context} from './context.js'
+export {dependencies} from './dependencies.js'
+export {devtool} from './devtool.js'
+export {entry} from './entry.js'
+export {experiments} from './experiments.js'
+export {externals} from './externals.js'
+export {externalsType} from './externalsType.js'
+export {infrastructureLogging} from './infrastructureLogging.js'
+export {loader} from './loader.js'
+export {mode} from './mode.js'
+export {module} from './module.js'
+export {name} from './name.js'
+export {node} from './node.js'
+export {optimization} from './optimization.js'
+export {output} from './output/index.js'
+export {parallelism} from './parallelism.js'
+export {performance} from './performance.js'
+export {plugins} from './plugins.js'
+export {profile} from './profile.js'
+export {recordsPath} from './recordsPath.js'
+export {resolve} from './resolve.js'
+export {resolveLoader} from './resolveLoader.js'
+export {snapshot} from './snapshot.js'
+export {stats} from './stats.js'
+export {target} from './target.js'
 
 export interface Factory<
   Key extends keyof Config,
   Config = Configuration,
 > {
-  (app: Bud): Promise<Config[Key]>
+  (app: Bud): Promise<Config[Key] | undefined>
 }
 
 export type Records<Config = Configuration> = {

package/src/config/infrastructureLogging.ts

@@ -1,6 +1,6 @@
-import logger from '@roots/bud-support/logger'
+import type {Factory} from '@roots/bud-build/config'
 
-import type {Factory} from './index.js'
+import logger from '@roots/bud-support/logger'
 
 export const infrastructureLogging: Factory<
   `infrastructureLogging`
@@ -9,16 +9,16 @@ export const infrastructureLogging: Factory<
     console: bud.hooks.filter(`build.infrastructureLogging.console`, {
       ...console,
       error: (...args: any[]) => {
-        logger.scope(`webpack`).error(...args)
+        logger.scope(bud.label, `webpack`).error(...args)
       },
       info: (...args: any[]) => {
-        logger.scope(`webpack`).info(...args)
+        logger.scope(bud.label, `webpack`).info(...args)
       },
       log: (...args: any[]) => {
-        logger.scope(`webpack`).log(...args)
+        logger.scope(bud.label, `webpack`).log(...args)
       },
       warn: (...args: any[]) => {
-        logger.scope(`webpack`).info(...args)
+        logger.scope(bud.label, `webpack`).info(...args)
       },
     }),
     level: bud.hooks.filter(`build.infrastructureLogging.level`, `log`),

package/src/config/loader.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const loader: Factory<`loader`> = async app =>
   app.hooks.filter(`build.loader`)

package/src/config/mode.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const mode: Factory<`mode`> = async bud =>
   bud.hooks.filter(`build.mode`, bud.mode)

package/src/config/module.ts

@@ -1,7 +1,6 @@
+import type {Factory} from '@roots/bud-build/config'
 import type {Bud} from '@roots/bud-framework'
 
-import type {Factory} from './index.js'
-
 interface Props {
   filter: Bud[`hooks`][`filter`]
   path: Bud[`path`]

package/src/config/name.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const name: Factory<`name`> = async ({hooks, label}) =>
   hooks.filter(`build.name`, label)

package/src/config/node.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const node: Factory<`node`> = async ({hooks}) =>
   hooks.filter(`build.node`, false)

package/src/config/optimization.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const optimization: Factory<`optimization`> = async ({
   hooks: {filter},
@@ -31,7 +31,7 @@ export const optimization: Factory<`optimization`> = async ({
     ),
     removeEmptyChunks: filter(
       `build.optimization.removeEmptyChunks`,
-      isProduction,
+      false,
     ),
     runtimeChunk: filter(`build.optimization.runtimeChunk`, `single`),
     sideEffects: filter(`build.optimization.sideEffects`, isProduction),

package/src/config/output/assetModuleFilename.ts

@@ -6,4 +6,4 @@ interface Props {
 }
 
 export const assetModuleFilename = ({filter, relPath}: Props) =>
-  filter(`build.output.assetModuleFilename`, relPath(`@file`))
+  filter(`build.output.assetModuleFilename`, relPath(`@file[query]`))

package/src/config/output/filename.ts

@@ -1,6 +1,6 @@
 import type {Bud} from '@roots/bud-framework'
 
-import {scriptExtension} from '../../helpers/scriptExtension.js'
+import scriptExtension from '@roots/bud-build/helpers/script-extension'
 
 interface Props {
   filter: Bud['hooks'][`filter`]

package/src/config/output/index.ts

@@ -1,6 +1,5 @@
-import type {Factory} from '../index.js'
+import type {Factory} from '@roots/bud-build/config'
 
-import {isMjs} from '../../helpers/isMjs.js'
 import {assetModuleFilename} from './assetModuleFilename.js'
 import {filename} from './filename.js'
 
@@ -24,11 +23,14 @@ export const output: Factory<`output`> = async ({
     iife: filter(`build.output.iife`, undefined),
     module: filter(`build.output.module`, false),
     path: filter(`build.output.path`, path(`@dist`)),
+    /**
+     * Path info is not necessary unless the user
+     * really knows what's going on.
+     *
+     * @see {@link https://medium.com/@kenneth_chau/speeding-up-webpack-typescript-incremental-builds-by-7x-3912ba4c1d15}
+     */
     pathinfo: filter(`build.output.pathinfo`, false),
     publicPath: filter(`build.output.publicPath`, `auto`),
-    scriptType: filter(
-      `build.output.scriptType`,
-      isMjs(filter) ? `module` : `text/javascript`,
-    ),
+    scriptType: filter(`build.output.scriptType`, undefined),
     uniqueName: filter(`build.output.uniqueName`, `@roots/bud`),
   })

package/src/config/parallelism.ts

@@ -1,16 +1,19 @@
-import {cpus} from 'node:os'
+import type {Factory} from '@roots/bud-build/config'
 
-import type {Factory} from './index.js'
+import {cpus} from 'node:os'
 
 export const parallelism: Factory<`parallelism`> = async ({
+  build,
   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
+  const concurrency = 100
+  const cores = Math.max(cpus().length, 1)
+
+  const available = cores * concurrency
+  const compilations = Math.max(Object.keys(root.children ?? []).length, 1)
+  const parallelism = Math.max(Math.floor(available / compilations), 1)
 
-  return hooks.filter(`build.parallelism`, (procs * factor) / comps)
+  build.logger.info(`parallelism set to`, parallelism)
+  return hooks.filter(`build.parallelism`, parallelism)
 }

package/src/config/performance.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const performance: Factory<`performance`> = async ({hooks}) =>
   hooks.filter(`build.performance`, false)

package/src/config/plugins.ts

@@ -1,4 +1,6 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
-export const plugins: Factory<`plugins`> = async app =>
-  await app.hooks.filterAsync(`build.plugins`, await app.extensions.make())
+export const plugins: Factory<`plugins`> = async app => {
+  const plugins = await app.extensions.make()
+  return await app.hooks.filterAsync(`build.plugins`, plugins)
+}

package/src/config/profile.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const profile: Factory<`profile`> = async bud =>
   bud.hooks.filter(`build.profile`, bud.context.debug)

package/src/config/recordsPath.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const recordsPath: Factory<`recordsPath`> = async bud =>
   bud.hooks.filter(

package/src/config/resolve.ts

@@ -1,6 +1,6 @@
-import isString from '@roots/bud-support/lodash/isString'
+import type {Factory} from '@roots/bud-build/config'
 
-import type {Factory} from './index.js'
+import isString from '@roots/bud-support/lodash/isString'
 
 export const resolve: Factory<`resolve`> = async bud => {
   return await bud.hooks.filterAsync(`build.resolve`, {
@@ -20,7 +20,7 @@ export const resolve: Factory<`resolve`> = async bud => {
     extensions: Array.from(
       bud.hooks.filter(
         `build.resolve.extensions`,
-        new Set([`.js`, `.mjs`, `.jsx`, `.css`]),
+        new Set([`.js`, `.mjs`, `.css`]),
       ),
     ),
 

package/src/config/resolveLoader.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const resolveLoader: Factory<`resolveLoader`> = async ({
   hooks,
@@ -13,11 +13,8 @@ export const resolveLoader: Factory<`resolveLoader`> = async ({
       '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/src/config/snapshot.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const snapshot: Factory<`snapshot`> = async ({env, hooks, path}) =>
   hooks.filter(`build.snapshot`, {

package/src/config/stats.ts

@@ -1,25 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const stats: Factory<`stats`> = async app =>
-  app.hooks.filter(
-    `build.stats`,
-    app.isProduction
-      ? {
-          all: false,
-          assets: true,
-          assetsSort: `size`,
-          builtAt: false,
-          children: false,
-          chunks: false,
-          entrypoints: true,
-          errors: true,
-          errorsCount: true,
-          hash: true,
-          modules: true,
-          outputPath: true,
-          timings: true,
-          warnings: true,
-          warningsCount: true,
-        }
-      : {preset: `none`},
-  )
+  app.hooks.filter(`build.stats`, {preset: `none`})

package/src/config/target.ts

@@ -1,4 +1,4 @@
-import type {Factory} from './index.js'
+import type {Factory} from '@roots/bud-build/config'
 
 export const target: Factory<`target`> = async ({context, hooks, root}) =>
   hooks.filter(

package/src/helpers/isMjs.ts

@@ -1,4 +1,6 @@
 import type {Bud} from '@roots/bud-framework'
 
-export const isMjs = (filter: Bud[`hooks`][`filter`]) =>
+const isMjs = (filter: Bud[`hooks`][`filter`]) =>
   filter(`build.experiments`)?.outputModule === true
+
+export {isMjs as default}

package/src/{shared/base.ts → helpers/registrable.ts}

@@ -4,7 +4,7 @@ import type {Base as BuildBase} from '@roots/bud-framework/services/build'
 import {bind} from '@roots/bud-support/decorators/bind'
 import isFunction from '@roots/bud-support/lodash/isFunction'
 
-export default class Base implements BuildBase {
+class Registrable implements BuildBase {
   /**
    * Constructor
    */
@@ -34,3 +34,5 @@ export default class Base implements BuildBase {
     return isFunction(input) ? input : () => input
   }
 }
+
+export {Registrable as default}

package/src/helpers/{scriptExtension.ts → script-extension.ts}

@@ -1,11 +1,13 @@
 import type {Bud} from '@roots/bud-framework'
 
-import {isMjs} from './isMjs.js'
+import isMjs from '@roots/bud-build/helpers/isMjs'
 
-export const scriptExtension = (
+const scriptExtension = (
   filter: Bud[`hooks`][`filter`],
   mjs: `.${string}` = `.mjs`,
   js: `.${string}` = `.js`,
 ): `.${string}` => {
   return isMjs(filter) ? mjs : js
 }
+
+export {scriptExtension as default}

package/src/index.ts

@@ -8,12 +8,61 @@
  * @see https://github.com/roots/bud
  */
 
-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'
+import {default as Item} from '@roots/bud-build/item'
+import {default as Loader} from '@roots/bud-build/loader'
+import {default as Rule} from '@roots/bud-build/rule'
+import {default as Build} from '@roots/bud-build/service'
 
-export default Build
+declare module '@roots/bud-framework' {
+  interface Services {
+    build: Build
+  }
 
-export {Item, Loader, Rule}
+  interface Loaders {
+    css: Loader
+    csv: Loader
+    file: Loader
+    html: Loader
+    md: Loader
+    minicss: Loader
+    raw: Loader
+    style: Loader
+    url: Loader
+    yml: Loader
+  }
+
+  interface Items {
+    css: Item
+    cssModule: Item
+    csv: Item
+    file: Item
+    font: Item
+    html: Item
+    image: Item
+    md: Item
+    minicss: Item
+    precss: Item
+    raw: Item
+    style: Item
+    yml: Item
+  }
+
+  interface Rules {
+    css: Rule
+    cssModule: Rule
+    csv: Rule
+    font: Rule
+    html: Rule
+    image: Rule
+    inlineFont: Rule
+    inlineImage: Rule
+    inlineSvg: Rule
+    js: Rule
+    json: Rule
+    svg: Rule
+    toml: Rule
+    yml: Rule
+  }
+}
+
+export {Build as default, Item, Loader, Rule}

package/src/item/index.ts

@@ -1,20 +1,19 @@
 import type {Bud, Loaders} from '@roots/bud-framework'
 import type * as Build from '@roots/bud-framework/services/build'
 
-import {basename} from 'path'
+import {basename} from 'node:path'
 
+import Registrable from '@roots/bud-build/helpers/registrable'
+import Loader from '@roots/bud-build/loader'
 import {bind} from '@roots/bud-support/decorators/bind'
 import isString from '@roots/bud-support/lodash/isString'
 
-import {Loader} from '../loader/index.js'
-import Base from '../shared/base.js'
-
 export type ConstructorOptions = Build.Item.ConstructorOptions
 
 /**
  * Item class
  */
-class Item extends Base implements Build.Item {
+class Item extends Registrable implements Build.Item {
   /**
    * Identifier
    */
@@ -153,4 +152,4 @@ class Item extends Base implements Build.Item {
   }
 }
 
-export {Item}
+export {Item as default}

package/src/{handlers/items/items.ts → items/index.ts}

@@ -1,9 +1,8 @@
+import type {Factory} from '@roots/bud-build/registry'
 import type {Item} from '@roots/bud-framework/services/build'
 
 import isBoolean from '@roots/bud-support/lodash/isBoolean'
 
-import type {Factory} from '../index.js'
-
 /**
  * CSS loader
  */

package/src/loader/index.ts

@@ -1,15 +1,16 @@
 import type {Bud} from '@roots/bud-framework'
 
-import Base from '../shared/base.js'
+import Registrable from '@roots/bud-build/helpers/registrable'
 
 /**
  * Bud Loader
  */
-class Loader extends Base {
+class Loader extends Registrable {
   /**
    * Factory returning the loader path
    */
   public src: string
+
   /**
    * Class constructor
    *
@@ -17,12 +18,12 @@ class Loader extends Base {
    */
   public constructor(
     public override _app: () => Bud,
-    src: string,
+    src?: string,
     definition?: string,
   ) {
     super(_app)
     this._app = _app
-    this.src = definition ?? src
+    this.src = definition ?? src ?? ``
   }
 
   public getSrc(): string {
@@ -35,4 +36,4 @@ class Loader extends Base {
   }
 }
 
-export {Loader}
+export {Loader as default}

package/src/{handlers/loaders/loaders.ts → loaders/index.ts}

@@ -1,9 +1,8 @@
+import type {Factory} from '@roots/bud-build/registry'
 import type {Loader} from '@roots/bud-framework/services/build'
 
 import * as MiniCss from '@roots/bud-support/mini-css-extract-plugin'
 
-import type {Factory} from '../index.js'
-
 export const css: Factory<Loader> = async ({makeLoader, resolve}) =>
   makeLoader(
     await resolve(`@roots/bud-support/css-loader`, import.meta.url),

package/src/{handlers/register.ts → registry/index.ts}

@@ -1,24 +1,28 @@
+import type Rule from '@roots/bud-build/rule'
 import type {Bud} from '@roots/bud-framework'
 
-import type {Factory} from './index.js'
+import * as items from '@roots/bud-build/items'
+import * as loaders from '@roots/bud-build/loaders'
+import * as rules from '@roots/bud-build/rules'
 
-import * as items from './items/items.js'
-import * as loaders from './loaders/loaders.js'
-import {rules} from './rules/index.js'
+interface Props {
+  filter: Bud[`hooks`][`filter`]
+  isProduction: Bud[`isProduction`]
+  makeItem: Bud[`build`][`makeItem`]
+  makeLoader: Bud[`build`][`makeLoader`]
+  makeRule: Bud[`build`][`makeRule`]
+  path: Bud[`path`]
+  resolve: Bud[`module`][`resolve`]
+}
 
-/**
- * Registry factory curry function
- */
-export interface makeRegister {
-  <T, F extends CallableFunction>(props: Partial<Bud>, setRule: F): <
-    K extends keyof T & string,
-  >([key, factory]: [K, Factory<T[K]>]) => void
+interface Factory<T = Rule> {
+  (props: Props): Promise<T>
 }
 
 /**
  * Register built-in {@link loaders}, {@link items} and {@link rules}
  */
-export async function register(bud: Bud) {
+async function register(bud: Bud) {
   await Promise.all([
     ...Object.entries(loaders).map(makeRegister(bud, bud.build.setLoader)),
     ...Object.entries(items).map(makeRegister(bud, bud.build.setItem)),
@@ -34,7 +38,23 @@ export async function register(bud: Bud) {
   Object.entries(rules).map(makeRegister(bud, bud.build.setRule))
 }
 
-export const makeRegister: makeRegister =
+/**
+ * Registry factory curry function
+ */
+interface makeRegister {
+  <T, F extends CallableFunction>(
+    props: Partial<Bud>,
+    setRule: F,
+  ): <K extends keyof T & string>([key, factory]: [
+    K,
+    Factory<T[K]>,
+  ]) => void
+}
+
+/**
+ * Registry factory
+ */
+const makeRegister: makeRegister =
   ({build, hooks, isProduction, module: {resolve}, path}, setRule) =>
   async ([key, factory]) =>
     setRule(
@@ -49,3 +69,6 @@ export const makeRegister: makeRegister =
         resolve,
       }),
     )
+
+export {items, loaders, makeRegister, register, rules}
+export type {Factory, Props}