js-build-tools 6.5.0 → 6.7.0

package/functions/partials/loadPeer.test.mjs

@@ -1,58 +1,58 @@
-import fs from 'fs'
-import path from 'node:path'
-import * as setUp from '../test-helpers/setUp.mjs'
-import { importModule, importPeer, requirePeer } from './loadPeer.mjs'
-
-setUp.setDefaults('test-load-peer')
-
-const options = { task: 'example', installHint: 'Install it with: npm install --save-dev fake-peer' }
-
-// A project with its own node_modules, so the packages are found from the project rather than from this package
-const projectWith = (name, files) => {
-  const project = path.resolve('test-load-peer/project')
-  fs.mkdirSync(`${project}/node_modules/${name}`, { recursive: true })
-  fs.writeFileSync(`${project}/package.json`, '{}')
-  Object.entries(files).forEach(([file, contents]) => fs.writeFileSync(`${project}/node_modules/${name}/${file}`, contents))
-  return project
-}
-
-beforeEach(setUp.beforeEach)
-afterEach(setUp.afterEach)
-
-describe('requirePeer', () => {
-  test('loads the package from the project being built', () => {
-    const project = projectWith('fake-peer', { 'package.json': '{"name":"fake-peer","main":"index.js"}', 'index.js': 'module.exports = { found: true }' })
-    expect(requirePeer('fake-peer', { ...options, projectPath: project })).toEqual({ found: true })
-  })
-
-  test('explains how to install the package when the project does not have it', () => {
-    expect(() => requirePeer('fake-peer', { ...options, projectPath: '/' })).toThrow(
-      'The example task needs the optional peer dependency fake-peer, which is not installed. Install it with: npm install --save-dev fake-peer'
-    )
-  })
-
-  test('does not hide other errors, and explains a package which is ESM-only when it has a message for that', () => {
-    const project = projectWith('broken-peer', { 'package.json': '{"name":"broken-peer","main":"index.js"}', 'index.js': 'throw new Error("boom")' })
-    expect(() => requirePeer('broken-peer', { ...options, projectPath: project })).toThrow('boom')
-    // A missing dependency of the peer is not the peer being missing
-    const inner = projectWith('inner-peer', { 'package.json': '{"name":"inner-peer","main":"index.js"}', 'index.js': 'require("something-else-missing")' })
-    expect(() => requirePeer('inner-peer', { ...options, projectPath: inner })).toThrow(/something-else-missing/)
-    expect(() => requirePeer('inner-peer', { ...options, projectPath: inner })).not.toThrow(/optional peer dependency/)
-  })
-})
-
-describe('importPeer', () => {
-  test('explains how to install the package when the project does not have it', async () => {
-    await expect(importPeer('fake-peer', { ...options, projectPath: '/' })).rejects.toThrow(
-      /needs the optional peer dependency fake-peer, which is not installed. Install it with/
-    )
-  })
-})
-
-describe('importModule', () => {
-  // The real import() cannot run under this project's CommonJS-transform-based Jest setup (see tsFor.mjs), so the
-  // loaders are checked by running the tasks for real, see the pull request.
-  test('is a function', () => {
-    expect(importModule).toBeInstanceOf(Function)
-  })
-})
+import fs from 'fs'
+import path from 'node:path'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { importModule, importPeer, requirePeer } from './loadPeer.mjs'
+
+setUp.setDefaults('test-load-peer')
+
+const options = { task: 'example', installHint: 'Install it with: npm install --save-dev fake-peer' }
+
+// A project with its own node_modules, so the packages are found from the project rather than from this package
+const projectWith = (name, files) => {
+  const project = path.resolve('test-load-peer/project')
+  fs.mkdirSync(`${project}/node_modules/${name}`, { recursive: true })
+  fs.writeFileSync(`${project}/package.json`, '{}')
+  Object.entries(files).forEach(([file, contents]) => fs.writeFileSync(`${project}/node_modules/${name}/${file}`, contents))
+  return project
+}
+
+beforeEach(setUp.beforeEach)
+afterEach(setUp.afterEach)
+
+describe('requirePeer', () => {
+  test('loads the package from the project being built', () => {
+    const project = projectWith('fake-peer', { 'package.json': '{"name":"fake-peer","main":"index.js"}', 'index.js': 'module.exports = { found: true }' })
+    expect(requirePeer('fake-peer', { ...options, projectPath: project })).toEqual({ found: true })
+  })
+
+  test('explains how to install the package when the project does not have it', () => {
+    expect(() => requirePeer('fake-peer', { ...options, projectPath: '/' })).toThrow(
+      'The example task needs the optional peer dependency fake-peer, which is not installed. Install it with: npm install --save-dev fake-peer'
+    )
+  })
+
+  test('does not hide other errors, and explains a package which is ESM-only when it has a message for that', () => {
+    const project = projectWith('broken-peer', { 'package.json': '{"name":"broken-peer","main":"index.js"}', 'index.js': 'throw new Error("boom")' })
+    expect(() => requirePeer('broken-peer', { ...options, projectPath: project })).toThrow('boom')
+    // A missing dependency of the peer is not the peer being missing
+    const inner = projectWith('inner-peer', { 'package.json': '{"name":"inner-peer","main":"index.js"}', 'index.js': 'require("something-else-missing")' })
+    expect(() => requirePeer('inner-peer', { ...options, projectPath: inner })).toThrow(/something-else-missing/)
+    expect(() => requirePeer('inner-peer', { ...options, projectPath: inner })).not.toThrow(/optional peer dependency/)
+  })
+})
+
+describe('importPeer', () => {
+  test('explains how to install the package when the project does not have it', async () => {
+    await expect(importPeer('fake-peer', { ...options, projectPath: '/' })).rejects.toThrow(
+      /needs the optional peer dependency fake-peer, which is not installed. Install it with/
+    )
+  })
+})
+
+describe('importModule', () => {
+  // The real import() cannot run under this project's CommonJS-transform-based Jest setup (see tsFor.mjs), so the
+  // loaders are checked by running the tasks for real, see the pull request.
+  test('is a function', () => {
+    expect(importModule).toBeInstanceOf(Function)
+  })
+})

