@roots/bud-build 6.6.5 → 6.6.6

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,117 @@
+import type {Item} from '@roots/bud-framework/services/build'
+import {isBoolean} from '@roots/bud-support/lodash-es'
+
+import type {Factory} from '../index.js'
+
+/**
+ * CSS loader
+ *
+ * @public
+ */
+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
+ *
+ * @public
+ */
+export const cssModule: Factory<Item> = ({makeItem}) =>
+  makeItem()
+    .setIdent(`cssModule`)
+    .setLoader(`css`)
+    .setOptions(({build: {rules}, hooks: {filter}}) => ({
+      esModule: true,
+      importLoaders: rules.cssModule.getUse().length - 2,
+      localIdentName: `[name]__[local]___[hash:base64:5]`,
+      modules: true,
+      sourceMap: isBoolean(filter(`build.devtool`, false))
+        ? filter(`build.devtool`, false)
+        : true,
+    }))
+
+/**
+ * CSV loader
+ *
+ * @public
+ */
+export const csv: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`csv`).setIdent(`csv`)
+
+/**
+ * HTML loader
+ *
+ * @public
+ */
+export const html: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`html`).setIdent(`html`)
+
+/**
+ * Style loader
+ *
+ * @public
+ */
+export const style: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`style`).setIdent(`style`)
+
+/**
+ * Markdown loader
+ *
+ * @public
+ */
+export const md: Factory<Item> = ({makeItem}) =>
+  makeItem().setIdent(`md`).setLoader(`md`)
+
+/**
+ * MiniCss loader
+ *
+ * @public
+ */
+export const minicss: Factory<Item> = ({makeItem}) =>
+  makeItem()
+    .setLoader(`minicss`)
+    .setIdent(`minicss`)
+    .setOptions(app => ({
+      publicPath: app.hooks.filter(`build.output.publicPath`),
+    }))
+
+/**
+ * Raw loader
+ *
+ * @public
+ */
+export const raw: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`raw`).setIdent(`raw`)
+
+/**
+ * File loader
+ *
+ * @public
+ */
+export const file: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`file`).setIdent(`file`)
+
+/**
+ * Xml loader
+ *
+ * @public
+ */
+export const xml: Factory<Item> = ({makeItem}) =>
+  makeItem().setLoader(`xml`).setIdent(`xml`)
+
+/**
+ * Yml loader
+ *
+ * @public
+ */
+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 MiniCssExtractPlugin from 'mini-css-extract-plugin'
+
+import type {Factory} from '../index.js'
+
+export const css: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`css-loader`)
+
+export const csv: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`csv-loader`)
+
+export const file: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`file-loader`)
+
+export const html: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`html-loader`)
+
+export const remark: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`remark-loader`)
+
+export const minicss: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(MiniCssExtractPlugin.loader)
+
+export const style: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`style-loader`)
+
+export const xml: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`xml-loader`)
+
+export const yml: Factory<Loader> = ({makeLoader}) =>
+  makeLoader(`yml-loader`)

package/src/handlers/register.ts

@@ -0,0 +1,51 @@
+import type {Bud} from '@roots/bud-framework'
+
+import type {Factory} from './index.js'
+import * as items from './items/items.js'
+import * as loaders from './loaders/loaders.js'
+import {rules} from './rules/index.js'
+
+/**
+ * Registry factory curry function
+ *
+ * @public
+ */
+export interface makeRegister {
+  <T, F extends CallableFunction>(props: Partial<Bud>, setRule: F): <
+    K extends keyof T & string,
+  >([key, factory]: [K, Factory<T[K]>]) => void
+}
+
+/**
+ * Register built-in {@link loaders}, {@link items} and {@link rules}
+ *
+ * @public
+ */
+export async function register(bud: Bud) {
+  Object.entries(loaders).map(makeRegister(bud, bud.build.setLoader))
+  Object.entries(items).map(makeRegister(bud, bud.build.setItem))
+
+  // this is a bit of a hack
+  // that sets the base stylesheet loader
+  // to minicss in production and style-loader in development
+  bud.build.items.precss = bud.isProduction
+    ? bud.build.items.minicss
+    : bud.build.items.style
+
+  Object.entries(rules).map(makeRegister(bud, bud.build.setRule))
+}
+
+export const makeRegister: makeRegister =
+  ({build, hooks, isProduction, path}, setRule) =>
+  ([key, factory]) =>
+    setRule(
+      key,
+      factory({
+        filter: hooks.filter,
+        makeItem: build.makeItem,
+        makeLoader: build.makeLoader,
+        makeRule: build.makeRule,
+        isProduction,
+        path,
+      }),
+    )

