js-build-tools 6.6.0 → 6.8.0

package/functions/partials/sassFor.test.mjs

@@ -1,81 +1,81 @@
-import fs from 'fs'
-import * as setUp from '../test-helpers/setUp.mjs'
-import { sassFor } from './sassFor.mjs'
-import { countMatches } from 'test-filesystem'
-
-setUp.setDefaults('test-sass-for')
-const gulpConfig = setUp.gulpConfig
-
-const sassContents = 'html\n' +
-  '  font-size: 62.5%\n' +
-  '  color: #444\n' +
-  '  font-size: 1em\n' +
-  '  line-height: 1.4\n' +
-  '  background-color: #fff\n' +
-  '\n' +
-  'html, body\n' +
-  '  width: 100%\n' +
-  '  height: 100%\n' +
-  '  margin: 0\n' +
-  '  padding: 0\n' +
-  '  position: absolute\n' +
-  '  text-align: center\n' +
-  '\n' +
-  'a\n' +
-  '  outline: none\n' +
-  '  text-decoration: none'
-
-const sassPath = gulpConfig.get('sass.path')
-
-beforeEach(() => setUp.beforeEach().then(() => fs.mkdirSync(sassPath, { recursive: true })))
-
-afterEach(setUp.afterEach)
-
-describe('sassFor', () => {
-  test('copies the sass directory and converts it into css output', done => {
-    const sassFile = `${sassPath}/sassFor.sass`
-    fs.writeFileSync(sassFile, sassContents)
-    expect.assertions(7)
-    const oldContents = fs.readFileSync(sassFile).toString()
-    expect(countMatches(oldContents, ';')).toEqual(0)
-    expect(countMatches(oldContents, ' {')).toEqual(0)
-    expect(countMatches(oldContents, '\n' +
-      '    }')).toEqual(0)
-    const cssPath = gulpConfig.get('sass.to')
-    sassFor(sassFile)
-      .on('finish', () => {
-        expect(fs.existsSync(cssPath)).toBeTruthy()
-        const cssContents = fs.readFileSync(`${cssPath}/sassFor.css`).toString()
-        // Will add braces and semicolons
-        expect(countMatches(cssContents, ';')).toEqual(13)
-        expect(countMatches(cssContents, '{')).toEqual(3)
-        expect(countMatches(cssContents, '}')).toEqual(3)
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done()
-      })
-  })
-
-  test('also writes a minified .min.css next to the css output', done => {
-    const sassFile = `${sassPath}/sassFor.sass`
-    fs.writeFileSync(sassFile, sassContents)
-    expect.assertions(4)
-    const cssPath = gulpConfig.get('sass.to')
-    sassFor(sassFile)
-      .on('finish', () => {
-        const cssContents = fs.readFileSync(`${cssPath}/sassFor.css`).toString()
-        const minContents = fs.readFileSync(`${cssPath}/sassFor.min.css`).toString()
-        expect(minContents.length).toBeLessThan(cssContents.length)
-        expect(countMatches(minContents.trim(), '\n')).toEqual(0)
-        expect(minContents).toContain('outline:none')
-        expect(minContents).toContain('text-align:center')
-        done()
-      })
-      .on('error', error => {
-        console.error('Encountered error', error)
-        done()
-      })
-  })
-})
+import fs from 'fs'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { sassFor } from './sassFor.mjs'
+import { countMatches } from 'test-filesystem'
+
+setUp.setDefaults('test-sass-for')
+const gulpConfig = setUp.gulpConfig
+
+const sassContents = 'html\n' +
+  '  font-size: 62.5%\n' +
+  '  color: #444\n' +
+  '  font-size: 1em\n' +
+  '  line-height: 1.4\n' +
+  '  background-color: #fff\n' +
+  '\n' +
+  'html, body\n' +
+  '  width: 100%\n' +
+  '  height: 100%\n' +
+  '  margin: 0\n' +
+  '  padding: 0\n' +
+  '  position: absolute\n' +
+  '  text-align: center\n' +
+  '\n' +
+  'a\n' +
+  '  outline: none\n' +
+  '  text-decoration: none'
+
+const sassPath = gulpConfig.get('sass.path')
+
+beforeEach(() => setUp.beforeEach().then(() => fs.mkdirSync(sassPath, { recursive: true })))
+
+afterEach(setUp.afterEach)
+
+describe('sassFor', () => {
+  test('copies the sass directory and converts it into css output', done => {
+    const sassFile = `${sassPath}/sassFor.sass`
+    fs.writeFileSync(sassFile, sassContents)
+    expect.assertions(7)
+    const oldContents = fs.readFileSync(sassFile).toString()
+    expect(countMatches(oldContents, ';')).toEqual(0)
+    expect(countMatches(oldContents, ' {')).toEqual(0)
+    expect(countMatches(oldContents, '\n' +
+      '    }')).toEqual(0)
+    const cssPath = gulpConfig.get('sass.to')
+    sassFor(sassFile)
+      .on('finish', () => {
+        expect(fs.existsSync(cssPath)).toBeTruthy()
+        const cssContents = fs.readFileSync(`${cssPath}/sassFor.css`).toString()
+        // Will add braces and semicolons
+        expect(countMatches(cssContents, ';')).toEqual(13)
+        expect(countMatches(cssContents, '{')).toEqual(3)
+        expect(countMatches(cssContents, '}')).toEqual(3)
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done()
+      })
+  })
+
+  test('also writes a minified .min.css next to the css output', done => {
+    const sassFile = `${sassPath}/sassFor.sass`
+    fs.writeFileSync(sassFile, sassContents)
+    expect.assertions(4)
+    const cssPath = gulpConfig.get('sass.to')
+    sassFor(sassFile)
+      .on('finish', () => {
+        const cssContents = fs.readFileSync(`${cssPath}/sassFor.css`).toString()
+        const minContents = fs.readFileSync(`${cssPath}/sassFor.min.css`).toString()
+        expect(minContents.length).toBeLessThan(cssContents.length)
+        expect(countMatches(minContents.trim(), '\n')).toEqual(0)
+        expect(minContents).toContain('outline:none')
+        expect(minContents).toContain('text-align:center')
+        done()
+      })
+      .on('error', error => {
+        console.error('Encountered error', error)
+        done()
+      })
+  })
+})