package/functions/partials/loadPlaywright.mjs

@@ -1,23 +1,23 @@
-import { requirePeer } from './loadPeer.mjs'
-
-const installHint = 'Install it in your project with: npm install --save-dev playwright'
-
-/**
- * Find Playwright (headless-browser automation) of the project being built, an optional peer dependency only
- * needed by whatever actually drives a real browser - projects which never do never need it installed.
- * @memberOf module:partials
- * @param {string} [projectPath=process.cwd()] The folder of the project (which has the package.json) being built.
- * @returns {Object} The Playwright module.
- * @throws {Error} With install instructions when playwright is not installed.
- */
-export const loadPlaywright = (projectPath = process.cwd()) => requirePeer('playwright', { task: 'browser automation', installHint, projectPath })
-
-/**
- * Launch a real headless Chromium browser via Playwright. See {@link loadPlaywright}.
- * @memberOf module:partials
- * @param {Function} [load=loadPlaywright] Which Playwright to launch - swappable in tests.
- * @param {string} [projectPath=process.cwd()] The folder of the project (which has the package.json) being built.
- * @returns {Promise<Browser>} The running Playwright browser - close it yourself (browser.close()) once done with it.
- * @throws {Error} With install instructions when playwright is not installed.
- */
-export const launchBrowser = (load = loadPlaywright, projectPath = process.cwd()) => load(projectPath).chromium.launch()
+import { requirePeer } from './loadPeer.mjs'
+
+const installHint = 'Install it in your project with: npm install --save-dev playwright'
+
+/**
+ * Find Playwright (headless-browser automation) of the project being built, an optional peer dependency only
+ * needed by whatever actually drives a real browser - projects which never do never need it installed.
+ * @memberOf module:partials
+ * @param {string} [projectPath=process.cwd()] The folder of the project (which has the package.json) being built.
+ * @returns {Object} The Playwright module.
+ * @throws {Error} With install instructions when playwright is not installed.
+ */
+export const loadPlaywright = (projectPath = process.cwd()) => requirePeer('playwright', { task: 'browser automation', installHint, projectPath })
+
+/**
+ * Launch a real headless Chromium browser via Playwright. See {@link loadPlaywright}.
+ * @memberOf module:partials
+ * @param {Function} [load=loadPlaywright] Which Playwright to launch - swappable in tests.
+ * @param {string} [projectPath=process.cwd()] The folder of the project (which has the package.json) being built.
+ * @returns {Promise<Browser>} The running Playwright browser - close it yourself (browser.close()) once done with it.
+ * @throws {Error} With install instructions when playwright is not installed.
+ */
+export const launchBrowser = (load = loadPlaywright, projectPath = process.cwd()) => load(projectPath).chromium.launch()

