js-build-tools 6.6.0 → 6.8.0

package/functions/sass.test.mjs

@@ -1,31 +1,31 @@
-import fs from 'fs'
-import * as setUp from './test-helpers/setUp.mjs'
-import { sass } from './sass.mjs'
-
-setUp.setDefaults('test-sass')
-const gulpConfig = setUp.gulpConfig
-
-beforeEach(() => setUp.beforeEach().then(
-  () => {
-    const sassPath = gulpConfig.get('sass.path')
-    return fs.mkdirSync(sassPath, { recursive: true })
-  }
-))
-
-afterEach(setUp.afterEach)
-
-describe('sass', () => {
-  test('uses the configured paths', done => {
-    const sassPath = gulpConfig.get('sass.path')
-    expect.assertions(1)
-    sass()
-      .on('finish', () => {
-        expect(fs.existsSync(sassPath)).toBeTruthy()
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done()
-      })
-  }, 10000)
-})
+import fs from 'fs'
+import * as setUp from './test-helpers/setUp.mjs'
+import { sass } from './sass.mjs'
+
+setUp.setDefaults('test-sass')
+const gulpConfig = setUp.gulpConfig
+
+beforeEach(() => setUp.beforeEach().then(
+  () => {
+    const sassPath = gulpConfig.get('sass.path')
+    return fs.mkdirSync(sassPath, { recursive: true })
+  }
+))
+
+afterEach(setUp.afterEach)
+
+describe('sass', () => {
+  test('uses the configured paths', done => {
+    const sassPath = gulpConfig.get('sass.path')
+    expect.assertions(1)
+    sass()
+      .on('finish', () => {
+        expect(fs.existsSync(sassPath)).toBeTruthy()
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done()
+      })
+  }, 10000)
+})

package/functions/sourceLint.mjs

@@ -1,13 +1,13 @@
-import { lintSource } from './partials/lintSource.mjs'
-
-/**
- * Applies neostandard linting (js-build-tools' chosen style) to the real, hand-written source - not the compiled
- * dist/browser output, which is generated and so was never going to pass a hand-authored-code style check (every
- * compiler/bundler emits its own boilerplate - import aliasing, interop headers - that only looks like a style
- * violation). Includes test files: there is no reason to hold tests to a lower style bar than the rest of the
- * source. When typescript.enabled, the real TypeScript source is linted too, with type-aware rules. Runs as part of
- * `build`, where remaining errors are reported but never fail it.
- * @memberOf module:js-build-tools
- * @returns {*}
- */
-export const sourceLint = () => lintSource()
+import { lintSource } from './partials/lintSource.mjs'
+
+/**
+ * Applies neostandard linting (js-build-tools' chosen style) to the real, hand-written source - not the compiled
+ * dist/browser output, which is generated and so was never going to pass a hand-authored-code style check (every
+ * compiler/bundler emits its own boilerplate - import aliasing, interop headers - that only looks like a style
+ * violation). Includes test files: there is no reason to hold tests to a lower style bar than the rest of the
+ * source. When typescript.enabled, the real TypeScript source is linted too, with type-aware rules. Runs as part of
+ * `build`, where remaining errors are reported but never fail it.
+ * @memberOf module:js-build-tools
+ * @returns {*}
+ */
+export const sourceLint = () => lintSource()

package/functions/sourceLint.test.mjs

