@roots/bud-build 0.0.0

package/src/config/index.test.ts

@@ -0,0 +1,129 @@
+import {Bud, factory} from '@repo/test-kit/bud'
+import {beforeEach, describe, expect, it} from 'vitest'
+
+import {Build} from '../service.js'
+
+describe(`bud.build.config`, function () {
+  let bud: Bud
+  let build: Build
+
+  beforeEach(async () => {
+    bud = await factory()
+    build = new Build(() => bud)
+    await build.register(bud)
+    await build.make()
+  })
+
+  it(`should not include deprecated properties`, async () => {
+    expect(build.config.hasOwnProperty(`devServer`)).toBe(false)
+    expect(build.config.hasOwnProperty(`unsafeCache`)).toBe(false)
+  })
+
+  it(`should have expected bail default`, async () => {
+    expect(build.config.bail).toEqual(true)
+  })
+
+  it(`should have expected cache default`, async () => {
+    const {cache}: any = build.config
+
+    expect(cache.type).toStrictEqual(`filesystem`)
+
+    expect(cache.cacheDirectory).toStrictEqual(
+      expect.stringContaining(`.budfiles`),
+    )
+
+    expect(cache.version).toStrictEqual(expect.any(String))
+  })
+
+  it(`should have expected context default`, async () => {
+    expect(build.config.context).toEqual(bud.path(`@src`))
+  })
+
+  it(`should have expected devtool default`, async () => {
+    expect(build.config.devtool).toBe(false)
+  })
+
+  it(`should have expected entry default`, async () => {
+    expect(build.config.entry).toEqual({main: {import: [`index`]}})
+  })
+
+  it(`should have expected mode default`, async () => {
+    expect(build.config.mode).toEqual(`production`)
+  })
+
+  it(`should have expected name default`, async () => {
+    expect(build.config.name).toEqual(`@tests/project`)
+  })
+
+  it(`should have expected node default`, async () => {
+    expect(build.config.node).toEqual(false)
+  })
+
+  it(`should have expected optimization.minimize default`, async () => {
+    expect(build.config.optimization?.minimize).toEqual(true)
+  })
+
+  it(`should have expected optimization.emitOnErrors default`, async () => {
+    expect((build.config.optimization as any).emitOnErrors).toEqual(false)
+  })
+
+  it(`should have expected optimization.runtimeChunk default`, async () => {
+    expect(build.config.optimization?.runtimeChunk).toBe(false)
+  })
+
+  it(`should have expected profile default`, async () => {
+    expect(build.config.profile).toBeUndefined()
+  })
+
+  it(`should have expected resolve.alias default`, async () => {
+    expect(build.config.resolve?.alias).toEqual({
+      '@src': bud.path(`@src`),
+    })
+  })
+
+  it(`should have expected resolve.extensions default`, async () => {
+    expect(build.config.resolve?.extensions?.sort()).toEqual(
+      expect.arrayContaining([
+        `.css`,
+        `.js`,
+        `.json`,
+        `.jsx`,
+        `.mjs`,
+        `.wasm`,
+        `.yml`,
+      ]),
+    )
+  })
+
+  it(`should have expected target default`, async () => {
+    expect(build.config.target).toMatch(/browserslist.*/)
+  })
+
+  it(`should have expected watch default`, async () => {
+    expect(build.config.watch).toBeUndefined()
+  })
+
+  it(`should have expected watchOptions default`, async () => {
+    expect(build.config.watchOptions).toBeUndefined()
+  })
+
+  it(`should have expected plugins`, async () => {
+    const plugins = build.config.plugins
+      ?.map(plugin => plugin.constructor.name)
+      .sort()
+
+    expect(plugins).toContain(`CleanWebpackPlugin`)
+    expect(plugins).toContain(`FixStyleOnlyEntrypoints`)
+  })
+
+  it(`should have expected default requireEnsure rule`, async () => {
+    if (!build.config.module?.rules?.length) throw new Error()
+    expect(build.config.module.rules[0]).toEqual(
+      expect.objectContaining({
+        parser: {
+          requireEnsure: false,
+        },
+      }),
+    )
+  })
+})