package/functions/partials/loadPlaywright.test.mjs

@@ -1,70 +1,70 @@
-import fs from 'fs'
-import * as setUp from '../test-helpers/setUp.mjs'
-import { loadPlaywright, launchBrowser } from './loadPlaywright.mjs'
-import { serveStatic } from './serveStatic.mjs'
-
-setUp.setDefaults('test-load-playwright')
-const gulpConfig = setUp.gulpConfig
-
-beforeEach(setUp.beforeEach)
-afterEach(setUp.afterEach)
-
-describe('loadPlaywright', () => {
-  test('explains how to install playwright when the project does not have it', () => {
-    expect(() => loadPlaywright('/')).toThrow(/optional peer dependency playwright.*npm install --save-dev playwright/)
-  })
-
-  // Unlike typedoc (ESM-only, see typeDocsFor.test.mjs), playwright is CommonJS-compatible, so its real loading can
-  // be tested directly here rather than only end to end.
-  test('loads the real playwright module from this project (its own devDependency)', () => {
-    const playwright = loadPlaywright()
-    expect(typeof playwright.chromium.launch).toBe('function')
-  })
-})
-
-describe('launchBrowser', () => {
-  test('resolves playwright (via the given loader) and launches its chromium', async () => {
-    const launch = jest.fn(() => Promise.resolve('a-real-browser'))
-    const load = jest.fn(() => ({ chromium: { launch } }))
-    await expect(launchBrowser(load, '/some/project')).resolves.toBe('a-real-browser')
-    expect(load).toHaveBeenCalledWith('/some/project')
-    expect(launch).toHaveBeenCalledTimes(1)
-  })
-
-  test('defaults to the real loadPlaywright and launches a real, working browser', async () => {
-    const browser = await launchBrowser()
-    expect(browser.isConnected()).toBe(true)
-    await browser.close()
-  }, 30000)
-})
-
-describe('a real page, served and loaded end to end', () => {
-  // The exact real-world case that motivated this partial: a page using a root-relative asset path
-  // (/style.css), which a bare file:// load resolves against the filesystem root instead of the page's own
-  // directory - serveStatic + a real browser is what actually proves this resolves correctly, not jsdom
-  // (which cannot execute <script type="module"> at all, the limitation this whole capability exists to close).
-  test('a page with a root-relative asset path loads correctly through a real server and a real browser', async () => {
-    const srcPath = gulpConfig.get('srcPath')
-    fs.mkdirSync(`${srcPath}/browser`, { recursive: true })
-    fs.writeFileSync(`${srcPath}/browser/style.css`, 'body { background-color: rgb(1, 2, 3); }')
-    fs.writeFileSync(`${srcPath}/index.html`, [
-      '<!doctype html><html><head>',
-      '<link rel="stylesheet" href="/browser/style.css">',
-      '<script type="module">document.title = \'loaded via a real module script\'</script>',
-      '</head><body></body></html>'
-    ].join(''))
-
-    const { server, url } = await serveStatic(srcPath)
-    const browser = await launchBrowser()
-    try {
-      const page = await browser.newPage()
-      await page.goto(`${url}/index.html`)
-      expect(await page.title()).toBe('loaded via a real module script')
-      const backgroundColor = await page.evaluate(() => globalThis.getComputedStyle(document.body).backgroundColor)
-      expect(backgroundColor).toBe('rgb(1, 2, 3)')
-    } finally {
-      await browser.close()
-      server.close()
-    }
-  }, 30000)
-})
+import fs from 'fs'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { loadPlaywright, launchBrowser } from './loadPlaywright.mjs'
+import { serveStatic } from './serveStatic.mjs'
+
+setUp.setDefaults('test-load-playwright')
+const gulpConfig = setUp.gulpConfig
+
+beforeEach(setUp.beforeEach)
+afterEach(setUp.afterEach)
+
+describe('loadPlaywright', () => {
+  test('explains how to install playwright when the project does not have it', () => {
+    expect(() => loadPlaywright('/')).toThrow(/optional peer dependency playwright.*npm install --save-dev playwright/)
+  })
+
+  // Unlike typedoc (ESM-only, see typeDocsFor.test.mjs), playwright is CommonJS-compatible, so its real loading can
+  // be tested directly here rather than only end to end.
+  test('loads the real playwright module from this project (its own devDependency)', () => {
+    const playwright = loadPlaywright()
+    expect(typeof playwright.chromium.launch).toBe('function')
+  })
+})
+
+describe('launchBrowser', () => {
+  test('resolves playwright (via the given loader) and launches its chromium', async () => {
+    const launch = jest.fn(() => Promise.resolve('a-real-browser'))
+    const load = jest.fn(() => ({ chromium: { launch } }))
+    await expect(launchBrowser(load, '/some/project')).resolves.toBe('a-real-browser')
+    expect(load).toHaveBeenCalledWith('/some/project')
+    expect(launch).toHaveBeenCalledTimes(1)
+  })
+
+  test('defaults to the real loadPlaywright and launches a real, working browser', async () => {
+    const browser = await launchBrowser()
+    expect(browser.isConnected()).toBe(true)
+    await browser.close()
+  }, 30000)
+})
+
+describe('a real page, served and loaded end to end', () => {
+  // The exact real-world case that motivated this partial: a page using a root-relative asset path
+  // (/style.css), which a bare file:// load resolves against the filesystem root instead of the page's own
+  // directory - serveStatic + a real browser is what actually proves this resolves correctly, not jsdom
+  // (which cannot execute <script type="module"> at all, the limitation this whole capability exists to close).
+  test('a page with a root-relative asset path loads correctly through a real server and a real browser', async () => {
+    const srcPath = gulpConfig.get('srcPath')
+    fs.mkdirSync(`${srcPath}/browser`, { recursive: true })
+    fs.writeFileSync(`${srcPath}/browser/style.css`, 'body { background-color: rgb(1, 2, 3); }')
+    fs.writeFileSync(`${srcPath}/index.html`, [
+      '<!doctype html><html><head>',
+      '<link rel="stylesheet" href="/browser/style.css">',
+      '<script type="module">document.title = \'loaded via a real module script\'</script>',
+      '</head><body></body></html>'
+    ].join(''))
+
+    const { server, url } = await serveStatic(srcPath)
+    const browser = await launchBrowser()
+    try {
+      const page = await browser.newPage()
+      await page.goto(`${url}/index.html`)
+      expect(await page.title()).toBe('loaded via a real module script')
+      const backgroundColor = await page.evaluate(() => globalThis.getComputedStyle(document.body).backgroundColor)
+      expect(backgroundColor).toBe('rgb(1, 2, 3)')
+    } finally {
+      await browser.close()
+      server.close()
+    }
+  }, 30000)
+})