package/src/handlers/rules/css.module.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const cssModule: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setTest(filter(`pattern.cssModule`))
+    .setInclude([() => path(`@src`)])
+    .setUse([`precss`, `cssModule`])

package/src/handlers/rules/css.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const css: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setTest(filter(`pattern.css`))
+    .setInclude([() => path(`@src`)])
+    .setUse([`precss`, `css`])

package/src/handlers/rules/csv.test.ts

@@ -0,0 +1,25 @@
+import {factory} from '@repo/test-kit/bud'
+import {describe, expect, it} from 'vitest'
+
+import {csv} from './csv.js'
+
+describe(`csv loader`, () => {
+  it(`should return a rule`, async () => {
+    const bud = await factory()
+
+    const result = csv({
+      filter: bud.hooks.filter,
+      makeItem: bud.build.makeItem,
+      makeLoader: bud.build.makeLoader,
+      makeRule: bud.build.makeRule,
+      isProduction: bud.isProduction,
+      path: bud.path,
+    })
+
+    const webpackOutput = result.toWebpack()
+
+    expect(webpackOutput.use?.[0]).toEqual(
+      expect.objectContaining({ident: `csv`, loader: `csv-loader`}),
+    )
+  })
+})

package/src/handlers/rules/csv.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const csv: Factory = ({makeRule, path, filter}) =>
+  makeRule()
+    .setInclude([path()])
+    .setTest(() => filter(`pattern.csv`))
+    .setUse([`csv`])

package/src/handlers/rules/font.inline.ts

@@ -0,0 +1,8 @@
+import type {Factory} from '../index.js'
+
+export const inlineFont: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setTest(filter(`pattern.font`))
+    .setInclude([() => path(`@src`)])
+    .setResourceQuery(/inline/)
+    .setType(`asset/inline`)

package/src/handlers/rules/font.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const font: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setType(`asset`)
+    .setTest(filter(`pattern.font`))
+    .setInclude([() => path(`@src`)])

package/src/handlers/rules/html.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const html: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setInclude([() => path()])
+    .setTest(filter(`pattern.html`))
+    .setUse([`html`])

package/src/handlers/rules/image.inline.ts

@@ -0,0 +1,8 @@
+import type {Factory} from '../index.js'
+
+export const inlineImage: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setTest(filter(`pattern.image`))
+    .setInclude([() => path(`@src`)])
+    .setType(`asset/inline`)
+    .setResourceQuery(/inline/)

package/src/handlers/rules/image.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const image: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setTest(filter(`pattern.image`))
+    .setInclude([() => path(`@src`)])
+    .setType(`asset/resource`)

package/src/handlers/rules/index.ts

@@ -0,0 +1,35 @@
+import {css} from './css.js'
+import {cssModule} from './css.module.js'
+import {csv} from './csv.js'
+import {inlineFont} from './font.inline.js'
+import {font} from './font.js'
+import {html} from './html.js'
+import {inlineImage} from './image.inline.js'
+import {image} from './image.js'
+import {js} from './js.js'
+import {json} from './json.js'
+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 = {
+  js,
+  css,
+  cssModule,
+  inlineSvg,
+  inlineImage,
+  inlineFont,
+  svg,
+  webp,
+  image,
+  font,
+  json,
+  html,
+  yml,
+  toml,
+  xml,
+  csv,
+}

package/src/handlers/rules/js.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const js: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setTest(filter(`pattern.js`))
+    .setInclude([() => path(`@src`)])
+    .setUse([])

