@roots/bud-build 0.0.0

package/src/rule/index.test.ts

@@ -0,0 +1,88 @@
+import {factory} from '@repo/test-kit/bud'
+import {beforeAll, describe, expect, it} from 'vitest'
+
+import {Rule} from './index.js'
+
+describe(`Build Rule`, function () {
+  let bud
+
+  beforeAll(async () => {
+    bud = await factory()
+  })
+
+  it(`is constructable`, () => {
+    const rule = {test: /.foo$/}
+    expect(new Rule(() => bud, rule)).toBeInstanceOf(Rule)
+  })
+
+  it(`make`, () => {
+    const rule = {test: /.foo$/}
+    expect(new Rule(() => bud, rule).toWebpack()).toEqual({
+      test: /.foo$/,
+    })
+  })
+
+  it(`getUse`, () => {
+    const input = [`md`]
+    const rule = new Rule(() => bud, {
+      test: /.foo$/,
+      // @ts-ignore
+      use: input,
+    })
+
+    expect(rule.getUse()).toEqual(input)
+  })
+
+  it(`setUse`, () => {
+    const input = [`raw`, `md`]
+    const rule = new Rule(() => bud, {test: /.foo$/})
+    // @ts-ignore
+    rule.setUse(input)
+
+    expect(rule.use).toEqual(input)
+  })
+
+  it(`getTest`, () => {
+    const input = /.foo$/
+    const rule = new Rule(() => bud, {test: input})
+
+    expect(rule.getTest()).toEqual(input)
+  })
+
+  it(`setTest`, () => {
+    const input = () => /.js$/
+    const rule = new Rule(() => bud, {test: /.foo$/})
+    rule.setTest(input)
+
+    expect(rule.test).toEqual(input)
+  })
+
+  it(`getExclude`, () => {
+    const definition = {
+      test: /.foo$/,
+      exclude: [/.bar$/],
+    }
+
+    const rule = new Rule(() => bud, definition)
+
+    expect(rule.exclude).toEqual(definition.exclude)
+  })
+
+  it(`setExclude from fn`, () => {
+    const rule = new Rule(() => bud, {test: /.foo$/})
+
+    const mutationFn = () => [/.js$/]
+    rule.setExclude(mutationFn)
+
+    expect(rule.getExclude()).toEqual([/.js$/])
+  })
+
+  it(`setExclude from obj`, () => {
+    const rule = new Rule(() => bud, {test: /.foo$/})
+
+    const mutation = [/.js$/]
+    rule.setExclude(mutation)
+
+    expect(rule.getExclude()).toStrictEqual(mutation)
+  })
+})

package/src/rule/index.ts