package/functions/partials/serveStatic.mjs

@@ -1,47 +1,47 @@
-import fs from 'node:fs'
-import http from 'node:http'
-import path from 'node:path'
-
-// A real, previously-undiscovered bug fixed here: without a Content-Type header, a browser enforces strict MIME
-// checking on <script type="module"> and refuses to load it at all - exactly the case this partial exists for.
-const contentTypes = {
-  '.css': 'text/css',
-  '.gif': 'image/gif',
-  '.html': 'text/html',
-  '.ico': 'image/x-icon',
-  '.jpeg': 'image/jpeg',
-  '.jpg': 'image/jpeg',
-  '.js': 'text/javascript',
-  '.json': 'application/json',
-  '.mjs': 'text/javascript',
-  '.png': 'image/png',
-  '.svg': 'image/svg+xml',
-  '.woff': 'font/woff',
-  '.woff2': 'font/woff2'
-}
-
-/**
- * Serve a directory's real files over plain HTTP, for anything that needs a page loaded from a real URL rather
- * than a bare file:// path - most commonly, a page using root-relative asset paths (/browser/...), which a
- * file:// load resolves against the filesystem root instead of the page's own directory.
- * @memberOf module:partials
- * @param {string} rootDir - The directory to serve.
- * @param {number} [port=0] - The port to listen on; 0 picks any free port.
- * @returns {Promise<{server: http.Server, url: string}>} The running server, and its base URL - close the
- * server yourself (server.close()) once done with it.
- */
-export const serveStatic = (rootDir, port = 0) => new Promise((resolve, reject) => {
-  const server = http.createServer((req, res) => {
-    const filePath = path.join(rootDir, decodeURIComponent(req.url.split('?')[0]))
-    fs.readFile(filePath, (error, data) => {
-      if (error) {
-        res.statusCode = 404
-        return res.end(`Not found: ${req.url}`)
-      }
-      res.setHeader('Content-Type', contentTypes[path.extname(filePath)] || 'application/octet-stream')
-      res.end(data)
-    })
-  })
-  server.once('error', reject)
-  server.listen(port, '127.0.0.1', () => resolve({ server, url: `http://127.0.0.1:${server.address().port}` }))
-})
+import fs from 'node:fs'
+import http from 'node:http'
+import path from 'node:path'
+
+// A real, previously-undiscovered bug fixed here: without a Content-Type header, a browser enforces strict MIME
+// checking on <script type="module"> and refuses to load it at all - exactly the case this partial exists for.
+const contentTypes = {
+  '.css': 'text/css',
+  '.gif': 'image/gif',
+  '.html': 'text/html',
+  '.ico': 'image/x-icon',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.js': 'text/javascript',
+  '.json': 'application/json',
+  '.mjs': 'text/javascript',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2'
+}
+
+/**
+ * Serve a directory's real files over plain HTTP, for anything that needs a page loaded from a real URL rather
+ * than a bare file:// path - most commonly, a page using root-relative asset paths (/browser/...), which a
+ * file:// load resolves against the filesystem root instead of the page's own directory.
+ * @memberOf module:partials
+ * @param {string} rootDir - The directory to serve.
+ * @param {number} [port=0] - The port to listen on; 0 picks any free port.
+ * @returns {Promise<{server: http.Server, url: string}>} The running server, and its base URL - close the
+ * server yourself (server.close()) once done with it.
+ */
+export const serveStatic = (rootDir, port = 0) => new Promise((resolve, reject) => {
+  const server = http.createServer((req, res) => {
+    const filePath = path.join(rootDir, decodeURIComponent(req.url.split('?')[0]))
+    fs.readFile(filePath, (error, data) => {
+      if (error) {
+        res.statusCode = 404
+        return res.end(`Not found: ${req.url}`)
+      }
+      res.setHeader('Content-Type', contentTypes[path.extname(filePath)] || 'application/octet-stream')
+      res.end(data)
+    })
+  })
+  server.once('error', reject)
+  server.listen(port, '127.0.0.1', () => resolve({ server, url: `http://127.0.0.1:${server.address().port}` }))
+})

