js-build-tools 6.5.0 → 6.7.0

package/functions/partials/removeDirectory.mjs

@@ -1,34 +1,34 @@
-import { access, rm } from 'node:fs/promises'
-import { setTimeout as sleep } from 'node:timers/promises'
-
-const attempts = 4
-
-const exists = dirPath => access(dirPath).then(() => true, () => false)
-
-/**
- * Delete a directory and everything in it, resolving only once it is really gone.
- *
- * A single rm can leave a directory behind - most often when something is still writing into it (a build task, a
- * watcher, a dev server) or has it briefly locked (EBUSY/EPERM/ENOTEMPTY) - which silently leaves stale output for
- * the next build. So: Node's own retry-with-back-off handles the transient errors, then the directory is checked and
- * removed again if it was recreated, and a clear error is raised rather than carrying on with stale output.
- * @memberOf module:partials
- * @param {string} dirPath
- * @returns {Promise<string>} Resolves with dirPath once the directory no longer exists (or already didn't).
- * @throws {Error} If the directory still exists after several attempts.
- */
-export const removeDirectory = async dirPath => {
-  for (let attempt = 1; attempt <= attempts; attempt++) {
-    await rm(dirPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
-    if (!await exists(dirPath)) {
-      return dirPath
-    }
-    if (attempt < attempts) {
-      await sleep(200 * attempt)
-    }
-  }
-  throw new Error(
-    `Unable to remove "${dirPath}" - it was recreated or is locked. Stop anything that has it open or is writing ` +
-    'into it (watchers, dev servers, editors, other build tasks) and try again.'
-  )
-}
+import { access, rm } from 'node:fs/promises'
+import { setTimeout as sleep } from 'node:timers/promises'
+
+const attempts = 4
+
+const exists = dirPath => access(dirPath).then(() => true, () => false)
+
+/**
+ * Delete a directory and everything in it, resolving only once it is really gone.
+ *
+ * A single rm can leave a directory behind - most often when something is still writing into it (a build task, a
+ * watcher, a dev server) or has it briefly locked (EBUSY/EPERM/ENOTEMPTY) - which silently leaves stale output for
+ * the next build. So: Node's own retry-with-back-off handles the transient errors, then the directory is checked and
+ * removed again if it was recreated, and a clear error is raised rather than carrying on with stale output.
+ * @memberOf module:partials
+ * @param {string} dirPath
+ * @returns {Promise<string>} Resolves with dirPath once the directory no longer exists (or already didn't).
+ * @throws {Error} If the directory still exists after several attempts.
+ */
+export const removeDirectory = async dirPath => {
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    await rm(dirPath, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
+    if (!await exists(dirPath)) {
+      return dirPath
+    }
+    if (attempt < attempts) {
+      await sleep(200 * attempt)
+    }
+  }
+  throw new Error(
+    `Unable to remove "${dirPath}" - it was recreated or is locked. Stop anything that has it open or is writing ` +
+    'into it (watchers, dev servers, editors, other build tasks) and try again.'
+  )
+}

package/functions/partials/removeDirectory.test.mjs

@@ -1,72 +1,72 @@
-import fs from 'fs'
-import { rm } from 'node:fs/promises'
-import { removeDirectory } from './removeDirectory.mjs'
-
-// Wrap rm so tests can simulate something recreating the directory while (or right after) it is deleted.
-jest.mock('node:fs/promises', () => {
-  const actual = jest.requireActual('node:fs/promises')
-  return { ...actual, rm: jest.fn(actual.rm) }
-})
-const { rm: realRm } = jest.requireActual('node:fs/promises')
-
-const dirPath = 'remove-directory'
-const recreateAfterRemoving = async (target, options) => {
-  await realRm(target, options)
-  fs.mkdirSync(target)
-}
-
-afterEach(() => {
-  rm.mockReset()
-  rm.mockImplementation(realRm)
-  fs.rmSync(dirPath, { recursive: true, force: true })
-})
-
-describe('removeDirectory', () => {
-  test('able to delete the remove-directory', async () => {
-    const dirPath = 'remove-directory'
-    fs.mkdirSync(dirPath)
-    expect(fs.existsSync(dirPath)).toBeTruthy()
-    await removeDirectory(dirPath)
-    expect(fs.existsSync(dirPath)).toBeFalsy()
-  })
-
-  test('able to delete directory with sub-directories', async () => {
-    const dirPath = 'remove-directory'
-    fs.mkdirSync(dirPath)
-    const subDir = `${dirPath}/sub`
-    fs.mkdirSync(subDir)
-    expect(fs.existsSync(subDir)).toBeTruthy()
-    await removeDirectory(dirPath)
-    expect(fs.existsSync(subDir)).toBeFalsy()
-  })
-
-  test('ends cleanly if directory does not exist', async () => {
-    const dirPath = 'remove-directory'
-    expect(fs.existsSync(dirPath)).toBeFalsy()
-    expect(await removeDirectory(dirPath)).toBe(dirPath)
-  })
-
-  test('removes with force and Node\'s built-in retry-with-back-off for busy or locked directories', async () => {
-    expect.assertions(1)
-    fs.mkdirSync(dirPath)
-    await removeDirectory(dirPath)
-    expect(rm).toHaveBeenCalledWith(dirPath, expect.objectContaining({ recursive: true, force: true, maxRetries: 5 }))
-  })
-
-  test('removes the directory again when something recreates it right after the first removal', async () => {
-    expect.assertions(2)
-    fs.mkdirSync(dirPath)
-    rm.mockImplementationOnce(recreateAfterRemoving)
-    await removeDirectory(dirPath)
-    expect(fs.existsSync(dirPath)).toBeFalsy()
-    expect(rm).toHaveBeenCalledTimes(2)
-  })
-
-  test('fails with a clear error instead of leaving stale output when the directory keeps coming back', async () => {
-    expect.assertions(2)
-    fs.mkdirSync(dirPath)
-    rm.mockImplementation(recreateAfterRemoving)
-    await expect(removeDirectory(dirPath)).rejects.toThrow(/Unable to remove "remove-directory" - it was recreated or is locked/)
-    expect(rm).toHaveBeenCalledTimes(4)
-  })
-})
+import fs from 'fs'
+import { rm } from 'node:fs/promises'
+import { removeDirectory } from './removeDirectory.mjs'
+
+// Wrap rm so tests can simulate something recreating the directory while (or right after) it is deleted.
+jest.mock('node:fs/promises', () => {
+  const actual = jest.requireActual('node:fs/promises')
+  return { ...actual, rm: jest.fn(actual.rm) }
+})
+const { rm: realRm } = jest.requireActual('node:fs/promises')
+
+const dirPath = 'remove-directory'
+const recreateAfterRemoving = async (target, options) => {
+  await realRm(target, options)
+  fs.mkdirSync(target)
+}
+
+afterEach(() => {
+  rm.mockReset()
+  rm.mockImplementation(realRm)
+  fs.rmSync(dirPath, { recursive: true, force: true })
+})
+
+describe('removeDirectory', () => {
+  test('able to delete the remove-directory', async () => {
+    const dirPath = 'remove-directory'
+    fs.mkdirSync(dirPath)
+    expect(fs.existsSync(dirPath)).toBeTruthy()
+    await removeDirectory(dirPath)
+    expect(fs.existsSync(dirPath)).toBeFalsy()
+  })
+
+  test('able to delete directory with sub-directories', async () => {
+    const dirPath = 'remove-directory'
+    fs.mkdirSync(dirPath)
+    const subDir = `${dirPath}/sub`
+    fs.mkdirSync(subDir)
+    expect(fs.existsSync(subDir)).toBeTruthy()
+    await removeDirectory(dirPath)
+    expect(fs.existsSync(subDir)).toBeFalsy()
+  })
+
+  test('ends cleanly if directory does not exist', async () => {
+    const dirPath = 'remove-directory'
+    expect(fs.existsSync(dirPath)).toBeFalsy()
+    expect(await removeDirectory(dirPath)).toBe(dirPath)
+  })
+
+  test('removes with force and Node\'s built-in retry-with-back-off for busy or locked directories', async () => {
+    expect.assertions(1)
+    fs.mkdirSync(dirPath)
+    await removeDirectory(dirPath)
+    expect(rm).toHaveBeenCalledWith(dirPath, expect.objectContaining({ recursive: true, force: true, maxRetries: 5 }))
+  })
+
+  test('removes the directory again when something recreates it right after the first removal', async () => {
+    expect.assertions(2)
+    fs.mkdirSync(dirPath)
+    rm.mockImplementationOnce(recreateAfterRemoving)
+    await removeDirectory(dirPath)
+    expect(fs.existsSync(dirPath)).toBeFalsy()
+    expect(rm).toHaveBeenCalledTimes(2)
+  })
+
+  test('fails with a clear error instead of leaving stale output when the directory keeps coming back', async () => {
+    expect.assertions(2)
+    fs.mkdirSync(dirPath)
+    rm.mockImplementation(recreateAfterRemoving)
+    await expect(removeDirectory(dirPath)).rejects.toThrow(/Unable to remove "remove-directory" - it was recreated or is locked/)
+    expect(rm).toHaveBeenCalledTimes(4)
+  })
+})

package/functions/partials/resolveDocsMethod.mjs

@@ -1,10 +1,10 @@
-import * as gulpConfig from '../../gulp.config.mjs'
-
-/**
- * Pick which engine generates the HTML documentation: docs.method picks it explicitly; left unset (false, the
- * default), it's inferred from typescript.enabled - every existing TypeScript project's config, which never
- * sets method, keeps producing TypeDoc output exactly as it always has.
- * @memberOf module:partials
- * @returns {'typedoc'|'jsdoc'}
- */
-export const resolveDocsMethod = () => gulpConfig.get('docs.method') || (gulpConfig.get('typescript.enabled') ? 'typedoc' : 'jsdoc')
+import * as gulpConfig from '../../gulp.config.mjs'
+
+/**
+ * Pick which engine generates the HTML documentation: docs.method picks it explicitly; left unset (false, the
+ * default), it's inferred from typescript.enabled - every existing TypeScript project's config, which never
+ * sets method, keeps producing TypeDoc output exactly as it always has.
+ * @memberOf module:partials
+ * @returns {'typedoc'|'jsdoc'}
+ */
+export const resolveDocsMethod = () => gulpConfig.get('docs.method') || (gulpConfig.get('typescript.enabled') ? 'typedoc' : 'jsdoc')

package/functions/partials/resolveDocsMethod.test.mjs

@@ -1,33 +1,33 @@
-import * as setUp from '../test-helpers/setUp.mjs'
-import { resolveDocsMethod } from './resolveDocsMethod.mjs'
-
-setUp.setDefaults('test-resolve-docs-method')
-const gulpConfig = setUp.gulpConfig
-
-beforeEach(setUp.beforeEach)
-
-afterEach(setUp.afterEach)
-
-describe('resolveDocsMethod', () => {
-  test('infers jsdoc when typescript.enabled is false and docs.method is unset', () => {
-    gulpConfig.set('typescript.enabled', false)
-    gulpConfig.set('docs.method', false)
-    expect(resolveDocsMethod()).toBe('jsdoc')
-  })
-
-  test('infers typedoc when typescript.enabled is true and docs.method is unset', () => {
-    gulpConfig.set('typescript.enabled', true)
-    gulpConfig.set('docs.method', false)
-    expect(resolveDocsMethod()).toBe('typedoc')
-  })
-
-  test('docs.method overrides the typescript.enabled inference either way', () => {
-    gulpConfig.set('typescript.enabled', true)
-    gulpConfig.set('docs.method', 'jsdoc')
-    expect(resolveDocsMethod()).toBe('jsdoc')
-
-    gulpConfig.set('typescript.enabled', false)
-    gulpConfig.set('docs.method', 'typedoc')
-    expect(resolveDocsMethod()).toBe('typedoc')
-  })
-})
+import * as setUp from '../test-helpers/setUp.mjs'
+import { resolveDocsMethod } from './resolveDocsMethod.mjs'
+
+setUp.setDefaults('test-resolve-docs-method')
+const gulpConfig = setUp.gulpConfig
+
+beforeEach(setUp.beforeEach)
+
+afterEach(setUp.afterEach)
+
+describe('resolveDocsMethod', () => {
+  test('infers jsdoc when typescript.enabled is false and docs.method is unset', () => {
+    gulpConfig.set('typescript.enabled', false)
+    gulpConfig.set('docs.method', false)
+    expect(resolveDocsMethod()).toBe('jsdoc')
+  })
+
+  test('infers typedoc when typescript.enabled is true and docs.method is unset', () => {
+    gulpConfig.set('typescript.enabled', true)
+    gulpConfig.set('docs.method', false)
+    expect(resolveDocsMethod()).toBe('typedoc')
+  })
+
+  test('docs.method overrides the typescript.enabled inference either way', () => {
+    gulpConfig.set('typescript.enabled', true)
+    gulpConfig.set('docs.method', 'jsdoc')
+    expect(resolveDocsMethod()).toBe('jsdoc')
+
+    gulpConfig.set('typescript.enabled', false)
+    gulpConfig.set('docs.method', 'typedoc')
+    expect(resolveDocsMethod()).toBe('typedoc')
+  })
+})

package/functions/partials/runOnChange.mjs

@@ -1,54 +1,54 @@
-import * as gulpConfig from '../../gulp.config.mjs'
-import { bundle } from '../bundle.mjs'
-import { distSeries } from './distSeries.mjs'
-import { parallel, series } from 'gulp'
-import { testQuick } from '../testQuick.mjs'
-
-/**
- * Run this function when the watched files are modified.
- * 1. Find the sub-folders within src path
- * 2. Maintain the folders, but use distPath for base
- * 3. Remove base folder and return dist path with correct sub-folders
- * @example
- * // Configured paths
- * distPath = 'dist'
- * srcPath = 'functions'
- *
- * // Path parameter
- * path = 'functions/some/path/file.js'
- *
- * // Generated regex using configured srcPath
- * pathRegex = '/^functions(.*\/).+\.js$/i'
- *
- * // Replace value using the configured distPath
- * replacePath = 'dist$1'
- *
- * // The resulting replaced path for the destination folder
- * distPathResult = 'dist/some/path/'
- * @memberOf module:partials
- * @param {string} path
- * @returns {stream.Stream}
- */
-export const runOnChange = path => {
-  const useTs = gulpConfig.get('typescript.enabled')
-  const distPath = gulpConfig.get('dist.to')
-  const srcPath = gulpConfig.get('srcPath')
-  /**
-   * 1. The original path comes in from src and is a .ts
-   * 2. Discover the outgoing dist path where that file should go
-   * 3. Use the path and dist in tsFor
-   * 4. Take the original path, convert to full file path in dist
-   * 5. Use the dist path found previously in #2
-   * 6. Use the full dist path and the dist outgoing path in distFor
-   */
-  const pathRegex = new RegExp(`^${srcPath}(.*\\/)(.+)\\.(js|ts)$`, 'i')
-  const distPathResult = path.replace(pathRegex, `${distPath}$1`)
-  let distSrcPath = path
-  if (useTs) {
-    distSrcPath = path.replace(pathRegex, `${distPath}$1$2.js`)
-  }
-  const runSeries = distSeries(distSrcPath, distPathResult, path)
-  return gulpConfig.get('browser.enabled')
-    ? parallel(testQuick, series(runSeries, bundle))()
-    : series(testQuick, runSeries)()
-}
+import * as gulpConfig from '../../gulp.config.mjs'
+import { bundle } from '../bundle.mjs'
+import { distSeries } from './distSeries.mjs'
+import { parallel, series } from 'gulp'
+import { testQuick } from '../testQuick.mjs'
+
+/**
+ * Run this function when the watched files are modified.
+ * 1. Find the sub-folders within src path
+ * 2. Maintain the folders, but use distPath for base
+ * 3. Remove base folder and return dist path with correct sub-folders
+ * @example
+ * // Configured paths
+ * distPath = 'dist'
+ * srcPath = 'functions'
+ *
+ * // Path parameter
+ * path = 'functions/some/path/file.js'
+ *
+ * // Generated regex using configured srcPath
+ * pathRegex = '/^functions(.*\/).+\.js$/i'
+ *
+ * // Replace value using the configured distPath
+ * replacePath = 'dist$1'
+ *
+ * // The resulting replaced path for the destination folder
+ * distPathResult = 'dist/some/path/'
+ * @memberOf module:partials
+ * @param {string} path
+ * @returns {stream.Stream}
+ */
+export const runOnChange = path => {
+  const useTs = gulpConfig.get('typescript.enabled')
+  const distPath = gulpConfig.get('dist.to')
+  const srcPath = gulpConfig.get('srcPath')
+  /**
+   * 1. The original path comes in from src and is a .ts
+   * 2. Discover the outgoing dist path where that file should go
+   * 3. Use the path and dist in tsFor
+   * 4. Take the original path, convert to full file path in dist
+   * 5. Use the dist path found previously in #2
+   * 6. Use the full dist path and the dist outgoing path in distFor
+   */
+  const pathRegex = new RegExp(`^${srcPath}(.*\\/)(.+)\\.(js|ts)$`, 'i')
+  const distPathResult = path.replace(pathRegex, `${distPath}$1`)
+  let distSrcPath = path
+  if (useTs) {
+    distSrcPath = path.replace(pathRegex, `${distPath}$1$2.js`)
+  }
+  const runSeries = distSeries(distSrcPath, distPathResult, path)
+  return gulpConfig.get('browser.enabled')
+    ? parallel(testQuick, series(runSeries, bundle))()
+    : series(testQuick, runSeries)()
+}

package/functions/partials/runOnChange.test.mjs

@@ -1,95 +1,95 @@
-/* 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 { bundle } from '../bundle.mjs'
-import { distFor } from './distFor.mjs'
-import { runOnChange } from './runOnChange.mjs'
-import { tsFor } from './tsFor.mjs'
-import { testQuick } from '../testQuick.mjs'
-
-setUp.setDefaults('test-run-on-change')
-const gulpConfig = setUp.gulpConfig
-
-const genericFunction = () => Promise.resolve(true)
-
-jest.mock('../bundle.mjs', () => ({ bundle: jest.fn(genericFunction) }))
-jest.mock('./distFor.mjs', () => ({ distFor: jest.fn(genericFunction) }))
-jest.mock('./tsFor.mjs', () => ({ tsFor: jest.fn(() => genericFunction) }))
-jest.mock('../testQuick.mjs', () => ({ testQuick: jest.fn(genericFunction) }))
-
-const rawContents = 'export function sayHello(name: string) {\n' +
-  '  return `Hello from ${name}`;\n' +
-  '}'
-
-const distPath = gulpConfig.get('dist.to') + '/'
-const srcPath = gulpConfig.get('srcPath')
-const srcFile = `${srcPath}/runOnChange.js`
-const srcTsFile = `${srcPath}/runOnChange.ts`
-
-beforeEach(() => {
-  return setUp.beforeEach()
-    .then(() => fs.writeFileSync(srcTsFile, rawContents))
-    .then(() => fs.writeFileSync(srcFile, rawContents))
-}
-)
-
-afterEach(() => {
-  jest.clearAllMocks()
-  return setUp.afterEach()
-})
-
-describe('runOnChange', () => {
-  test('runs testQuick and distFor for nodeOnly true and useTs false', done => {
-    gulpConfig.set('browser.enabled', false)
-    gulpConfig.set('typescript.enabled', false)
-    expect.assertions(2)
-    runOnChange(srcFile)
-    setTimeout(() => {
-      expect(testQuick).toHaveBeenCalled()
-      expect(distFor).toHaveBeenCalledWith(srcFile, distPath)
-      done()
-    }, 500)
-  })
-
-  test('runs testQuick and distFor for nodeOnly true and tsFor for useTs true', done => {
-    gulpConfig.set('browser.enabled', false)
-    gulpConfig.set('typescript.enabled', true)
-    const distSrcPath = distPath + 'runOnChange.js'
-    expect.assertions(3)
-    runOnChange(srcTsFile)
-    setTimeout(() => {
-      expect(testQuick).toHaveBeenCalled()
-      expect(tsFor).toHaveBeenCalledWith(srcTsFile, distPath)
-      expect(distFor).toHaveBeenCalledWith(distSrcPath, distPath)
-      done()
-    }, 500)
-  })
-
-  test('runs testQuick and distFor then bundle for nodeOnly false and useTs false', done => {
-    gulpConfig.set('browser.enabled', true)
-    gulpConfig.set('typescript.enabled', false)
-    expect.assertions(3)
-    runOnChange(srcFile)
-    setTimeout(() => {
-      expect(testQuick).toHaveBeenCalled()
-      expect(distFor).toHaveBeenCalledWith(srcFile, distPath)
-      expect(bundle).toHaveBeenCalled()
-      done()
-    }, 500)
-  })
-
-  test('runs testQuick and distFor then bundle for nodeOnly false and tsFor for useTs true', done => {
-    gulpConfig.set('browser.enabled', true)
-    gulpConfig.set('typescript.enabled', true)
-    const distSrcPath = distPath + 'runOnChange.js'
-    expect.assertions(4)
-    runOnChange(srcTsFile)
-    setTimeout(() => {
-      expect(testQuick).toHaveBeenCalled()
-      expect(tsFor).toHaveBeenCalledWith(srcTsFile, distPath)
-      expect(distFor).toHaveBeenCalledWith(distSrcPath, distPath)
-      expect(bundle).toHaveBeenCalled()
-      done()
-    }, 500)
-  })
-})
+/* 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 { bundle } from '../bundle.mjs'
+import { distFor } from './distFor.mjs'
+import { runOnChange } from './runOnChange.mjs'
+import { tsFor } from './tsFor.mjs'
+import { testQuick } from '../testQuick.mjs'
+
+setUp.setDefaults('test-run-on-change')
+const gulpConfig = setUp.gulpConfig
+
+const genericFunction = () => Promise.resolve(true)
+
+jest.mock('../bundle.mjs', () => ({ bundle: jest.fn(genericFunction) }))
+jest.mock('./distFor.mjs', () => ({ distFor: jest.fn(genericFunction) }))
+jest.mock('./tsFor.mjs', () => ({ tsFor: jest.fn(() => genericFunction) }))
+jest.mock('../testQuick.mjs', () => ({ testQuick: jest.fn(genericFunction) }))
+
+const rawContents = 'export function sayHello(name: string) {\n' +
+  '  return `Hello from ${name}`;\n' +
+  '}'
+
+const distPath = gulpConfig.get('dist.to') + '/'
+const srcPath = gulpConfig.get('srcPath')
+const srcFile = `${srcPath}/runOnChange.js`
+const srcTsFile = `${srcPath}/runOnChange.ts`
+
+beforeEach(() => {
+  return setUp.beforeEach()
+    .then(() => fs.writeFileSync(srcTsFile, rawContents))
+    .then(() => fs.writeFileSync(srcFile, rawContents))
+}
+)
+
+afterEach(() => {
+  jest.clearAllMocks()
+  return setUp.afterEach()
+})
+
+describe('runOnChange', () => {
+  test('runs testQuick and distFor for nodeOnly true and useTs false', done => {
+    gulpConfig.set('browser.enabled', false)
+    gulpConfig.set('typescript.enabled', false)
+    expect.assertions(2)
+    runOnChange(srcFile)
+    setTimeout(() => {
+      expect(testQuick).toHaveBeenCalled()
+      expect(distFor).toHaveBeenCalledWith(srcFile, distPath)
+      done()
+    }, 500)
+  })
+
+  test('runs testQuick and distFor for nodeOnly true and tsFor for useTs true', done => {
+    gulpConfig.set('browser.enabled', false)
+    gulpConfig.set('typescript.enabled', true)
+    const distSrcPath = distPath + 'runOnChange.js'
+    expect.assertions(3)
+    runOnChange(srcTsFile)
+    setTimeout(() => {
+      expect(testQuick).toHaveBeenCalled()
+      expect(tsFor).toHaveBeenCalledWith(srcTsFile, distPath)
+      expect(distFor).toHaveBeenCalledWith(distSrcPath, distPath)
+      done()
+    }, 500)
+  })
+
+  test('runs testQuick and distFor then bundle for nodeOnly false and useTs false', done => {
+    gulpConfig.set('browser.enabled', true)
+    gulpConfig.set('typescript.enabled', false)
+    expect.assertions(3)
+    runOnChange(srcFile)
+    setTimeout(() => {
+      expect(testQuick).toHaveBeenCalled()
+      expect(distFor).toHaveBeenCalledWith(srcFile, distPath)
+      expect(bundle).toHaveBeenCalled()
+      done()
+    }, 500)
+  })
+
+  test('runs testQuick and distFor then bundle for nodeOnly false and tsFor for useTs true', done => {
+    gulpConfig.set('browser.enabled', true)
+    gulpConfig.set('typescript.enabled', true)
+    const distSrcPath = distPath + 'runOnChange.js'
+    expect.assertions(4)
+    runOnChange(srcTsFile)
+    setTimeout(() => {
+      expect(testQuick).toHaveBeenCalled()
+      expect(tsFor).toHaveBeenCalledWith(srcTsFile, distPath)
+      expect(distFor).toHaveBeenCalledWith(distSrcPath, distPath)
+      expect(bundle).toHaveBeenCalled()
+      done()
+    }, 500)
+  })
+})

package/functions/partials/sassFor.mjs

@@ -1,25 +1,25 @@
-import { dest, src } from 'gulp'
-import * as gulpConfig from '../../gulp.config.mjs'
-import autoprefixer from 'autoprefixer'
-import cssnano from 'cssnano'
-import postcss from 'gulp-postcss'
-import rename from 'gulp-rename'
-import * as sass from 'sass'
-import { default as gulpSass } from 'gulp-sass'
-
-const runSass = gulpSass(sass)
-
-/**
- * Build the CSS for a given source pattern.
- * @memberOf module:partials
- * @param {string|array} [srcSearch='src/config/path/sass/for']
- * @param {string} [cssPath='css/config/path']
- * @returns {stream.Stream}
- */
-export const sassFor = (srcSearch = gulpConfig.get('sass.from'), cssPath = gulpConfig.get('sass.to')) => src(srcSearch)
-  .pipe(runSass().on('error', runSass.logError)) // Passes it through a gulp-sass, log errors to console
-  .pipe(dest(cssPath))
-  // add: false - the old gulp-cssnano only ever removed obsolete vendor prefixes, never added any; keep that.
-  .pipe(postcss([autoprefixer({ add: false }), cssnano()]))
-  .pipe(rename({ extname: '.min.css' }))
-  .pipe(dest(cssPath))
+import { dest, src } from 'gulp'
+import * as gulpConfig from '../../gulp.config.mjs'
+import autoprefixer from 'autoprefixer'
+import cssnano from 'cssnano'
+import postcss from 'gulp-postcss'
+import rename from 'gulp-rename'
+import * as sass from 'sass'
+import { default as gulpSass } from 'gulp-sass'
+
+const runSass = gulpSass(sass)
+
+/**
+ * Build the CSS for a given source pattern.
+ * @memberOf module:partials
+ * @param {string|array} [srcSearch='src/config/path/sass/for']
+ * @param {string} [cssPath='css/config/path']
+ * @returns {stream.Stream}
+ */
+export const sassFor = (srcSearch = gulpConfig.get('sass.from'), cssPath = gulpConfig.get('sass.to')) => src(srcSearch)
+  .pipe(runSass().on('error', runSass.logError)) // Passes it through a gulp-sass, log errors to console
+  .pipe(dest(cssPath))
+  // add: false - the old gulp-cssnano only ever removed obsolete vendor prefixes, never added any; keep that.
+  .pipe(postcss([autoprefixer({ add: false }), cssnano()]))
+  .pipe(rename({ extname: '.min.css' }))
+  .pipe(dest(cssPath))