@@ -0,0 +1,257 @@
+import type {Bud} from '@roots/bud-framework'
+import type {
+  Options,
+  Output,
+  Parser,
+  Rule as Interface,
+} from '@roots/bud-framework/services/build/rule'
+import {bind} from '@roots/bud-support/decorators'
+import isFunction from '@roots/bud-support/lodash/isFunction'
+import isString from '@roots/bud-support/lodash/isString'
+import type {RuleSetRule} from '@roots/bud-support/webpack'
+
+import Base from '../shared/base.js'
+
+/**
+ * RuleSetRule
+ */
+class Rule extends Base implements Interface {
+  /**
+   * RuleSetRule test
+   */
+  public test: Options['test']
+
+  /**
+   * RuleSetRule use
+   */
+  public use?: Options[`use`]
+
+  /**
+   * RuleSetRule include
+   */
+  public include?: Options['include']
+
+  /**
+   * RuleSetRule exclude
+   */
+  public exclude?: Options['exclude']
+
+  /**
+   * RuleSetRule type
+   */
+  public type?: Options['type']
+
+  /**
+   * RuleSetRule resourceQuery
+   */
+  public resourceQuery?: Options['resourceQuery']
+
+  /**
+   * RuleSetRule parser
+   */
+  public parser?: Options['parser']
+
+  /**
+   * RuleSetRule generator
+   */
+  public generator?: Options['generator']
+
+  /**
+   * Class constructor
+   */
+  public constructor(_app: () => Bud, options?: Options) {
+    super(_app)
+    this._app = _app
+
+    if (!options) return
+
+    this.setTest(options.test)
+    this.setUse(options.use)
+    this.setInclude(options.include)
+    this.setExclude(options.exclude)
+    this.setType(options.type)
+    this.setParser(options.parser)
+    this.setGenerator(options.generator)
+  }
+
+  /**
+   * Test value
+   */
+  @bind
+  public getTest(): Output['test'] {
+    return this.unwrap(this.test)
+  }
+
+  /**
+   * Set test value
+   */
+  @bind
+  public setTest(test: Options['test']): this {
+    this.test = test
+    return this
+  }
+
+  /**
+   * Get parser value
+   */
+  @bind
+  public getParser(): Output['parser'] {
+    return this.unwrap(this.parser)
+  }
+
+  /**
+   * Set parser value
+   */
+  @bind
+  public setParser(parser: Interface['parser']): this {
+    this.parser = this.wrap(parser)
+    return this
+  }
+
+  /**
+   * Get use value
+   */
+  @bind
+  public getUse(): Options[`use`] {
+    return this.use
+  }
+
+  /**
+   * Set use value
+   */
+  @bind
+  public setUse(
+    use: Options[`use`] | ((use: Options[`use`]) => Options[`use`]),
+  ): this {
+    this.use = isFunction(use) ? use(this.getUse()) : use
+    return this
+  }
+
+  /**
+   * Get include value
+   */
+  @bind
+  public getInclude(): Array<string | RegExp> {
+    return this.include?.map(item =>
+      isFunction(item) ? item(this.app) : item,
+    )
+  }
+
+  /**
+   * Set include value
+   */
+  @bind
+  public setInclude(includes: Options['include']): this {
+    this.include = isFunction(includes) ? includes(this.include) : includes
+    return this
+  }
+
+  /**
+   * Get include value
+   */
+  @bind
+  public getResourceQuery(): Output[`resourceQuery`] {
+    return this.resourceQuery
+  }
+
+  /**
+   * Set include value
+   */
+  @bind
+  public setResourceQuery(query: Options['resourceQuery']): this {
+    this.resourceQuery = query
+    return this
+  }
+
+  /**
+   * Get exclude value
+   */
+  @bind
+  public getExclude(): Array<string | RegExp> {
+    return this.exclude?.map(this.unwrap)
+  }
+
+  /**
+   * Set exclude value
+   */
+  @bind
+  public setExclude(
+    excludes:
+      | Options['exclude']
+      | ((excludes: Options['exclude']) => Options['exclude']),
+  ): this {
+    this.exclude = isFunction(excludes) ? excludes(this.exclude) : excludes
+    return this
+  }
+
+  /**
+   * Get type value
+   */
+  @bind
+  public getType(): string {
+    return this.unwrap(this.type)
+  }
+
+  /**
+   * Set type value
+   */
+  @bind
+  public setType(type: Options[`type`]): this {
+    this.type = type
+    return this
+  }
+
+  /**
+   * Get generator value
+   */
+  @bind
+  public getGenerator() {
+    return this.unwrap(this.generator)
+  }
+
+  /**
+   * Set generator value
+   */
+  @bind
+  public setGenerator(generator: Options['generator']): this {
+    this.generator = this.wrap(generator)
+    return this
+  }
+
+  /**
+   * Produce final Base output
+   */
+  @bind
+  public toWebpack(): Output & RuleSetRule {
+    const output: Output = Object.entries({
+      test: this.getTest(),
+      type: this.getType(),
+      parser: this.getParser(),
+      generator: this.getGenerator(),
+      use: this.getUse()
+        ?.filter(Boolean)
+        .map(item =>
+          isString(item) && item in this.app.build.items
+            ? this.app.build.items[item]
+            : item,
+        )
+        .filter(Boolean)
+        .map(item =>
+          !isString(item) && `toWebpack` in item ? item.toWebpack() : item,
+        ),
+      resourceQuery: this.getResourceQuery(),
+      include: this.getInclude(),
+      exclude: this.getExclude(),
+    }).reduce((a, [k, v]) => {
+      if (v === undefined) return a
+      return {...a, [k]: v}
+    }, {})
+
+    this.app.info(output)
+
+    return output
+  }
+}
+
+export {Rule}
+export {Interface, Options, Output, Parser}