package/functions/partials/minifyFor.mjs

@@ -1,15 +1,15 @@
-import { dest, src } from 'gulp'
-import { default as gulpUglify } from 'gulp-uglify-es'
-import rename from 'gulp-rename'
-
-const uglify = Object.hasOwn(gulpUglify, 'default') ? gulpUglify.default : gulpUglify
-
-/**
- * Minify files and rename the output with '.min' extension.
- * @memberOf module:partials
- * @returns {*}
- */
-export const minifyFor = (srcSearch, destination) => src(srcSearch)
-  .pipe(uglify())
-  .pipe(rename({ extname: '.min.js' }))
-  .pipe(dest(destination))
+import { dest, src } from 'gulp'
+import { default as gulpUglify } from 'gulp-uglify-es'
+import rename from 'gulp-rename'
+
+const uglify = Object.hasOwn(gulpUglify, 'default') ? gulpUglify.default : gulpUglify
+
+/**
+ * Minify files and rename the output with '.min' extension.
+ * @memberOf module:partials
+ * @returns {*}
+ */
+export const minifyFor = (srcSearch, destination) => src(srcSearch)
+  .pipe(uglify())
+  .pipe(rename({ extname: '.min.js' }))
+  .pipe(dest(destination))

package/functions/partials/minifyFor.test.mjs

