js-build-tools 5.7.0 → 6.0.0

package/functions/bundleLint.mjs

@@ -1,18 +0,0 @@
-import { dest, src } from 'gulp'
-import * as gulpConfig from '../gulp.config.mjs'
-import { standardLint } from './partials/standardLint.mjs'
-import { getBundleConfigs } from './utilities/getBundleConfigs.mjs'
-
-/**
- * Applies Standard code style linting to every bundled file (the primary bundle, plus any
- * additional ones from browser.bundles). The lint step itself never varies per bundle, so this is
- * one shared src()/dest() pipeline fed every bundle's filename at once, rather than one pipeline
- * per bundle - gulp's src()/dest() both accept an array of paths natively.
- * @memberOf module:js-build-tools
- * @returns {stream.Stream}
- */
-export const bundleLint = () => src(
-  getBundleConfigs().map(({ name }) => `${gulpConfig.get('browser.to')}/${name}.js`)
-)
-  .pipe(standardLint({ fix: true }))
-  .pipe(dest(gulpConfig.get('browser.to')))

package/functions/bundleLint.test.mjs

@@ -1,85 +0,0 @@
-import fs from 'fs'
-import * as setUp from './test-helpers/setUp.mjs'
-import { bundleLint } from './bundleLint.mjs'
-import { countMatches } from 'test-filesystem'
-
-// Run the real Standard (in a subprocess) - Jest's CommonJS transform can't load the ESM-only package itself.
-jest.mock('./partials/standardLint.mjs', () => require('./test-helpers/standardLintWithRealStandard.mjs'))
-
-setUp.setDefaults('test-bundle-lint')
-const gulpConfig = setUp.gulpConfig
-
-const lintableContents = 'const gulpConfig = require("../gulp.config.js");\n' +
-  'const { dest, src } = require("gulp");\n' +
-  'const standard = require("gulp-standard");\n' +
-  '\n' +
-  '/**\n' +
-  ' * Applies Standard code style linting to distribution files.\n' +
-  ' * @returns {*}\n' +
-  ' */\n' +
-  'const bundleLint = () => src(`${gulpConfig.get(\"browserPath\")}/${gulpConfig.get(\"browserName\")}.js`)\n' +
-  '  .pipe(standard({ fix: true }))\n' +
-  '  .pipe(standard.reporter("default", {\n' +
-  '    fix: true,\n' +
-  '    quiet: true\n' +
-  '  }))\n' +
-  '  .pipe(dest(gulpConfig.get("browserPath")));\n' +
-  '\n' +
-  'module.exports = bundleLint;'
-
-beforeEach(
-  () => setUp.beforeEach()
-    .then(
-      async () => {
-        const browserPath = gulpConfig.get('browser.to')
-        const browserName = gulpConfig.get('browser.name')
-        await fs.mkdirSync(browserPath)
-        return fs.writeFileSync(`${browserPath}/${browserName}.js`, lintableContents)
-      }
-    )
-)
-
-afterEach(setUp.afterEach)
-
-describe('bundleLint', () => {
-  test('copies the src directory and babelifies it into the dist directory', done => {
-    const browserPath = gulpConfig.get('browser.to')
-    const browserName = gulpConfig.get('browser.name')
-    const fullPath = `${browserPath}/${browserName}.js`
-    const oldContents = fs.readFileSync(fullPath).toString()
-    expect.assertions(4)
-    expect(countMatches(oldContents, '"')).toEqual(14)
-    expect(countMatches(oldContents, ';')).toEqual(5)
-    bundleLint()
-      .on('finish', () => {
-        const lintedContents = fs.readFileSync(fullPath).toString()
-        expect(countMatches(lintedContents, '"')).toEqual(0)
-        expect(countMatches(lintedContents, ';')).toEqual(0)
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done()
-      })
-  }, 10000)
-
-  test('lints every additional bundle too, not just the primary one', done => {
-    const browserPath = gulpConfig.get('browser.to')
-    const renderOnlyFile = `${browserPath}/renderOnly.js`
-    fs.writeFileSync(renderOnlyFile, lintableContents)
-    gulpConfig.set('browser.bundles', [{ name: 'renderOnly' }])
-    expect.assertions(2)
-    bundleLint()
-      .on('finish', () => {
-        const lintedContents = fs.readFileSync(renderOnlyFile).toString()
-        expect(countMatches(lintedContents, '"')).toEqual(0)
-        expect(countMatches(lintedContents, ';')).toEqual(0)
-        gulpConfig.set('browser.bundles', [])
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done(error)
-      })
-  }, 10000)
-})