@@ -1,166 +1,166 @@
-/* eslint-disable no-template-curly-in-string -- fixture source code, the ${...} is meant to stay literal */
-import fs from 'fs'
-import * as setUp from './test-helpers/setUp.mjs'
-import { lint } from './lint.mjs'
-import { sourceLint } from './sourceLint.mjs'
-import { countMatches } from 'test-filesystem'
-
-// Run the real neostandard (in a subprocess) - Jest's CommonJS transform can't load the ESM-only package itself.
-jest.mock('./partials/neostandardLint.mjs', () => require('./test-helpers/neostandardLintWithRealNeostandard.mjs'))
-
-setUp.setDefaults('test-source-lint')
-const gulpConfig = setUp.gulpConfig
-
-const lintableContents = 'const x = "a";\n' +
-  '\n' +
-  'module.exports = x;\n'
-
-const lintableTestContents = 'const y = "b";\n' +
-  '\n' +
-  'module.exports = y;\n'
-
-beforeEach(
-  () => setUp.beforeEach()
-    .then(
-      async () => {
-        const srcPath = gulpConfig.get('srcPath')
-        await fs.mkdirSync(srcPath, { recursive: true })
-        fs.writeFileSync(`${srcPath}/example.js`, lintableContents)
-        return fs.writeFileSync(`${srcPath}/example.test.js`, lintableTestContents)
-      }
-    )
-)
-
-afterEach(setUp.afterEach)
-
-describe('sourceLint', () => {
-  test('fixes the real source in place, including test files', done => {
-    const srcPath = gulpConfig.get('srcPath')
-    expect.assertions(4)
-    sourceLint()
-      .on('finish', () => {
-        const linted = fs.readFileSync(`${srcPath}/example.js`).toString()
-        expect(countMatches(linted, '"')).toEqual(0)
-        expect(countMatches(linted, ';')).toEqual(0)
-        const lintedTest = fs.readFileSync(`${srcPath}/example.test.js`).toString()
-        expect(countMatches(lintedTest, '"')).toEqual(0)
-        expect(countMatches(lintedTest, ';')).toEqual(0)
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done(error)
-      })
-  }, 20000)
-
-  test('also lints .mjs and .cjs source, not just .js', done => {
-    const srcPath = gulpConfig.get('srcPath')
-    fs.writeFileSync(`${srcPath}/example.mjs`, 'const m = "d";\n\nexport default m;\n')
-    fs.writeFileSync(`${srcPath}/example.cjs`, 'const c = "e";\n\nmodule.exports = c;\n')
-    expect.assertions(2)
-    sourceLint()
-      .on('finish', () => {
-        expect(fs.readFileSync(`${srcPath}/example.mjs`).toString()).toEqual('const m = \'d\'\n\nexport default m\n')
-        expect(fs.readFileSync(`${srcPath}/example.cjs`).toString()).toEqual('const c = \'e\'\n\nmodule.exports = c\n')
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done(error)
-      })
-  }, 20000)
-
-  test('lint.rules actually suppresses a real neostandard finding', done => {
-    const srcPath = gulpConfig.get('srcPath')
-    // A fixture string containing literal ${...} text (simulating real module source, not an accidental
-    // non-template string) - neostandard's no-template-curly-in-string rule flags this as an error by default.
-    const fixtureContents = 'const fixture = \'import(`imagemin-${pluginName}`)\'\n\nmodule.exports = fixture\n'
-    fs.writeFileSync(`${srcPath}/fixture.js`, fixtureContents)
-    gulpConfig.set('lint.rules', { 'no-template-curly-in-string': 'off' })
-    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
-    expect.assertions(1)
-    sourceLint()
-      .on('finish', () => {
-        gulpConfig.set('lint.rules', {})
-        expect(logSpy.mock.calls.flat().join('\n')).not.toMatch(/no-template-curly-in-string|template string expression/)
-        logSpy.mockRestore()
-        done()
-      })
-      .on('error', error => {
-        gulpConfig.set('lint.rules', {})
-        logSpy.mockRestore()
-        console.error('Encountered error', error)
-        done(error)
-      })
-  }, 20000)
-
-  test('also lints .ts source when typescript.enabled', done => {
-    const srcPath = gulpConfig.get('srcPath')
-    gulpConfig.set('typescript.enabled', true)
-    fs.writeFileSync(`${srcPath}/example.ts`, 'const z: string = "c";\n\nexport default z;\n')
-    expect.assertions(2)
-    sourceLint()
-      .on('finish', () => {
-        gulpConfig.set('typescript.enabled', false)
-        const linted = fs.readFileSync(`${srcPath}/example.ts`).toString()
-        expect(countMatches(linted, '"')).toEqual(0)
-        expect(countMatches(linted, ';')).toEqual(0)
-        done()
-      })
-      .on('error', error => {
-        gulpConfig.set('typescript.enabled', false)
-        console.error('Encountered error', error)
-        done(error)
-      })
-  }, 20000)
-})
-
-describe('lint', () => {
-  test('fixes the source and finishes without error when nothing unfixable remains', done => {
-    const srcPath = gulpConfig.get('srcPath')
-    expect.assertions(1)
-    lint()
-      .on('finish', () => {
-        expect(countMatches(fs.readFileSync(`${srcPath}/example.js`).toString(), ';')).toEqual(0)
-        done()
-      })
-      .on('error', error => done(error))
-  }, 20000)
-
-  test('fails when an error remains that neostandard cannot fix', done => {
-    const srcPath = gulpConfig.get('srcPath')
-    fs.writeFileSync(`${srcPath}/unfixable.js`, 'const unused = 1\n')
-    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
-    expect.assertions(1)
-    lint()
-      .on('error', error => {
-        logSpy.mockRestore()
-        expect(error.message).toMatch('neostandard found 1 lint error(s)')
-        done()
-      })
-      .on('finish', () => {
-        logSpy.mockRestore()
-        done(new Error('lint should have failed on the unused variable'))
-      })
-  }, 20000)
-
-  test('only fails once every fixed file has been written back', done => {
-    // gulp exits as soon as a task fails, so failing while a file is still being written can leave that file empty.
-    const srcPath = gulpConfig.get('srcPath')
-    const fixable = ['a', 'b', 'c'].map(name => `${srcPath}/fixable-${name}.js`)
-    fixable.forEach(file => fs.writeFileSync(file, 'const x = "y";\n\nmodule.exports = x;\n'))
-    fs.writeFileSync(`${srcPath}/unfixable.js`, 'const unused = 1\n')
-    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
-    expect.assertions(fixable.length)
-    lint()
-      .on('error', () => {
-        logSpy.mockRestore()
-        fixable.forEach(file => expect(fs.readFileSync(file).toString()).toEqual('const x = \'y\'\n\nmodule.exports = x\n'))
-        done()
-      })
-      .on('finish', () => {
-        logSpy.mockRestore()
-        done(new Error('lint should have failed on the unused variable'))
-      })
-  }, 30000)
-})
+/* eslint-disable no-template-curly-in-string -- fixture source code, the ${...} is meant to stay literal */
+import fs from 'fs'
+import * as setUp from './test-helpers/setUp.mjs'
+import { lint } from './lint.mjs'
+import { sourceLint } from './sourceLint.mjs'
+import { countMatches } from 'test-filesystem'
+
+// Run the real neostandard (in a subprocess) - Jest's CommonJS transform can't load the ESM-only package itself.
+jest.mock('./partials/neostandardLint.mjs', () => require('./test-helpers/neostandardLintWithRealNeostandard.mjs'))
+
+setUp.setDefaults('test-source-lint')
+const gulpConfig = setUp.gulpConfig
+
+const lintableContents = 'const x = "a";\n' +
+  '\n' +
+  'module.exports = x;\n'
+
+const lintableTestContents = 'const y = "b";\n' +
+  '\n' +
+  'module.exports = y;\n'
+
+beforeEach(
+  () => setUp.beforeEach()
+    .then(
+      async () => {
+        const srcPath = gulpConfig.get('srcPath')
+        await fs.mkdirSync(srcPath, { recursive: true })
+        fs.writeFileSync(`${srcPath}/example.js`, lintableContents)
+        return fs.writeFileSync(`${srcPath}/example.test.js`, lintableTestContents)
+      }
+    )
+)
+
+afterEach(setUp.afterEach)
+
+describe('sourceLint', () => {
+  test('fixes the real source in place, including test files', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    expect.assertions(4)
+    sourceLint()
+      .on('finish', () => {
+        const linted = fs.readFileSync(`${srcPath}/example.js`).toString()
+        expect(countMatches(linted, '"')).toEqual(0)
+        expect(countMatches(linted, ';')).toEqual(0)
+        const lintedTest = fs.readFileSync(`${srcPath}/example.test.js`).toString()
+        expect(countMatches(lintedTest, '"')).toEqual(0)
+        expect(countMatches(lintedTest, ';')).toEqual(0)
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done(error)
+      })
+  }, 20000)
+
+  test('also lints .mjs and .cjs source, not just .js', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    fs.writeFileSync(`${srcPath}/example.mjs`, 'const m = "d";\n\nexport default m;\n')
+    fs.writeFileSync(`${srcPath}/example.cjs`, 'const c = "e";\n\nmodule.exports = c;\n')
+    expect.assertions(2)
+    sourceLint()
+      .on('finish', () => {
+        expect(fs.readFileSync(`${srcPath}/example.mjs`).toString()).toEqual('const m = \'d\'\n\nexport default m\n')
+        expect(fs.readFileSync(`${srcPath}/example.cjs`).toString()).toEqual('const c = \'e\'\n\nmodule.exports = c\n')
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done(error)
+      })
+  }, 20000)
+
+  test('lint.rules actually suppresses a real neostandard finding', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    // A fixture string containing literal ${...} text (simulating real module source, not an accidental
+    // non-template string) - neostandard's no-template-curly-in-string rule flags this as an error by default.
+    const fixtureContents = 'const fixture = \'import(`imagemin-${pluginName}`)\'\n\nmodule.exports = fixture\n'
+    fs.writeFileSync(`${srcPath}/fixture.js`, fixtureContents)
+    gulpConfig.set('lint.rules', { 'no-template-curly-in-string': 'off' })
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+    expect.assertions(1)
+    sourceLint()
+      .on('finish', () => {
+        gulpConfig.set('lint.rules', {})
+        expect(logSpy.mock.calls.flat().join('\n')).not.toMatch(/no-template-curly-in-string|template string expression/)
+        logSpy.mockRestore()
+        done()
+      })
+      .on('error', error => {
+        gulpConfig.set('lint.rules', {})
+        logSpy.mockRestore()
+        console.error('Encountered error', error)
+        done(error)
+      })
+  }, 20000)
+
+  test('also lints .ts source when typescript.enabled', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    gulpConfig.set('typescript.enabled', true)
+    fs.writeFileSync(`${srcPath}/example.ts`, 'const z: string = "c";\n\nexport default z;\n')
+    expect.assertions(2)
+    sourceLint()
+      .on('finish', () => {
+        gulpConfig.set('typescript.enabled', false)
+        const linted = fs.readFileSync(`${srcPath}/example.ts`).toString()
+        expect(countMatches(linted, '"')).toEqual(0)
+        expect(countMatches(linted, ';')).toEqual(0)
+        done()
+      })
+      .on('error', error => {
+        gulpConfig.set('typescript.enabled', false)
+        console.error('Encountered error', error)
+        done(error)
+      })
+  }, 20000)
+})
+
+describe('lint', () => {
+  test('fixes the source and finishes without error when nothing unfixable remains', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    expect.assertions(1)
+    lint()
+      .on('finish', () => {
+        expect(countMatches(fs.readFileSync(`${srcPath}/example.js`).toString(), ';')).toEqual(0)
+        done()
+      })
+      .on('error', error => done(error))
+  }, 20000)
+
+  test('fails when an error remains that neostandard cannot fix', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    fs.writeFileSync(`${srcPath}/unfixable.js`, 'const unused = 1\n')
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+    expect.assertions(1)
+    lint()
+      .on('error', error => {
+        logSpy.mockRestore()
+        expect(error.message).toMatch('neostandard found 1 lint error(s)')
+        done()
+      })
+      .on('finish', () => {
+        logSpy.mockRestore()
+        done(new Error('lint should have failed on the unused variable'))
+      })
+  }, 20000)
+
+  test('only fails once every fixed file has been written back', done => {
+    // gulp exits as soon as a task fails, so failing while a file is still being written can leave that file empty.
+    const srcPath = gulpConfig.get('srcPath')
+    const fixable = ['a', 'b', 'c'].map(name => `${srcPath}/fixable-${name}.js`)
+    fixable.forEach(file => fs.writeFileSync(file, 'const x = "y";\n\nmodule.exports = x;\n'))
+    fs.writeFileSync(`${srcPath}/unfixable.js`, 'const unused = 1\n')
+    const logSpy = jest.spyOn(console, 'log').mockImplementation(() => {})
+    expect.assertions(fixable.length)
+    lint()
+      .on('error', () => {
+        logSpy.mockRestore()
+        fixable.forEach(file => expect(fs.readFileSync(file).toString()).toEqual('const x = \'y\'\n\nmodule.exports = x\n'))
+        done()
+      })
+      .on('finish', () => {
+        logSpy.mockRestore()
+        done(new Error('lint should have failed on the unused variable'))
+      })
+  }, 30000)
+})