package/src/config/index.ts

@@ -0,0 +1,67 @@
+import type {Bud} from '@roots/bud-framework'
+import type {Configuration} from '@roots/bud-support/webpack'
+
+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 {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,
+  stats,
+  target,
+}
+
+export interface Factory<
+  Key extends keyof Config,
+  Config = Configuration,
+> {
+  (app: Bud): Promise<Config[Key]>
+}
+
+export type Records<Config = Configuration> = {
+  [Key in keyof Config as `${Key & string}`]: Factory<Key, Config>
+}

package/src/config/infrastructureLogging.ts

@@ -0,0 +1,18 @@
+import type {Factory} from './index.js'
+
+export const infrastructureLogging: Factory<
+  `infrastructureLogging`
+> = async bud =>
+  bud.hooks.filter(`build.infrastructureLogging`, {
+    console: bud.hooks.filter(`build.infrastructureLogging.console`, {
+      ...console,
+      log: bud.context.logger.log,
+      info: bud.context.logger.info,
+      warn: bud.context.logger.warn,
+      error: bud.context.logger.error,
+      debug: bud.context.logger.debug,
+      time: bud.context.logger.time,
+      timeEnd: bud.context.logger.timeEnd,
+    }),
+    level: bud.hooks.filter(`build.infrastructureLogging.level`, `log`),
+  })

package/src/config/loader.ts

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

package/src/config/mode.ts

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

package/src/config/module.ts

@@ -0,0 +1,45 @@
+import type {Bud} from '@roots/bud-framework'
+
+import type {Factory} from './index.js'
+
+interface Props {
+  filter: Bud[`hooks`][`filter`]
+  rules: Bud[`build`][`rules`]
+  path: Bud[`path`]
+}
+
+export const module: Factory<`module`> = async ({
+  build: {rules},
+  hooks: {filter},
+  path,
+}) =>
+  filter(`build.module`, {
+    noParse: getNoParse(filter),
+    rules: getRules({filter, path, rules}),
+    unsafeCache: getUnsafeCache(filter),
+  })
+
+const getRules = ({filter, path, rules}: Props) => [
+  ...filter(`build.module.rules.before`, [
+    {
+      test: filter(`pattern.js`),
+      include: [path(`@src`)],
+      parser: {requireEnsure: false},
+    },
+  ]),
+  {
+    oneOf: filter(
+      `build.module.rules.oneOf`,
+      Object.values(rules)
+        .filter(Boolean)
+        .map(rule => (`toWebpack` in rule ? rule.toWebpack() : rule)),
+    ),
+  },
+  ...filter(`build.module.rules.after`, []),
+]
+
+const getNoParse = (filter: Props[`filter`]) =>
+  filter(`build.module.noParse`, undefined)
+
+const getUnsafeCache = (filter: Props[`filter`]) =>
+  filter(`build.module.unsafeCache`, false)

package/src/config/name.ts

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

package/src/config/node.ts

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

package/src/config/optimization.ts

@@ -0,0 +1,20 @@
+import type {Factory} from './index.js'
+
+export const optimization: Factory<`optimization`> = async ({
+  hooks: {filter},
+  isDevelopment,
+  isProduction,
+}) =>
+  filter(`build.optimization`, {
+    emitOnErrors: filter(`build.optimization.emitOnErrors`, isDevelopment),
+    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),
+    splitChunks: filter(`build.optimization.splitChunks`, false),
+    usedExports: filter(`build.optimization.usedExports`, isProduction),
+  })

package/src/config/output/assetModuleFilename.ts

@@ -0,0 +1,9 @@
+import type {Bud} from '@roots/bud-framework'
+
+interface Props {
+  filter: Bud['hooks'][`filter`]
+  relPath: Bud['relPath']
+}
+
+export const assetModuleFilename = ({filter, relPath}: Props) =>
+  filter(`build.output.assetModuleFilename`, relPath(`@file`))