package/src/service.ts

@@ -0,0 +1,204 @@
+import type {Items, Loaders, Rules} from '@roots/bud-framework'
+import {Service} from '@roots/bud-framework/service'
+import type * as Base from '@roots/bud-framework/services/build'
+import {bind} from '@roots/bud-support/decorators'
+import isFunction from '@roots/bud-support/lodash/isFunction'
+import isUndefined from '@roots/bud-support/lodash/isUndefined'
+import type {Configuration} from '@roots/bud-support/webpack'
+
+import type {Records} from './config/index.js'
+import {register} from './handlers/register.js'
+import {Item} from './item/index.js'
+import {Loader} from './loader/index.js'
+import {Options as RuleOptions, Rule} from './rule/index.js'
+
+/**
+ * Webpack configuration builder class
+ */
+export class Build extends Service implements Base.Service {
+  /**
+   * Built config object
+   */
+  public config: Partial<Configuration> = {}
+
+  /**
+   * Registered loaders
+   *
+   * @public
+   */
+  public loaders: Loaders = {} as Loaders
+
+  /**
+   * Registered rules
+   *
+   * @public
+   */
+  public rules: Rules = {} as Rules
+
+  /**
+   * Registered items
+   *
+   * @public
+   */
+  public items: Items = {} as Items
+
+  /**
+   * Service register event
+   *
+   * @remarks
+   * `loaders`, `items`, and `rules` are instantiated dumbly
+   * because it is painful to think about how to map the typings..
+   */
+  public override register? = register.bind(this)
+
+  /**
+   * Make webpack configuration
+   */
+  @bind
+  public async make(): Promise<Configuration> {
+    this.logger.log(`bud.build.make called`)
+    await this.app.hooks.fire(`build.before`, this.app)
+
+    await import(`./config/index.js`).then(
+      async (records: Records) =>
+        await Promise.all(
+          Object.entries(records).map(async ([prop, factory]) => {
+            try {
+              const value = await factory(this.app)
+              if (isUndefined(value)) return
+
+              this.config[prop] = value
+              this.logger.success(`built`, prop)
+            } catch (error) {
+              throw error
+            }
+          }),
+        ),
+    )
+
+    this.logger.success(`configuration successfully built`)
+    await this.app.hooks.fire(`build.after`, this.app)
+
+    return this.config
+  }
+
+  /**
+   * Get rule
+   */
+  @bind
+  public getRule<K extends `${keyof Rules & string}`>(ident: K): Rules[K] {
+    return this.rules[ident]
+  }
+
+  /**
+   * Set Rule
+   */
+  @bind
+  public setRule<K extends `${keyof Rules & string}`>(
+    name: K,
+    input?: RuleOptions | Rule,
+  ): this {
+    this.rules[name] =
+      input instanceof Rule
+        ? input
+        : isFunction(input)
+        ? input(this.makeRule())
+        : this.makeRule(input as any)
+
+    this.logger.success(`set rule:`, name)
+    this.logger.info(`\n`, this.rules[name])
+
+    return this
+  }
+
+  /**
+   * Make Rule
+   */
+  @bind
+  public makeRule(options?: RuleOptions): Rule {
+    return new Rule(() => this.app, options)
+  }
+
+  /**
+   * Get loader
+   */
+  @bind
+  public getLoader(name: string): Loader {
+    if (!this.loaders[name])
+      this.logger.error(
+        `loader ${name} was requested but is not registered`,
+      )
+
+    return this.loaders[name]
+  }
+  /**
+   * Set loader
+   */
+  @bind
+  public setLoader<K extends `${keyof Loaders & string}`>(
+    name: K,
+    definition?: any,
+  ): this {
+    const loader = isUndefined(definition)
+      ? this.makeLoader(name)
+      : definition instanceof Loader
+      ? definition
+      : this.makeLoader(definition)
+
+    this.loaders[name] = loader
+    this.logger.info(`set loader`, loader)
+
+    return this
+  }
+
+  /**
+   * Make loader
+   */
+  @bind
+  public makeLoader(src?: string): Loader {
+    return new Loader(() => this.app, src)
+  }
+
+  /**
+   * Get item
+   */
+  @bind
+  public getItem(name: `${keyof Items & string}`): Item {
+    if (!this.items[name])
+      this.logger.error(
+        `loader ${name} was requested but is not registered`,
+      )
+
+    return this.items[name]
+  }
+
+  /**
+   * Set item
+   */
+  @bind
+  public setItem<K extends `${keyof Items & string}`>(
+    ident: K,
+    options?: Items[K]['options'] | ((item: Items[K]) => Items[K]),
+  ): this {
+    const maybeOptionsCallback = isUndefined(options)
+      ? {ident, loader: ident}
+      : options
+
+    const item = isFunction(maybeOptionsCallback)
+      ? maybeOptionsCallback(this.makeItem())
+      : this.makeItem(maybeOptionsCallback)
+
+    this.items[ident] = item
+    this.logger.info(`set item`, item)
+
+    return this
+  }
+
+  /**
+   * Make item
+   */
+  @bind
+  public makeItem(options?: Partial<Item['options']>): Item {
+    return new Item(() => this.app, options)
+  }
+}