package/functions/distLint.mjs

@@ -1,12 +0,0 @@
-import * as gulpConfig from '../gulp.config.mjs'
-import { dest, src } from 'gulp'
-import { standardLint } from './partials/standardLint.mjs'
-
-/**
- * Applies Standard code style linting to distribution files.
- * @memberOf module:js-build-tools
- * @returns {*}
- */
-export const distLint = () => src(gulpConfig.get('browser.from'))
-  .pipe(standardLint({ fix: true }))
-  .pipe(dest(gulpConfig.get('dist.to')))

package/functions/distLint.test.mjs

@@ -1,62 +0,0 @@
-import fs from 'fs'
-import * as setUp from './test-helpers/setUp.mjs'
-import { distLint } from './distLint.mjs'
-import { countMatches } from 'test-filesystem'
-
-// Run the real Standard (in a subprocess) - Jest's CommonJS transform can't load the ESM-only package itself.
-jest.mock('./partials/standardLint.mjs', () => require('./test-helpers/standardLintWithRealStandard.mjs'))
-
-setUp.setDefaults('test-dist-lint')
-const gulpConfig = setUp.gulpConfig
-
-const lintableContents = 'const gulpConfig = require("../gulp.config.js");\n' +
-  'const { dest, src } = require("gulp");\n' +
-  'const standard = require("gulp-standard");\n' +
-  '\n' +
-  '/**\n' +
-  ' * Applies Standard code style linting to distribution files.\n' +
-  ' * @returns {*}\n' +
-  ' */\n' +
-  'const distLint = () => src(gulpConfig.get("distSearch"))\n' +
-  '  .pipe(standard({ fix: true }))\n' +
-  '  .pipe(standard.reporter("default", {\n' +
-  '    fix: true,\n' +
-  '    quiet: true\n' +
-  '  }))\n' +
-  '  .pipe(dest(gulpConfig.get("distPath")));\n' +
-  '\n' +
-  'module.exports = distLint;'
-
-beforeEach(
-  () => setUp.beforeEach()
-    .then(
-      async () => {
-        const distPath = gulpConfig.get('dist.to')
-        await fs.mkdirSync(distPath)
-        return fs.writeFileSync(`${distPath}/distLint.js`, lintableContents)
-      }
-    )
-)
-
-afterEach(setUp.afterEach)
-
-describe('distLint', () => {
-  test('copies the src directory and babelifies it into the dist directory', done => {
-    const distPath = gulpConfig.get('dist.to')
-    const oldContents = fs.readFileSync(`${distPath}/distLint.js`).toString()
-    expect.assertions(4)
-    expect(countMatches(oldContents, '"')).toEqual(12)
-    expect(countMatches(oldContents, ';')).toEqual(5)
-    distLint()
-      .on('finish', () => {
-        const lintedContents = fs.readFileSync(`${distPath}/distLint.js`).toString()
-        expect(countMatches(lintedContents, '"')).toEqual(0)
-        expect(countMatches(lintedContents, ';')).toEqual(0)
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done()
-      })
-  }, 10000)
-})

package/functions/partials/standardLint.mjs