package/functions/partials/serveStatic.test.mjs

@@ -1,71 +1,71 @@
-import fs from 'fs'
-import path from 'node:path'
-import * as setUp from '../test-helpers/setUp.mjs'
-import { serveStatic } from './serveStatic.mjs'
-
-setUp.setDefaults('test-serve-static')
-const gulpConfig = setUp.gulpConfig
-
-const write = (file, contents) => {
-  fs.mkdirSync(path.dirname(file), { recursive: true })
-  fs.writeFileSync(file, contents)
-}
-
-beforeEach(
-  () => setUp.beforeEach().then(() => {
-    const srcPath = gulpConfig.get('srcPath')
-    write(`${srcPath}/index.html`, '<!doctype html><html><body>hello</body></html>')
-    write(`${srcPath}/sub/page.html`, '<!doctype html><html><body>nested</body></html>')
-    write(`${srcPath}/module.js`, 'export default 1')
-  })
-)
-
-afterEach(setUp.afterEach)
-
-describe('serveStatic', () => {
-  test('serves real files from the given directory over a real local HTTP server', async () => {
-    const { server, url } = await serveStatic(gulpConfig.get('srcPath'))
-    try {
-      expect(url).toMatch(/^http:\/\/127\.0\.0\.1:\d+$/)
-      const root = await fetch(`${url}/index.html`)
-      expect(await root.text()).toBe('<!doctype html><html><body>hello</body></html>')
-      const nested = await fetch(`${url}/sub/page.html`)
-      expect(await nested.text()).toBe('<!doctype html><html><body>nested</body></html>')
-    } finally {
-      server.close()
-    }
-  })
-
-  test('sends a real Content-Type, not a blank one - a browser refuses to load a <script type="module"> without one', async () => {
-    const { server, url } = await serveStatic(gulpConfig.get('srcPath'))
-    try {
-      const html = await fetch(`${url}/index.html`)
-      expect(html.headers.get('content-type')).toBe('text/html')
-      const script = await fetch(`${url}/module.js`)
-      expect(script.headers.get('content-type')).toBe('text/javascript')
-    } finally {
-      server.close()
-    }
-  })
-
-  test('responds 404 for a file that does not exist, rather than hanging or throwing', async () => {
-    const { server, url } = await serveStatic(gulpConfig.get('srcPath'))
-    try {
-      const response = await fetch(`${url}/nothing-here.html`)
-      expect(response.status).toBe(404)
-    } finally {
-      server.close()
-    }
-  })
-
-  test('two servers for the same directory each get their own free port', async () => {
-    const first = await serveStatic(gulpConfig.get('srcPath'))
-    const second = await serveStatic(gulpConfig.get('srcPath'))
-    try {
-      expect(first.url).not.toBe(second.url)
-    } finally {
-      first.server.close()
-      second.server.close()
-    }
-  })
-})
+import fs from 'fs'
+import path from 'node:path'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { serveStatic } from './serveStatic.mjs'
+
+setUp.setDefaults('test-serve-static')
+const gulpConfig = setUp.gulpConfig
+
+const write = (file, contents) => {
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.writeFileSync(file, contents)
+}
+
+beforeEach(
+  () => setUp.beforeEach().then(() => {
+    const srcPath = gulpConfig.get('srcPath')
+    write(`${srcPath}/index.html`, '<!doctype html><html><body>hello</body></html>')
+    write(`${srcPath}/sub/page.html`, '<!doctype html><html><body>nested</body></html>')
+    write(`${srcPath}/module.js`, 'export default 1')
+  })
+)
+
+afterEach(setUp.afterEach)
+
+describe('serveStatic', () => {
+  test('serves real files from the given directory over a real local HTTP server', async () => {
+    const { server, url } = await serveStatic(gulpConfig.get('srcPath'))
+    try {
+      expect(url).toMatch(/^http:\/\/127\.0\.0\.1:\d+$/)
+      const root = await fetch(`${url}/index.html`)
+      expect(await root.text()).toBe('<!doctype html><html><body>hello</body></html>')
+      const nested = await fetch(`${url}/sub/page.html`)
+      expect(await nested.text()).toBe('<!doctype html><html><body>nested</body></html>')
+    } finally {
+      server.close()
+    }
+  })
+
+  test('sends a real Content-Type, not a blank one - a browser refuses to load a <script type="module"> without one', async () => {
+    const { server, url } = await serveStatic(gulpConfig.get('srcPath'))
+    try {
+      const html = await fetch(`${url}/index.html`)
+      expect(html.headers.get('content-type')).toBe('text/html')
+      const script = await fetch(`${url}/module.js`)
+      expect(script.headers.get('content-type')).toBe('text/javascript')
+    } finally {
+      server.close()
+    }
+  })
+
+  test('responds 404 for a file that does not exist, rather than hanging or throwing', async () => {
+    const { server, url } = await serveStatic(gulpConfig.get('srcPath'))
+    try {
+      const response = await fetch(`${url}/nothing-here.html`)
+      expect(response.status).toBe(404)
+    } finally {
+      server.close()
+    }
+  })
+
+  test('two servers for the same directory each get their own free port', async () => {
+    const first = await serveStatic(gulpConfig.get('srcPath'))
+    const second = await serveStatic(gulpConfig.get('srcPath'))
+    try {
+      expect(first.url).not.toBe(second.url)
+    } finally {
+      first.server.close()
+      second.server.close()
+    }
+  })
+})