package/src/shared/base.ts

@@ -0,0 +1,37 @@
+import type {Bud} from '@roots/bud-framework'
+import type {Base as BuildBase} from '@roots/bud-framework/services/build'
+import {bind} from '@roots/bud-support/decorators'
+import isFunction from '@roots/bud-support/lodash/isFunction'
+
+export default class Base implements BuildBase {
+  /**
+   * Application getter
+   *
+   * @readonly @public
+   */
+  public get app(): Bud {
+    return this._app()
+  }
+
+  /**
+   * Constructor
+   *
+   * @public
+   */
+  public constructor(public _app: () => Bud) {}
+
+  @bind
+  public wrap<T = any>(input: T | ((app: Bud) => T)): (app: Bud) => T {
+    return isFunction(input) ? input : () => input
+  }
+
+  @bind
+  public unwrap<T = any>(
+    maybeFunction: T | ((app: Bud, ...options: Array<any>) => T),
+    ...options: Array<any>
+  ): T {
+    return isFunction(maybeFunction)
+      ? maybeFunction(this.app, ...options)
+      : maybeFunction
+  }
+}

package/src/types.ts

@@ -0,0 +1,57 @@
+/// <reference types="@roots/bud-framework" />
+/// <reference types="@roots/bud-hooks" />
+
+import type {Item} from './item/index.js'
+import type {Loader} from './loader/index.js'
+import type {Rule} from './rule/index.js'
+
+declare module '@roots/bud-framework' {
+  interface Loaders {
+    css: Loader
+    csv: Loader
+    file: Loader
+    html: Loader
+    md: Loader
+    minicss: Loader
+    raw: Loader
+    style: Loader
+    url: Loader
+    xml: Loader
+    yml: Loader
+  }
+
+  interface Items {
+    precss: Item
+    minicss: Item
+    style: Item
+    css: Item
+    cssModule: Item
+    csv: Item
+    file: Item
+    image: Item
+    font: Item
+    html: Item
+    md: Item
+    raw: Item
+    xml: Item
+    yml: Item
+  }
+
+  interface Rules {
+    js: Rule
+    css: Rule
+    cssModule: Rule
+    html: Rule
+    svg: Rule
+    image: Rule
+    font: Rule
+    xml: Rule
+    json: Rule
+    csv: Rule
+    yml: Rule
+    toml: Rule
+    inlineSvg: Rule
+    inlineFont: Rule
+    inlineImage: Rule
+  }
+}