@roots/bud-build 6.6.5 → 6.6.6

package/src/item/index.ts

@@ -0,0 +1,181 @@
+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-es'
+import {basename} from 'path'
+
+import {Loader} from '../loader/index.js'
+import Base from '../shared/base.js'
+
+export type ConstructorOptions = Build.Item.ConstructorOptions
+
+/**
+ * Item class
+ *
+ * @public
+ */
+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,40 @@
+import type {Bud} from '@roots/bud-framework'
+
+import Base from '../shared/base.js'
+
+/**
+ * Bud Loader
+ *
+ * @public
+ */
+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}

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,311 @@
+import type {Bud, Items} 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, isString} from '@roots/bud-support/lodash-es'
+
+import type {Item} from '../item/index.js'
+import Base from '../shared/base.js'
+
+export {Interface, Options, Output, Parser}
+
+/**
+ * Bud Rule
+ *
+ * @public
+ */
+class Rule extends Base implements Interface {
+  /**
+   * @public
+   */
+  public test: Options['test']
+
+  /**
+   * @public
+   */
+  public use?: Options[`use`]
+
+  /**
+   * @public
+   */
+  public include?: Options['include']
+
+  /**
+   * @public
+   */
+  public exclude?: Options['exclude']
+
+  /**
+   * @public
+   */
+  public type?: Interface['type']
+
+  /**
+   * @public
+   */
+  public resourceQuery?: Interface['resourceQuery']
+
+  /**
+   * @public
+   */
+  public parser?: Interface['parser']
+
+  /**
+   * Generator factory
+   *
+   * @public
+   */
+  public generator?: Interface['generator']
+
+  /**
+   * Class constructor
+   *
+   * @public
+   */
+  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
+   *
+   * @param app - Bud instance
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public getTest(): Output['test'] {
+    return this.unwrap(this.test)
+  }
+
+  /**
+   * Set test value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public setTest(test: Options['test']): this {
+    this.test = test
+    return this
+  }
+
+  /**
+   * Get parser value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public getParser(): Output['parser'] {
+    return this.unwrap(this.parser)
+  }
+
+  /**
+   * Set parser value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public setParser(parser: Interface['parser']): this {
+    this.parser = this.wrap(parser)
+    return this
+  }
+
+  /**
+   * Get use value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public getUse(): Array<`${keyof Items & string}` | Item> {
+    return this.use
+  }
+
+  /**
+   * Set use value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @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
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public getInclude(): Array<string | RegExp> {
+    return this.include?.map(item =>
+      isFunction(item) ? item(this.app) : item,
+    )
+  }
+
+  /**
+   * Set include value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public setInclude(includes: Options['include']): this {
+    this.include = isFunction(includes) ? includes(this.include) : includes
+    return this
+  }
+
+  /**
+   * Get include value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public getResourceQuery(): Output[`resourceQuery`] {
+    return this.resourceQuery
+  }
+
+  /**
+   * Set include value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public setResourceQuery(query: Options['resourceQuery']): this {
+    this.resourceQuery = query
+    return this
+  }
+
+  /**
+   * Get exclude value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public getExclude(): Array<string | RegExp> {
+    return this.exclude?.map(this.unwrap)
+  }
+
+  /**
+   * Set exclude value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @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
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public getType(): string {
+    return this.unwrap(this.type)
+  }
+
+  /**
+   * Set type value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public setType(type: Options[`type`]): this {
+    this.type = type
+    return this
+  }
+
+  /**
+   * Get generator value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public getGenerator() {
+    return this.unwrap(this.generator)
+  }
+
+  /**
+   * Set generator value
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public setGenerator(generator: Interface['generator']): this {
+    this.generator = this.wrap(generator)
+    return this
+  }
+
+  /**
+   * Produce final Base output
+   *
+   * @param app - {@link @roots/bud-framework#Bud}
+   * @returns finalized rule
+   *
+   * @public
+   * @decorator `@bind`
+   */
+  @bind
+  public toWebpack(): Output {
+    const output: Output = Object.entries({
+      test: this.getTest(),
+      type: this.getType(),
+      parser: this.getParser(),
+      generator: this.getGenerator(),
+      use: this.getUse()
+        ?.map(item => (isString(item) ? this.app.build.items[item] : item))
+        .map(item => item.toWebpack()),
+      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}