@roots/bud-build 0.0.0

package/src/handlers/register.ts

@@ -0,0 +1,47 @@
+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
+ */
+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}
+ */
+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}) =>
+  makeRule()
+    .setTest(filter(`pattern.css`))
+    .setInclude([({path}) => path(`@src`)])
+    .setUse([`precss`, `css`])

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

@@ -0,0 +1,28 @@
+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: `@roots/bud-support/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 = {
+  toml,
+  xml,
+  csv,
+  yml,
+  html,
+  json,
+  font,
+  svg,
+  webp,
+  image,
+  inlineFont,
+  inlineSvg,
+  inlineImage,
+  cssModule,
+  css,
+  js,
+}

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 json5 from '@roots/bud-support/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: json5.parse})

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

@@ -0,0 +1,30 @@
+import {describe, expect, it} from 'vitest'
+
+import {inlineSvg, dataUrl} from './svg.inline.js'
+
+describe(`svg-inline`, () => {
+  it(`should return a rule`, async () => {
+    const bud = await import(`@repo/test-kit/bud`).then(
+      async ({factory}) => await factory(),
+    )
+    const result = inlineSvg({
+      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.test).toEqual(bud.hooks.filter(`pattern.svg`))
+    expect(webpackOutput.include).toEqual([bud.path(`@src`)])
+    expect(webpackOutput.resourceQuery).toEqual(/inline/)
+    expect(webpackOutput.type).toEqual(`asset/inline`)
+    expect(webpackOutput.generator).toEqual(
+      expect.objectContaining({
+        dataUrl,
+      }),
+    )
+  })
+})

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

@@ -0,0 +1,13 @@
+import dataUri from '@roots/bud-support/mini-svg-data-uri'
+
+import type {Factory} from '../index.js'
+
+export const inlineSvg: Factory = ({filter, makeRule, path}) =>
+  makeRule()
+    .setTest(filter(`pattern.svg`))
+    .setInclude([() => path(`@src`)])
+    .setResourceQuery(/inline/)
+    .setGenerator({dataUrl})
+    .setType(`asset/inline`)
+
+export const dataUrl = (data: Buffer) => dataUri(data.toString())

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 tomlParser from '@roots/bud-support/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,27 @@
+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: `@roots/bud-support/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

package/src/item/index.ts

@@ -0,0 +1,179 @@
+import type {Bud, Loaders} from '@roots/bud-framework'
+import type * as Build from '@roots/bud-framework/services/build'
+import {bind} from '@roots/bud-support/decorators'
+import isString from '@roots/bud-support/lodash/isString'
+import {basename} from 'path'
+
+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 {
+  /**
+   * Identifier
+   * @public
+   */
+  public ident: string
+
+  /**
+   * Loader
+   *
+   * @public
+   */
+  public loader: Loader | `${keyof Loaders & string}`
+
+  /**
+   * Loader options
+   *
+   * @public
+   */
+  public options: Build.Item['options']
+
+  /**
+   * Class constructor
+   *
+   * @public
+   */
+  public constructor(
+    public override _app: () => Bud,
+    constructorParams?: {
+      ident?: string
+      loader?: Loader | `${keyof Loaders & string}`
+      options?: Item['options']
+    },
+  ) {
+    super(_app)
+
+    constructorParams?.ident && this.setIdent(constructorParams.ident)
+    constructorParams?.loader && this.setLoader(constructorParams.loader)
+
+    !constructorParams?.ident &&
+      constructorParams?.loader &&
+      this.setIdent(
+        isString(constructorParams.loader)
+          ? constructorParams.loader
+          : basename(constructorParams.loader.getSrc()),
+      )
+
+    constructorParams?.options &&
+      this.setOptions(constructorParams.options)
+  }
+
+  @bind
+  public getIdent(): Build.Item['ident'] {
+    return this.ident
+  }
+
+  @bind
+  public setIdent(ident: Build.Item['ident']): this {
+    this.ident = ident
+    return this
+  }
+
+  /**
+   * Get rule set item loader
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public getLoader(): Loader {
+    return this.loader instanceof Loader
+      ? this.loader
+      : this.app.build.loaders[this.loader]
+  }
+
+  /**
+   * Set rule set item loader
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public setLoader(loader: Loader | `${keyof Loaders & string}`): this {
+    this.loader = loader
+
+    if (!this.ident)
+      this.setIdent(basename(isString(loader) ? loader : loader.getSrc()))
+
+    return this
+  }
+
+  /**
+   * Get rule set item options
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public getOptions(): Item['options'] {
+    return this.unwrap(this.options)
+  }
+
+  /**
+   * Set rule set item options
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public setOptions(options: Item['options']) {
+    this.options = options
+    return this
+  }
+
+  /**
+   * Merge rule set item options
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public mergeOptions(options: Build.Item.Options): this {
+    this.setOptions({
+      ...(this.getOptions() ?? {}),
+      ...options,
+    })
+
+    return this
+  }
+
+  /**
+   * Produce rule set item object for Webpack
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public toWebpack(): Build.Item.Output {
+    const output: Build.Item.Output = {
+      loader: this.getLoader()?.getSrc(),
+    }
+
+    if (this.options) {
+      output.options = this.getOptions()
+    }
+
+    if (this.ident) {
+      output.ident = this.getIdent()
+    }
+
+    if (!output.loader) {
+      this.app.error(`error in ${this.ident}`, `no loader registered`)
+    }
+
+    return Object.entries(output).reduce(
+      (output, [key, value]) => ({
+        ...(output ?? {}),
+        ...(value ? {[key]: value} : {}),
+      }),
+      {},
+    )
+  }
+}
+
+export {Item}

package/src/loader/index.ts

@@ -0,0 +1,38 @@
+import type {Bud} from '@roots/bud-framework'
+
+import Base from '../shared/base.js'
+
+/**
+ * Bud Loader
+ */
+class Loader extends Base {
+  /**
+   * Factory returning the loader path
+   *
+   * @public
+   */
+  public src: string
+  /**
+   * Class constructor
+   *
+   * @param src - Either a factory returning a string or a literal string
+   *
+   * @public
+   */
+  public constructor(public override _app: () => Bud, src: string) {
+    super(_app)
+    this._app = _app
+    this.src = src
+  }
+
+  public getSrc(): string {
+    return this.src
+  }
+
+  public setSrc(src: string) {
+    this.src = src
+    return this
+  }
+}
+
+export {Loader}