package/src/config/output/chunkFilename.ts

@@ -0,0 +1,18 @@
+import {join} from 'node:path'
+
+import type {Bud} from '@roots/bud-framework'
+
+import {scriptExtension} from '../../helpers/scriptExtension.js'
+
+interface Props {
+  filter: Bud[`hooks`][`filter`]
+  relPath: Bud[`relPath`]
+}
+
+export const chunkFilename = ({filter, relPath}: Props) =>
+  filter(
+    `build.output.chunkFilename`,
+    join(`js`, `dynamic`, relPath(`@name.chunk`)).concat(
+      scriptExtension(filter, `.mjs`, `.js`),
+    ),
+  )

package/src/config/output/filename.ts

@@ -0,0 +1,14 @@
+import type {Bud} from '@roots/bud-framework'
+
+import {scriptExtension} from '../../helpers/scriptExtension.js'
+
+interface Props {
+  filter: Bud['hooks'][`filter`]
+  relPath: Bud['relPath']
+}
+
+export const filename = ({filter, relPath}: Props) =>
+  filter(
+    `build.output.filename`,
+    relPath(`js`, `@name${scriptExtension(filter, `.mjs`, `.js`)}`),
+  )

package/src/config/output/index.ts

@@ -0,0 +1,28 @@
+import {isMjs} from '../../helpers/isMjs.js'
+import type {Factory} from '../index.js'
+import {assetModuleFilename} from './assetModuleFilename.js'
+import {chunkFilename} from './chunkFilename.js'
+import {filename} from './filename.js'
+
+export const output: Factory<`output`> = async ({
+  hooks: {filter},
+  isProduction,
+  path,
+  relPath,
+}) =>
+  filter(`build.output`, {
+    assetModuleFilename: assetModuleFilename({filter, relPath}),
+    chunkFilename: chunkFilename({filter, relPath}),
+    clean: filter(`build.output.clean`, isProduction),
+    environment: filter(`build.output.environment`, undefined),
+    filename: filename({filter, relPath}),
+    module: filter(`build.output.module`, false),
+    path: filter(`build.output.path`, path(`@dist`)),
+    pathinfo: filter(`build.output.pathinfo`),
+    publicPath: filter(`build.output.publicPath`, `auto`),
+    scriptType: filter(
+      `build.output.scriptType`,
+      isMjs(filter) ? `module` : false,
+    ),
+    uniqueName: filter(`build.output.uniqueName`, `@roots/bud`),
+  })

package/src/config/parallelism.ts

@@ -0,0 +1,6 @@
+import {cpus} from 'node:os'
+
+import type {Factory} from './index.js'
+
+export const parallelism: Factory<`parallelism`> = async ({hooks}) =>
+  hooks.filter(`build.parallelism`, 10 * Math.max(cpus().length - 1, 1))

package/src/config/performance.ts

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

package/src/config/plugins.ts

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

package/src/config/profile.ts

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

package/src/config/recordsPath.ts

@@ -0,0 +1,7 @@
+import type {Factory} from './index.js'
+
+export const recordsPath: Factory<`recordsPath`> = async bud =>
+  bud.hooks.filter(
+    `build.recordsPath`,
+    bud.path(`@storage`, bud.label, `modules.json`),
+  )

package/src/config/resolve.ts