package/functions/test-helpers/neostandardLintWithRealNeostandard.mjs

@@ -1,40 +1,40 @@
-import { execFileSync } from 'node:child_process'
-import fs from 'node:fs'
-import path from 'node:path'
-
-// Jest's CommonJS transform cannot load `neostandard` (ESM-only) or run a real dynamic import(), so tests that need
-// genuine neostandard behavior run the actual package in a plain Node subprocess instead of faking it.
-const script = 'import { readFileSync } from \'node:fs\'\n' +
-  'import { ESLint } from \'eslint\'\n' +
-  'import { neostandard, defaultFilePatterns } from \'neostandard\'\n' +
-  'const { text, filePath, cwd, fix, ts, env, rules } = JSON.parse(readFileSync(0, \'utf8\'))\n' +
-  'const baseConfig = neostandard({ ts, env })\n' +
-  'if (Object.keys(rules).length) { baseConfig.push({ files: defaultFilePatterns.all, rules }) }\n' +
-  'const eslint = new ESLint({ cwd, fix, overrideConfigFile: true, baseConfig })\n' +
-  'process.stdout.write(JSON.stringify(await eslint.lintText(text, { filePath })))\n'
-
-const readEnv = cwd => {
-  try {
-    return JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8')).standard?.env ?? []
-  } catch {
-    return []
-  }
-}
-
-export const loadEslintViaSubprocess = ({ cwd, ts, fix, rules = {} }) => Promise.resolve({
-  lintText: (text, { filePath }) => Promise.resolve().then(() => JSON.parse(execFileSync(
-    process.execPath,
-    ['--input-type=module', '--eval', script],
-    {
-      input: JSON.stringify({ text, filePath, cwd, fix, ts, env: readEnv(cwd), rules }),
-      encoding: 'utf8',
-      cwd,
-      maxBuffer: 256 * 1024 * 1024
-    }
-  )))
-})
-
-const actual = jest.requireActual('../partials/neostandardLint.mjs')
-
-// Drop-in replacement for the partial module (see jest.mock in the lint/build tests): same API, real neostandard.
-export const neostandardLint = (options) => actual.neostandardLint(options, loadEslintViaSubprocess)
+import { execFileSync } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+// Jest's CommonJS transform cannot load `neostandard` (ESM-only) or run a real dynamic import(), so tests that need
+// genuine neostandard behavior run the actual package in a plain Node subprocess instead of faking it.
+const script = 'import { readFileSync } from \'node:fs\'\n' +
+  'import { ESLint } from \'eslint\'\n' +
+  'import { neostandard, defaultFilePatterns } from \'neostandard\'\n' +
+  'const { text, filePath, cwd, fix, ts, env, rules } = JSON.parse(readFileSync(0, \'utf8\'))\n' +
+  'const baseConfig = neostandard({ ts, env })\n' +
+  'if (Object.keys(rules).length) { baseConfig.push({ files: defaultFilePatterns.all, rules }) }\n' +
+  'const eslint = new ESLint({ cwd, fix, overrideConfigFile: true, baseConfig })\n' +
+  'process.stdout.write(JSON.stringify(await eslint.lintText(text, { filePath })))\n'
+
+const readEnv = cwd => {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8')).standard?.env ?? []
+  } catch {
+    return []
+  }
+}
+
+export const loadEslintViaSubprocess = ({ cwd, ts, fix, rules = {} }) => Promise.resolve({
+  lintText: (text, { filePath }) => Promise.resolve().then(() => JSON.parse(execFileSync(
+    process.execPath,
+    ['--input-type=module', '--eval', script],
+    {
+      input: JSON.stringify({ text, filePath, cwd, fix, ts, env: readEnv(cwd), rules }),
+      encoding: 'utf8',
+      cwd,
+      maxBuffer: 256 * 1024 * 1024
+    }
+  )))
+})
+
+const actual = jest.requireActual('../partials/neostandardLint.mjs')
+
+// Drop-in replacement for the partial module (see jest.mock in the lint/build tests): same API, real neostandard.
+export const neostandardLint = (options) => actual.neostandardLint(options, loadEslintViaSubprocess)