@@ -1,78 +0,0 @@
-import path from 'node:path'
-import through from 'through2'
-import { importModule } from './loadPeer.mjs'
-
-// `standard` (17+) ships ESM-only, see importModule for how it is imported.
-const importStandard = () => importModule('standard')
-
-/**
- * Print a file's lint messages, if it has any.
- * @memberOf module:partials
- * @param {import('vinyl')} file
- * @param {{messages: Array<{line: number, column: number, message: string}>, errorCount: number, warningCount: number}} result
- * @returns {undefined}
- */
-const printFileReport = (file, result) => {
-  if (!result.messages.length) {
-    return
-  }
-  console.log(path.relative(file.cwd, file.path))
-  result.messages.forEach(({ line, column, message }) => console.log(`line ${line}:${column}\t${message}`))
-  console.log(`✖ ${result.errorCount} error\t⚠ ${result.warningCount} warning\n`)
-}
-
-/**
- * Lint every file streaming through with JavaScript Standard Style and, unless `fix` is false, apply the automatic
- * fixes to the file's contents so a following `dest()` writes the fixed version. Remaining problems are printed
- * along with a summary once the stream ends; they never fail the build.
- *
- * Project-level Standard configuration (the `standard` field in package.json: ignore, env, globals, ...) is honored
- * because the file's own path and cwd are handed to Standard.
- * @memberOf module:partials
- * @param {Object} [options={}]
- * @param {boolean} [options.fix=true] - Apply Standard's automatic fixes to the file contents.
- * @param {function(): Promise<{lintText: Function}>} [loadStandard] - Resolves the `standard` module. Real callers
- * should never need to pass this - it exists so tests can supply a stand-in, since this project's
- * CommonJS-transform-based Jest setup cannot execute a real dynamic import() of an ES module.
- * @returns {import('stream').Transform}
- */
-export const standardLint = (
-  { fix = true } = {},
-  loadStandard = () => importStandard().then(({ default: standard }) => standard)
-) => {
-  const totals = { errors: 0, warnings: 0 }
-  return through.obj(
-    function (file, enc, callback) {
-      if (file.isNull()) {
-        callback(null, file)
-        return
-      }
-      if (file.isStream()) {
-        callback(new Error('standardLint: streaming file contents are not supported.'))
-        return
-      }
-      loadStandard()
-        .then(standard => standard.lintText(file.contents.toString(), { filename: file.path, cwd: file.cwd, fix }))
-        .then(results => {
-          // No result at all means the file is ignored by the project's Standard configuration.
-          const [result] = results
-          if (result) {
-            if (typeof result.output === 'string') {
-              file.contents = Buffer.from(result.output)
-            }
-            totals.errors += result.errorCount
-            totals.warnings += result.warningCount
-            printFileReport(file, result)
-          }
-          callback(null, file)
-        }, callback)
-    },
-    function (callback) {
-      console.log('Standard linter results')
-      console.log('======================================')
-      console.log(`✖ Errors total: ${totals.errors}`)
-      console.log(`⚠ Warnings total: ${totals.warnings}\n`)
-      callback()
-    }
-  )
-}

package/functions/partials/standardLint.test.mjs