@@ -0,0 +1,45 @@
+import type {Bud} from '@roots/bud-framework'
+
+import type {Factory} from './index.js'
+
+export const resolve: Factory<`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)
+}
+
+const getAlias = async (bud: Bud) =>
+  await bud.hooks.filterAsync(`build.resolve.alias`, {
+    '@src': bud.path(`@src`),
+  })
+
+const getExtensions = (bud: 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: Bud) =>
+  await bud.hooks.filterAsync(`build.resolve.modules`, [
+    bud.hooks.filter(`location.@src`),
+    bud.hooks.filter(`location.@modules`),
+  ])

package/src/config/stats.ts

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

package/src/config/target.ts

@@ -0,0 +1,9 @@
+import type {Factory} from './index.js'
+
+export const target: Factory<`target`> = async ({context, hooks, root}) =>
+  hooks.filter(
+    `build.target`,
+    context.manifest?.browserslist
+      ? `browserslist:${root.path(`package.json`)}`
+      : `web`,
+  )

package/src/handlers/index.ts

@@ -0,0 +1,22 @@
+import type {Bud} from '@roots/bud-framework'
+
+import type {Rule} from '../rule/index.js'
+import * as items from './items/items.js'
+import * as loaders from './loaders/loaders.js'
+import {register} from './register.js'
+import {rules} from './rules/index.js'
+
+export interface Props {
+  filter: Bud[`hooks`][`filter`]
+  makeItem: Bud[`build`][`makeItem`]
+  makeLoader: Bud[`build`][`makeLoader`]
+  makeRule: Bud[`build`][`makeRule`]
+  isProduction: Bud[`isProduction`]
+  path: Bud[`path`]
+}
+
+export interface Factory<T = Rule> {
+  (props: Props): T
+}
+
+export {items, loaders, register, rules}

package/src/handlers/items/items.ts

@@ -0,0 +1,93 @@
+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
+ */
+export const css: Factory<Item> = ({makeItem}) =>
+  makeItem()
+    .setIdent(`css`)
+    .setLoader(`css`)
+    .setOptions(({build: {rules}, hooks: {filter}}) => ({
+      importLoaders: rules.css.getUse().length - 2,
+      modules: false,
+      sourceMap: isBoolean(filter(`build.devtool`, false))
+        ? filter(`build.devtool`, false)
+        : true,
+    }))
+
+/**
+ * CSS module loader
+ */
+export const cssModule: Factory<Item> = ({makeItem}) =>
+  makeItem()
+    .setIdent(`cssModule`)
+    .setLoader(`css`)
+    .setOptions(({build: {rules}, hooks: {filter}}) => ({
+      importLoaders: rules.cssModule.getUse().length - 2,
+      modules: true,
+      sourceMap: isBoolean(filter(`build.devtool`, false))
+        ? filter(`build.devtool`, false)
+        : true,
+    }))
+
+/**
+ * CSV loader
+ */
+export const csv: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`csv`).setIdent(`csv`)
+
+/**
+ * HTML loader
+ */
+export const html: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`html`).setIdent(`html`)
+
+/**
+ * Style loader
+ */
+export const style: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`style`).setIdent(`style`)
+
+/**
+ * Markdown loader
+ */
+export const md: Factory<Item> = ({makeItem}) =>
+  makeItem().setIdent(`md`).setLoader(`md`)
+
+/**
+ * MiniCss loader
+ */
+export const minicss: Factory<Item> = ({makeItem}) =>
+  makeItem()
+    .setLoader(`minicss`)
+    .setIdent(`minicss`)
+    .setOptions(app => ({
+      publicPath: app.hooks.filter(`build.output.publicPath`),
+    }))
+
+/**
+ * Raw loader
+ */
+export const raw: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`raw`).setIdent(`raw`)
+
+/**
+ * File loader
+ */
+export const file: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`file`).setIdent(`file`)
+
+/**
+ * Xml loader
+ */
+export const xml: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`xml`).setIdent(`xml`)
+
+/**
+ * Yml loader
+ */
+export const yml: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`yml`).setIdent(`yml`)

package/src/handlers/loaders/loaders.ts

@@ -0,0 +1,31 @@
+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> = ({makeLoader}) =>
+  makeLoader(`@roots/bud-support/css-loader`)
+
+export const csv: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`@roots/bud-support/csv-loader`)
+
+export const file: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`@roots/bud-support/file-loader`)
+
+export const html: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`@roots/bud-support/html-loader`)
+
+export const remark: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`@roots/bud-support/remark-loader`)
+
+export const minicss: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(MiniCss.loader)
+
+export const style: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`@roots/bud-support/style-loader`)
+
+export const xml: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`@roots/bud-support/xml-loader`)
+
+export const yml: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`@roots/bud-support/yml-loader`)