package/src/handlers/rules/json.ts

@@ -0,0 +1,10 @@
+import * as json5Parser from 'json5'
+
+import type {Factory} from '../index.js'
+
+export const json: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setType(`json`)
+    .setInclude([() => path()])
+    .setTest(filter(`pattern.json`))
+    .setParser({parse: json5Parser.parse})

package/src/handlers/rules/svg.inline.ts

@@ -0,0 +1,8 @@
+import type {Factory} from '../index.js'
+
+export const inlineSvg: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setTest(filter(`pattern.svg`))
+    .setInclude([() => path(`@src`)])
+    .setResourceQuery(/inline/)
+    .setType(`asset/inline`)

package/src/handlers/rules/svg.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const svg: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setTest(filter(`pattern.svg`))
+    .setInclude([() => path(`@src`)])
+    .setType(`asset/resource`)

package/src/handlers/rules/toml.test.ts

@@ -0,0 +1,22 @@
+import {factory} from '@repo/test-kit/bud'
+import {describe, expect, it} from 'vitest'
+
+import {toml} from './toml'
+
+describe(`toml loader`, () => {
+  let bud
+
+  it(`should return a rule`, async () => {
+    bud = await factory()
+    const result = toml({
+      filter: bud.hooks.filter,
+      makeItem: bud.build.makeItem,
+      makeLoader: bud.build.makeLoader,
+      makeRule: bud.build.makeRule,
+      isProduction: bud.isProduction,
+      path: bud.path,
+    })
+    const webpackOutput = result.toWebpack()
+    expect(webpackOutput.type).toEqual(`json`)
+  })
+})

package/src/handlers/rules/toml.ts

@@ -0,0 +1,10 @@
+import * as tomlParser from 'toml'
+
+import type {Factory} from '../index.js'
+
+export const toml: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setType(`json`)
+    .setInclude([() => path()])
+    .setTest(() => filter(`pattern.toml`))
+    .setParser({parse: tomlParser.parse})

package/src/handlers/rules/webp.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const webp: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setTest(filter(`pattern.webp`))
+    .setInclude([() => path(`@src`)])
+    .setType(`asset/resource`)

package/src/handlers/rules/xml.test.ts

@@ -0,0 +1,24 @@
+import {describe, expect, it} from 'vitest'
+
+import {xml} from './xml'
+
+describe(`xml loader`, () => {
+  it(`should return a rule`, async () => {
+    const bud = await import(`@repo/test-kit/bud`).then(
+      async ({factory}) => await factory(),
+    )
+    const result = xml({
+      filter: bud.hooks.filter,
+      makeItem: bud.build.makeItem,
+      makeLoader: bud.build.makeLoader,
+      makeRule: bud.build.makeRule,
+      isProduction: bud.isProduction,
+      path: bud.path,
+    })
+
+    const webpackOutput = result.toWebpack()
+    expect(webpackOutput.use?.[0]).toEqual(
+      expect.objectContaining({ident: `xml`, loader: `xml-loader`}),
+    )
+  })
+})

package/src/handlers/rules/xml.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const xml: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setInclude([() => path()])
+    .setTest(() => filter(`pattern.xml`))
+    .setUse([`xml`])

package/src/handlers/rules/yml.ts

@@ -0,0 +1,7 @@
+import type {Factory} from '../index.js'
+
+export const yml: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setInclude([() => path()])
+    .setTest(filter(`pattern.yml`))
+    .setUse([`yml`])

package/src/helpers/isMjs.ts

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

package/src/helpers/scriptExtension.ts

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

package/src/index.ts

@@ -0,0 +1,17 @@
+// Copyright © Roots Software Foundation LLC
+// Licensed under the MIT license.
+
+/**
+ * Configuration builder
+ *
+ * @see https://bud.js.org
+ * @see https://github.com/roots/bud
+ *
+ * @packageDocumentation
+ */
+
+import './types.js'
+
+import {Build} from './service.js'
+
+export default Build