@@ -1,49 +1,49 @@
-import fs from 'fs'
-import * as setUp from '../test-helpers/setUp.mjs'
-import { minifyFor } from './minifyFor.mjs'
-import { countMatches } from 'test-filesystem'
-
-setUp.setDefaults('test-minify-for')
-const gulpConfig = setUp.gulpConfig
-
-const rawContents = 'const { dest, src } = require(\'gulp\')\n' +
-  'const { default: uglify } = require(\'gulp-uglify-es\')\n' +
-  'const rename = require(\'gulp-rename\')\n' +
-  '\n' +
-  '/**\n' +
-  ' * Minify files and rename the output with \'.min\' extension.\n' +
-  ' * @returns {*}\n' +
-  ' */\n' +
-  'const minifyFor = (srcSearch, destination) => src(srcSearch)\n' +
-  '  .pipe(uglify())\n' +
-  '  .pipe(rename({ extname: \'.min.js\' }))\n' +
-  '  .pipe(dest(destination))\n' +
-  '\n' +
-  'module.exports = minifyFor\n'
-
-beforeEach(() => setUp.beforeEach()
-  .then(() => fs.writeFileSync(gulpConfig.get('srcPath') + '/minifyFor.js', rawContents)))
-
-afterEach(setUp.afterEach)
-
-describe('minifyFor', () => {
-  test('copies the src directory and minifies it into the dist directory with min extension', done => {
-    const srcPath = gulpConfig.get('srcPath')
-    const filePath = `${srcPath}/minifyFor.js`
-    const expectedFilePath = `${srcPath}/minifyFor.min.js`
-    expect.assertions(3)
-    const oldContents = fs.readFileSync(filePath).toString()
-    expect(countMatches(oldContents, '\n')).toBe(14)
-    minifyFor(filePath, srcPath)
-      .on('finish', () => {
-        expect(fs.existsSync(expectedFilePath)).toBeTruthy()
-        const minifiedContents = fs.readFileSync(expectedFilePath).toString()
-        expect(countMatches(minifiedContents, '\n')).toBe(0)
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done()
-      })
-  })
-})
+import fs from 'fs'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { minifyFor } from './minifyFor.mjs'
+import { countMatches } from 'test-filesystem'
+
+setUp.setDefaults('test-minify-for')
+const gulpConfig = setUp.gulpConfig
+
+const rawContents = 'const { dest, src } = require(\'gulp\')\n' +
+  'const { default: uglify } = require(\'gulp-uglify-es\')\n' +
+  'const rename = require(\'gulp-rename\')\n' +
+  '\n' +
+  '/**\n' +
+  ' * Minify files and rename the output with \'.min\' extension.\n' +
+  ' * @returns {*}\n' +
+  ' */\n' +
+  'const minifyFor = (srcSearch, destination) => src(srcSearch)\n' +
+  '  .pipe(uglify())\n' +
+  '  .pipe(rename({ extname: \'.min.js\' }))\n' +
+  '  .pipe(dest(destination))\n' +
+  '\n' +
+  'module.exports = minifyFor\n'
+
+beforeEach(() => setUp.beforeEach()
+  .then(() => fs.writeFileSync(gulpConfig.get('srcPath') + '/minifyFor.js', rawContents)))
+
+afterEach(setUp.afterEach)
+
+describe('minifyFor', () => {
+  test('copies the src directory and minifies it into the dist directory with min extension', done => {
+    const srcPath = gulpConfig.get('srcPath')
+    const filePath = `${srcPath}/minifyFor.js`
+    const expectedFilePath = `${srcPath}/minifyFor.min.js`
+    expect.assertions(3)
+    const oldContents = fs.readFileSync(filePath).toString()
+    expect(countMatches(oldContents, '\n')).toBe(14)
+    minifyFor(filePath, srcPath)
+      .on('finish', () => {
+        expect(fs.existsSync(expectedFilePath)).toBeTruthy()
+        const minifiedContents = fs.readFileSync(expectedFilePath).toString()
+        expect(countMatches(minifiedContents, '\n')).toBe(0)
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done()
+      })
+  })
+})