@@ -1,99 +0,0 @@
-import Vinyl from 'vinyl'
-import { Readable } from 'node:stream'
-import { standardLint } from './standardLint.mjs'
-
-const makeFile = (contents, filePath = '/project/dist/example.js') => new Vinyl({
-  cwd: '/project',
-  base: '/project/dist',
-  path: filePath,
-  contents
-})
-
-const run = (transform, files) => new Promise((resolve, reject) => {
-  const out = []
-  transform.on('data', file => out.push(file)).on('end', () => resolve(out)).on('error', reject)
-  files.forEach(file => transform.write(file))
-  transform.end()
-})
-
-const fakeStandard = (resultFor) => ({
-  lintText: jest.fn((text, options) => Promise.resolve(resultFor(text, options)))
-})
-
-let logSpy
-
-beforeEach(() => {
-  logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
-})
-
-afterEach(() => {
-  logSpy.mockRestore()
-})
-
-describe('standardLint', () => {
-  test('replaces file contents with the fixed output and hands Standard the file path, cwd and fix option', async () => {
-    expect.assertions(3)
-    const standard = fakeStandard((text) => [{ messages: [], errorCount: 0, warningCount: 0, output: text.replace(/"/g, '\'') }])
-    const [linted] = await run(standardLint({ fix: true }, () => Promise.resolve(standard)), [makeFile(Buffer.from('const a = "b"'))])
-    expect(linted.contents.toString()).toEqual('const a = \'b\'')
-    expect(standard.lintText).toHaveBeenCalledWith('const a = "b"', { filename: '/project/dist/example.js', cwd: '/project', fix: true })
-    expect(linted.path).toEqual('/project/dist/example.js')
-  })
-
-  test('leaves the contents alone when Standard has no fixed output (nothing needed fixing)', async () => {
-    expect.assertions(1)
-    const standard = fakeStandard(() => [{ messages: [], errorCount: 0, warningCount: 0 }])
-    const [linted] = await run(standardLint({}, () => Promise.resolve(standard)), [makeFile(Buffer.from('const a = 1'))])
-    expect(linted.contents.toString()).toEqual('const a = 1')
-  })
-
-  test('passes fix: false through so nothing is rewritten', async () => {
-    expect.assertions(1)
-    const standard = fakeStandard(() => [{ messages: [], errorCount: 0, warningCount: 0 }])
-    await run(standardLint({ fix: false }, () => Promise.resolve(standard)), [makeFile(Buffer.from('x'))])
-    expect(standard.lintText.mock.calls[0][1].fix).toBe(false)
-  })
-
-  test('passes a file through untouched when the project ignores it (Standard returns no results)', async () => {
-    expect.assertions(2)
-    const standard = fakeStandard(() => [])
-    const [linted] = await run(standardLint({}, () => Promise.resolve(standard)), [makeFile(Buffer.from('var x=1'))])
-    expect(linted.contents.toString()).toEqual('var x=1')
-    expect(logSpy).toHaveBeenCalledWith('✖ Errors total: 0')
-  })
-
-  test('skips null-content files without linting them', async () => {
-    expect.assertions(2)
-    const standard = fakeStandard(() => [])
-    const [passed] = await run(standardLint({}, () => Promise.resolve(standard)), [makeFile(null)])
-    expect(passed.isNull()).toBeTruthy()
-    expect(standard.lintText).not.toHaveBeenCalled()
-  })
-
-  test('errors on streaming file contents, which cannot be linted', async () => {
-    expect.assertions(1)
-    const streamFile = makeFile(Readable.from(['x']))
-    await expect(run(standardLint({}, () => Promise.resolve(fakeStandard(() => []))), [streamFile])).rejects.toThrow(/streaming/)
-  })
-
-  test('prints per-file problems and a summary of totals across all files, without failing', async () => {
-    expect.assertions(5)
-    const standard = fakeStandard((text, { filename }) => filename.endsWith('a.js')
-      ? [{ messages: [{ line: 2, column: 7, message: 'unused b' }, { line: 3, column: 1, message: 'bad thing' }], errorCount: 2, warningCount: 0 }]
-      : [{ messages: [{ line: 1, column: 1, message: 'just a warning' }], errorCount: 0, warningCount: 1 }])
-    const out = await run(
-      standardLint({}, () => Promise.resolve(standard)),
-      [makeFile(Buffer.from('a'), '/project/dist/a.js'), makeFile(Buffer.from('b'), '/project/dist/b.js')]
-    )
-    expect(out).toHaveLength(2)
-    expect(logSpy).toHaveBeenCalledWith('dist/a.js')
-    expect(logSpy).toHaveBeenCalledWith('line 2:7\tunused b')
-    expect(logSpy).toHaveBeenCalledWith('✖ Errors total: 2')
-    expect(logSpy).toHaveBeenCalledWith('⚠ Warnings total: 1\n')
-  })
-
-  test('surfaces a failure to load or run Standard as a stream error', async () => {
-    expect.assertions(1)
-    await expect(run(standardLint({}, () => Promise.reject(new Error('cannot load'))), [makeFile(Buffer.from('x'))])).rejects.toThrow('cannot load')
-  })
-})

package/functions/test-helpers/standardLintWithRealStandard.mjs

@@ -1,21 +0,0 @@
-import { execFileSync } from 'node:child_process'
-
-// Jest's CommonJS transform cannot load `standard` (ESM-only) or run a real dynamic import(), so tests that need
-// genuine Standard behavior run the actual `standard` package in a plain Node subprocess instead of faking it.
-const script = 'import { readFileSync } from \'node:fs\'\n' +
-  'import standard from \'standard\'\n' +
-  'const { text, options } = JSON.parse(readFileSync(0, \'utf8\'))\n' +
-  'process.stdout.write(JSON.stringify(await standard.lintText(text, options)))\n'
-
-export const loadStandardViaSubprocess = () => Promise.resolve({
-  lintText: (text, options) => Promise.resolve().then(() => JSON.parse(execFileSync(
-    process.execPath,
-    ['--input-type=module', '--eval', script],
-    { input: JSON.stringify({ text, options }), encoding: 'utf8', cwd: process.cwd(), maxBuffer: 256 * 1024 * 1024 }
-  )))
-})
-
-const actual = jest.requireActual('../partials/standardLint.mjs')
-
-// Drop-in replacement for the partial module (see jest.mock in the lint/build tests): same API, real Standard.
-export const standardLint = (options) => actual.standardLint(options, loadStandardViaSubprocess)