package/functions/partials/tsFor.mjs

@@ -1,92 +1,92 @@
-import { dest, src } from 'gulp'
-import path from 'node:path'
-import * as gulpConfig from '../../gulp.config.mjs'
-import { importModule, requirePeer } from './loadPeer.mjs'
-
-// gulp-ts-compile ships ESM-only (no CJS build - see its own package.json), see importModule for how it is imported.
-const importGulpTsCompile = () => importModule('gulp-ts-compile')
-
-/**
- * Wrap a stream in a promise that resolves once it finishes writing.
- * @memberOf module:partials
- * @param {stream.Stream} stream
- * @returns {Promise<void>}
- */
-const installHint = 'Install it in your project with: npm install --save-dev typescript'
-
-/**
- * Load the project's own copy of TypeScript (an optional peer dependency, only needed when the typescript task is
- * enabled) from the project being built, so projects which do not use TypeScript 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 TypeScript compiler API module.
- * @throws {Error} With install instructions when typescript is not installed.
- */
-export const loadTypescript = (projectPath = process.cwd()) => requirePeer('typescript', { task: 'typescript', installHint, projectPath })
-
-const streamToPromise = (stream) => new Promise((resolve, reject) => {
-  stream.on('finish', resolve)
-  stream.on('error', reject)
-})
-
-/**
- * Read a tsconfig.json file into real typescript.CompilerOptions values, using only TypeScript's stable, current,
- * public config-reading API (the same one `tsc --project` itself uses internally) - never
- * `ts.convertCompilerOptionsFromJson`, which is exactly the kind of internal/legacy surface that broke
- * gulp-typescript when a removed API call started throwing under TypeScript 7.
- * @memberOf module:partials
- * @param {string} configPath - Path to a tsconfig.json file.
- * @returns {ts.CompilerOptions} TypeScript's compiler options
- */
-const readCompilerOptions = (ts, configPath) => {
-  const configFile = ts.readConfigFile(configPath, ts.sys.readFile)
-  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath))
-  return parsedConfig.options
-}
-
-/**
- * Starting at the source directory, find all the ts files and convert them into the distribution directory.
- * @memberOf module:partials
- * @param {string|array} [srcPath='']
- * @param {string} [distPath='']
- * @param {function(): Promise<Function>} [loadTsCompile] - Resolves the `gulp-ts-compile` default export. Real
- * callers should never need to pass this - it exists so tests can inject a stand-in compiler, sidestepping the
- * genuine dynamic `import()` above that this project's current CommonJS-transform-based Jest setup cannot
- * execute without a broader (and riskier) migration to Jest's native ESM support. gulp-ts-compile's own test
- * suite already covers real TypeScript-compile correctness - this function's own tests only need to verify its
- * config resolution and stream wiring.
- * @returns {Function}
- */
-export const tsFor = (
-  srcPath = gulpConfig.get('typescript.from'),
-  distPath = gulpConfig.get('typescript.to'),
-  loadTsCompile = () => importGulpTsCompile().then(({ default: tsCompile }) => tsCompile)
-) => {
-  if (gulpConfig.get('typescript.enabled') === false) {
-    return () => {}
-  }
-  const ts = loadTypescript()
-  const configPath = gulpConfig.get('typescript.config')
-  // When no tsconfig.json is configured, target/module are pinned explicitly rather than left for TypeScript's
-  // own compiler defaults - those defaults have already shifted once across a TypeScript version bump in this
-  // project's own history (silently changing whether output keeps `const`/`let` or downlevels to `var`), and
-  // pinning them keeps this task's output stable across future TypeScript upgrades too. ES5/CommonJS matches
-  // what the downstream babel/browserify bundling pipeline has always assumed it receives.
-  const compilerOptions = configPath
-    ? readCompilerOptions(ts, configPath)
-    : { declaration: true, target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS, esModuleInterop: false }
-  // Accepts gulp's own callback-style task convention (an optional `done`, called once finished) rather than
-  // just returning a Promise, since callers may invoke the returned function directly with a callback instead
-  // of relying on gulp's own runner to observe a returned Promise.
-  return (done) => {
-    const compile = async () => {
-      const tsCompile = await loadTsCompile()
-      const tsResult = src(srcPath).pipe(tsCompile(compilerOptions))
-      await Promise.all([
-        streamToPromise(tsResult.dts.pipe(dest(distPath))),
-        streamToPromise(tsResult.js.pipe(dest(distPath)))
-      ])
-    }
-    return typeof done === 'function' ? compile().then(() => done(), done) : compile()
-  }
-}
+import { dest, src } from 'gulp'
+import path from 'node:path'
+import * as gulpConfig from '../../gulp.config.mjs'
+import { importModule, requirePeer } from './loadPeer.mjs'
+
+// gulp-ts-compile ships ESM-only (no CJS build - see its own package.json), see importModule for how it is imported.
+const importGulpTsCompile = () => importModule('gulp-ts-compile')
+
+/**
+ * Wrap a stream in a promise that resolves once it finishes writing.
+ * @memberOf module:partials
+ * @param {stream.Stream} stream
+ * @returns {Promise<void>}
+ */
+const installHint = 'Install it in your project with: npm install --save-dev typescript'
+
+/**
+ * Load the project's own copy of TypeScript (an optional peer dependency, only needed when the typescript task is
+ * enabled) from the project being built, so projects which do not use TypeScript 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 TypeScript compiler API module.
+ * @throws {Error} With install instructions when typescript is not installed.
+ */
+export const loadTypescript = (projectPath = process.cwd()) => requirePeer('typescript', { task: 'typescript', installHint, projectPath })
+
+const streamToPromise = (stream) => new Promise((resolve, reject) => {
+  stream.on('finish', resolve)
+  stream.on('error', reject)
+})
+
+/**
+ * Read a tsconfig.json file into real typescript.CompilerOptions values, using only TypeScript's stable, current,
+ * public config-reading API (the same one `tsc --project` itself uses internally) - never
+ * `ts.convertCompilerOptionsFromJson`, which is exactly the kind of internal/legacy surface that broke
+ * gulp-typescript when a removed API call started throwing under TypeScript 7.
+ * @memberOf module:partials
+ * @param {string} configPath - Path to a tsconfig.json file.
+ * @returns {ts.CompilerOptions} TypeScript's compiler options
+ */
+const readCompilerOptions = (ts, configPath) => {
+  const configFile = ts.readConfigFile(configPath, ts.sys.readFile)
+  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath))
+  return parsedConfig.options
+}
+
+/**
+ * Starting at the source directory, find all the ts files and convert them into the distribution directory.
+ * @memberOf module:partials
+ * @param {string|array} [srcPath='']
+ * @param {string} [distPath='']
+ * @param {function(): Promise<Function>} [loadTsCompile] - Resolves the `gulp-ts-compile` default export. Real
+ * callers should never need to pass this - it exists so tests can inject a stand-in compiler, sidestepping the
+ * genuine dynamic `import()` above that this project's current CommonJS-transform-based Jest setup cannot
+ * execute without a broader (and riskier) migration to Jest's native ESM support. gulp-ts-compile's own test
+ * suite already covers real TypeScript-compile correctness - this function's own tests only need to verify its
+ * config resolution and stream wiring.
+ * @returns {Function}
+ */
+export const tsFor = (
+  srcPath = gulpConfig.get('typescript.from'),
+  distPath = gulpConfig.get('typescript.to'),
+  loadTsCompile = () => importGulpTsCompile().then(({ default: tsCompile }) => tsCompile)
+) => {
+  if (gulpConfig.get('typescript.enabled') === false) {
+    return () => {}
+  }
+  const ts = loadTypescript()
+  const configPath = gulpConfig.get('typescript.config')
+  // When no tsconfig.json is configured, target/module are pinned explicitly rather than left for TypeScript's
+  // own compiler defaults - those defaults have already shifted once across a TypeScript version bump in this
+  // project's own history (silently changing whether output keeps `const`/`let` or downlevels to `var`), and
+  // pinning them keeps this task's output stable across future TypeScript upgrades too. ES5/CommonJS matches
+  // what the downstream babel/browserify bundling pipeline has always assumed it receives.
+  const compilerOptions = configPath
+    ? readCompilerOptions(ts, configPath)
+    : { declaration: true, target: ts.ScriptTarget.ES5, module: ts.ModuleKind.CommonJS, esModuleInterop: false }
+  // Accepts gulp's own callback-style task convention (an optional `done`, called once finished) rather than
+  // just returning a Promise, since callers may invoke the returned function directly with a callback instead
+  // of relying on gulp's own runner to observe a returned Promise.
+  return (done) => {
+    const compile = async () => {
+      const tsCompile = await loadTsCompile()
+      const tsResult = src(srcPath).pipe(tsCompile(compilerOptions))
+      await Promise.all([
+        streamToPromise(tsResult.dts.pipe(dest(distPath))),
+        streamToPromise(tsResult.js.pipe(dest(distPath)))
+      ])
+    }
+    return typeof done === 'function' ? compile().then(() => done(), done) : compile()
+  }
+}