js-build-tools 5.6.0 → 6.0.0

package/functions/sourceLint.mjs

@@ -0,0 +1,24 @@
+import * as gulpConfig from '../gulp.config.mjs'
+import { dest, src } from 'gulp'
+import { neostandardLint } from './partials/neostandardLint.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.
+ * @memberOf module:js-build-tools
+ * @returns {*}
+ */
+export const sourceLint = () => {
+  const srcPath = gulpConfig.get('srcPath')
+  const ts = gulpConfig.get('typescript.enabled')
+  const patterns = [`${srcPath}/**/*.js`]
+  if (ts) {
+    patterns.push(`${srcPath}/**/*.ts`)
+  }
+  return src(patterns)
+    .pipe(neostandardLint({ fix: true, ts }))
+    .pipe(dest(srcPath))
+}

package/functions/sourceLint.test.mjs

@@ -0,0 +1,73 @@
+import fs from 'fs'
+import * as setUp from './test-helpers/setUp.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 .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)
+})

package/functions/test-helpers/neostandardLintWithRealNeostandard.mjs

@@ -0,0 +1,38 @@
+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 } from \'neostandard\'\n' +
+  'const { text, filePath, cwd, fix, ts, env } = JSON.parse(readFileSync(0, \'utf8\'))\n' +
+  'const eslint = new ESLint({ cwd, fix, overrideConfigFile: true, baseConfig: neostandard({ ts, env }) })\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 }) => 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) }),
+      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)

package/functions/test-helpers/setUp.mjs

@@ -30,6 +30,11 @@ export const setDefaults = (testDir = 'test-temp') => {
   gulpConfig.set('readme.template', `${tempDir}MAIN.md`)
   gulpConfig.set('readme.to', tempDir)
   gulpConfig.set('readme.from', `${srcPath}/**/!(*.test).js`)
+  // Reset explicitly: gulpConfig is a process-wide singleton seeded once from this real project's own
+  // build-tools.config.json, so without this, this project's own real readme.fromEsm value (gulp.config.mjs)
+  // would leak into every test that exercises addToReadme/compileReadme but never sets this path itself -
+  // doing real file I/O and a real jsdoc-to-markdown parse of this project's own, much larger, config file.
+  gulpConfig.set('readme.fromEsm', [])
   gulpConfig.set('rootPath', tempDir)
   gulpConfig.set('sass.from', `${sassPath}/**/*.+(scss|sass)`)
   gulpConfig.set('sass.path', sassPath)

package/functions/utilities/convertMjsFilesForDocs.mjs

@@ -0,0 +1,33 @@
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { esmNamedExportsToCjs } from './esmNamedExportsToCjs.mjs'
+
+/**
+ * Writes a rewritten (see {@link esmNamedExportsToCjs}) copy of each given `.mjs` file into a fresh, unique
+ * directory under the OS temp directory, with a `.js` extension - jsdoc-to-markdown only recognizes `.js` as a
+ * documentable file, regardless of whether its contents are actually CommonJS or ESM (it parses the real ESM
+ * syntax of the rest of a file fine; the extension is the only thing it filters on). Writing outside the project
+ * tree means there is nothing to gitignore and nothing left behind in the project - call the returned `cleanUp`
+ * once done (for example, right after jsdoc-to-markdown has read the files) to remove the temp directory.
+ * @memberOf module:utilities
+ * @param {Array<string>} mjsFilePaths - Real `.mjs` files to convert. An empty array is a safe, cheap no-op.
+ * @returns {{filePaths: Array<string>, cleanUp: function(): void}} The temp `.js` file paths to pass to
+ * jsdoc-to-markdown instead of the real `.mjs` ones, and a function to remove the temp directory afterward.
+ */
+export const convertMjsFilesForDocs = (mjsFilePaths = []) => {
+  if (mjsFilePaths.length === 0) {
+    return { filePaths: [], cleanUp: () => {} }
+  }
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'js-build-tools-docs-'))
+  const filePaths = mjsFilePaths.map((mjsFilePath) => {
+    const tempFilePath = path.join(tempDir, path.basename(mjsFilePath, '.mjs') + '.js')
+    const source = fs.readFileSync(mjsFilePath, 'utf8')
+    fs.writeFileSync(tempFilePath, esmNamedExportsToCjs(source))
+    return tempFilePath
+  })
+  return {
+    filePaths,
+    cleanUp: () => fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}

package/functions/utilities/convertMjsFilesForDocs.test.mjs

@@ -0,0 +1,57 @@
+import fs from 'fs'
+import * as setUp from '../test-helpers/setUp.mjs'
+import { convertMjsFilesForDocs } from './convertMjsFilesForDocs.mjs'
+
+setUp.setDefaults('test-temp-convert-mjs-for-docs')
+const gulpConfig = setUp.gulpConfig
+
+const rawContents = '/**\n' +
+  ' * Say hello with a given name.\n' +
+  ' * @memberOf module:greet\n' +
+  ' * @param {string} name\n' +
+  ' * @returns {string}\n' +
+  ' */\n' +
+  'export const sayHello = name => `Hello from ${name}`\n'
+
+beforeEach(() => setUp.beforeEach()
+  .then(() => fs.writeFileSync(gulpConfig.get('srcPath') + '/greet.mjs', rawContents)))
+
+afterEach(setUp.afterEach)
+
+describe('convertMjsFilesForDocs', () => {
+  test('returns an empty result, with a safe no-op cleanUp, for an empty list', () => {
+    const { filePaths, cleanUp } = convertMjsFilesForDocs([])
+    expect(filePaths).toEqual([])
+    expect(() => cleanUp()).not.toThrow()
+  })
+
+  test('writes a rewritten, doc-parseable .js copy outside the project tree', () => {
+    const mjsFilePath = gulpConfig.get('srcPath') + '/greet.mjs'
+    const { filePaths, cleanUp } = convertMjsFilesForDocs([mjsFilePath])
+
+    expect(filePaths).toHaveLength(1)
+    expect(filePaths[0]).toMatch(/greet\.js$/)
+    expect(filePaths[0]).not.toContain(process.cwd())
+
+    const converted = fs.readFileSync(filePaths[0], 'utf8')
+    expect(converted).toContain('const sayHello = name => `Hello from ${name}`')
+    expect(converted).toContain('module.exports = { sayHello }')
+
+    cleanUp()
+    expect(fs.existsSync(filePaths[0])).toBe(false)
+  })
+
+  test('converts several files into the same temp directory', () => {
+    fs.writeFileSync(gulpConfig.get('srcPath') + '/greetAgain.mjs', rawContents.replace('sayHello', 'sayHelloAgain'))
+    const { filePaths, cleanUp } = convertMjsFilesForDocs([
+      gulpConfig.get('srcPath') + '/greet.mjs',
+      gulpConfig.get('srcPath') + '/greetAgain.mjs'
+    ])
+
+    expect(filePaths).toHaveLength(2)
+    filePaths.forEach(filePath => expect(fs.existsSync(filePath)).toBe(true))
+
+    cleanUp()
+    filePaths.forEach(filePath => expect(fs.existsSync(filePath)).toBe(false))
+  })
+})

package/functions/utilities/esmNamedExportsToCjs.mjs

@@ -0,0 +1,29 @@
+/**
+ * Rewrites named `export const`/`export function`/`export class` declarations to plain declarations plus a
+ * trailing `module.exports = { ... }` - the same shape jsdoc-to-markdown already documents cleanly (a plain
+ * declaration with its own `@memberOf` tag, exported all at once at the bottom), rather than the "exports.name"
+ * longname jsdoc-to-markdown's own ESM-compat layer produces for an inline `export const name = ...`.
+ *
+ * This is a narrow, text-level rewrite for documentation purposes only - it does not execute the module, so it
+ * only has to look enough like the real thing for jsdoc-to-markdown's parser. It handles the common named-export
+ * forms (`export const`, `export function`, `export class`) and leaves everything else (including `export
+ * default`, re-exports, and `export { a, b }` lists) untouched in place - a file using one of those keeps its
+ * own export line as-is, which jsdoc-to-markdown will document however it already does for ESM.
+ * @memberOf module:utilities
+ * @param {string} source - The raw ESM source text (never executed, just rewritten as text).
+ * @returns {string} The rewritten text, safe to write out with a `.js` extension for jsdoc-to-markdown to read.
+ */
+export const esmNamedExportsToCjs = (source) => {
+  const exportedNames = []
+  const rewritten = source.replace(
+    /^export (const|function|class) (\w+)/gm,
+    (match, keyword, name) => {
+      exportedNames.push(name)
+      return `${keyword} ${name}`
+    }
+  )
+  if (exportedNames.length === 0) {
+    return rewritten
+  }
+  return `${rewritten}\n\nmodule.exports = { ${exportedNames.join(', ')} }\n`
+}

package/functions/utilities/esmNamedExportsToCjs.test.mjs

@@ -0,0 +1,47 @@
+import { esmNamedExportsToCjs } from './esmNamedExportsToCjs.mjs'
+
+describe('esmNamedExportsToCjs', () => {
+  test('rewrites a single export const to a plain declaration plus a trailing module.exports', () => {
+    const source = 'export const get = (path) => path\n'
+    const result = esmNamedExportsToCjs(source)
+    expect(result).toContain('const get = (path) => path')
+    expect(result).toContain('module.exports = { get }')
+    expect(result).not.toContain('export const')
+  })
+
+  test('rewrites multiple export const declarations into one module.exports with all the names', () => {
+    const source = 'export const get = () => {}\nexport const set = () => {}\n'
+    const result = esmNamedExportsToCjs(source)
+    expect(result).toContain('const get = () => {}')
+    expect(result).toContain('const set = () => {}')
+    expect(result).toContain('module.exports = { get, set }')
+  })
+
+  test('rewrites export function and export class the same way', () => {
+    const source = 'export function doThing() {}\nexport class Thing {}\n'
+    const result = esmNamedExportsToCjs(source)
+    expect(result).toContain('function doThing() {}')
+    expect(result).toContain('class Thing {}')
+    expect(result).toContain('module.exports = { doThing, Thing }')
+  })
+
+  test('leaves non-export lines and JSDoc comments untouched', () => {
+    const source = '/**\n * A function.\n * @memberOf module:gulpConfig\n */\nexport const get = () => {}\n'
+    const result = esmNamedExportsToCjs(source)
+    expect(result).toContain('/**\n * A function.\n * @memberOf module:gulpConfig\n */\nconst get = () => {}')
+  })
+
+  test('does not add a module.exports block when there is nothing to export', () => {
+    const source = 'import { thing } from \'./thing.mjs\'\nconst local = 1\n'
+    const result = esmNamedExportsToCjs(source)
+    expect(result).toBe(source)
+    expect(result).not.toContain('module.exports')
+  })
+
+  test('leaves export default and other export forms untouched', () => {
+    const source = 'const value = 1\nexport default value\n'
+    const result = esmNamedExportsToCjs(source)
+    expect(result).toContain('export default value')
+    expect(result).not.toContain('module.exports')
+  })
+})

package/gulp.config.mjs

@@ -101,6 +101,9 @@ import { fileExists } from 'test-filesystem'
  * @typedef {Object<string, Setting>} module:gulpConfig~ReadmeConfig
  * @property {StringSetting} file - The name of the output documentation markdown file.
  * @property {StringSetting} from - Location of files to use for compiling documentation into the readme.
+ * @property {ArrayableSetting} fromEsm - Additional `.mjs` files to document alongside `from`, converted on the
+ * fly since the readme generator only recognizes `.js` files - see 'Configure including ESM files in the
+ * generated readme'. Empty by default: a project that never sets this gets exactly the readme it always did.
  * @property {ArrayableSetting} options - Options for formatting the output readme.
  * @property {StringSetting} template - The file which will be pre-fixed to your README.md output.
  * @property {StringSetting} to - The directory to output the readme file in.
@@ -200,6 +203,7 @@ const setDefaults = {
   readme: {
     file: 'README.md',
     from: 'src/**/!(*.test).js',
+    fromEsm: [],
     options: 'utf8',
     template: 'MAIN.md',
     to: './'

package/gulpfile.base.js

@@ -8,18 +8,17 @@
 
 const build = require('./dist/build.js')
 const bundle = require('./dist/bundle.js')
-const bundleLint = require('./dist/bundleLint.js')
 const bundleMinify = require('./dist/bundleMinify.js')
 const compileReadme = require('./dist/compileReadme.js')
 const copyFonts = require('./dist/copyFonts.js')
 const defaultCmd = require('./dist/default.js')
 const dist = require('./dist/dist.js')
-const distLint = require('./dist/distLint.js')
 const distMinify = require('./dist/distMinify.js')
 const gulpConfig = require('./gulp.config.js')
 const images = require('./dist/images.js')
 const partials = require('./dist/partials.js')
 const sass = require('./dist/sass.js')
+const sourceLint = require('./dist/sourceLint.js')
 const testFull = require('./dist/testFull.js')
 const testHelpers = require('./dist/testHelpers.js')
 const testQuick = require('./dist/testQuick.js')
@@ -31,19 +30,18 @@ const watchTest = require('./dist/watchTest.js')
 module.exports = {
   build,
   bundle,
-  bundleLint,
   bundleMinify,
   copyFonts,
   defaultCmd,
   docs: typeDocs,
   dist,
-  distLint,
   distMinify,
   gulpConfig,
   images,
   partials,
   readme: compileReadme,
   sass,
+  sourceLint,
   testFull,
   testHelpers,
   testQuick,

package/gulpfile.base.mjs

@@ -7,18 +7,17 @@
  */
 export { build } from './functions/build.mjs'
 export { bundle } from './functions/bundle.mjs'
-export { bundleLint } from './functions/bundleLint.mjs'
 export { bundleMinify } from './functions/bundleMinify.mjs'
 export { compileReadme as readme } from './functions/compileReadme.mjs'
 export { copyFonts } from './functions/copyFonts.mjs'
 export { defaultCmd } from './functions/default.mjs'
 export { dist } from './functions/dist.mjs'
-export { distLint } from './functions/distLint.mjs'
 export { distMinify } from './functions/distMinify.mjs'
 export * as gulpConfig from './gulp.config.mjs'
 export { images } from './functions/images.mjs'
 export * as partials from './functions/partials.mjs'
 export { sass } from './functions/sass.mjs'
+export { sourceLint } from './functions/sourceLint.mjs'
 export { testFull } from './functions/testFull.mjs'
 export * as testHelpers from './functions/testHelpers.mjs'
 export { testQuick } from './functions/testQuick.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-build-tools",
-  "version": "5.6.0",
+  "version": "6.0.0",
   "description": "Standardised build process with gulp.",
   "main": "gulpfile.base.js",
   "exports": {
@@ -50,12 +50,13 @@
     "@babel/plugin-transform-modules-commonjs": "^7.29.7",
     "@babel/preset-env": "^7.29.7",
     "@babel/preset-typescript": "^7.29.7",
-    "@babel/runtime-corejs3": "^8.0.6",
+    "@babel/runtime-corejs3": "^8.0.7",
     "autoprefixer": "^10.6.1",
     "babel-jest": "^30.5.2",
     "browserify": "^17.0.1",
     "core-js": "^3.50.0",
     "cssnano": "^6.1.2",
+    "eslint": "^10.12.0",
     "glob": "^13.0.6",
     "gulp": "^5.0.1",
     "gulp-babel": "^8.1.0",
@@ -69,11 +70,11 @@
     "jest-environment-jsdom": "^30.5.2",
     "jsdoc-to-markdown": "^9.1.3",
     "merge-stream": "^2.0.0",
-    "postcss": "^8.5.28",
+    "neostandard": "^0.14.1",
+    "postcss": "^8.5.30",
     "regenerator-runtime": "^0.14.1",
-    "sass": "^1.105.0",
-    "standard": "^17.1.2",
-    "test-filesystem": "^1.5.1",
+    "sass": "^1.105.1",
+    "test-filesystem": "^2.0.0",
     "through2": "^4.0.2",
     "vinyl-source-stream": "^2.0.0"
   },

package/dist/bundleLint.js

@@ -1,28 +0,0 @@
-'use strict'
-
-require('core-js/modules/esnext.weak-map.delete-all.js')
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.bundleLint = void 0
-require('core-js/modules/esnext.iterator.constructor.js')
-require('core-js/modules/esnext.iterator.map.js')
-const _gulp = require('gulp')
-const gulpConfig = _interopRequireWildcard(require('../gulp.config.js'))
-const _standardLint = require('./partials/standardLint.js')
-const _getBundleConfigs = require('./utilities/getBundleConfigs.js')
-function _interopRequireWildcard (e, t) { if (typeof WeakMap === 'function') var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; let o; let i; const f = { __proto__: null, default: e }; if (e === null || typeof e !== 'object' && typeof e !== 'function') return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f) } for (const t in e) t !== 'default' && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f })(e, t) }
-/**
- * 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}
- */
-const bundleLint = () => (0, _gulp.src)((0, _getBundleConfigs.getBundleConfigs)().map(({
-  name
-}) => `${gulpConfig.get('browser.to')}/${name}.js`)).pipe((0, _standardLint.standardLint)({
-  fix: true
-})).pipe((0, _gulp.dest)(gulpConfig.get('browser.to')))
-exports.bundleLint = bundleLint

package/dist/bundleLint.min.js

@@ -1 +0,0 @@
-"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.bundleLint=void 0,require("core-js/modules/esnext.iterator.constructor.js"),require("core-js/modules/esnext.iterator.map.js");var _gulp=require("gulp"),gulpConfig=_interopRequireWildcard(require("../gulp.config.js")),_standardLint=require("./partials/standardLint.js"),_getBundleConfigs=require("./utilities/getBundleConfigs.js");function _interopRequireWildcard(e,t){if("function"==typeof WeakMap)var r=new WeakMap,n=new WeakMap;return(_interopRequireWildcard=function(e,t){if(!t&&e&&e.__esModule)return e;var i,o,u={__proto__:null,default:e};if(null===e||"object"!=typeof e&&"function"!=typeof e)return u;if(i=t?n:r){if(i.has(e))return i.get(e);i.set(e,u)}for(const t in e)"default"!==t&&{}.hasOwnProperty.call(e,t)&&((o=(i=Object.defineProperty)&&Object.getOwnPropertyDescriptor(e,t))&&(o.get||o.set)?i(u,t,o):u[t]=e[t]);return u})(e,t)}const bundleLint=()=>(0,_gulp.src)((0,_getBundleConfigs.getBundleConfigs)().map(({name:e})=>`${gulpConfig.get("browser.to")}/${e}.js`)).pipe((0,_standardLint.standardLint)({fix:!0})).pipe((0,_gulp.dest)(gulpConfig.get("browser.to")));exports.bundleLint=bundleLint;

package/dist/distLint.js

@@ -1,20 +0,0 @@
-'use strict'
-
-require('core-js/modules/esnext.weak-map.delete-all.js')
-Object.defineProperty(exports, '__esModule', {
-  value: true
-})
-exports.distLint = void 0
-const gulpConfig = _interopRequireWildcard(require('../gulp.config.js'))
-const _gulp = require('gulp')
-const _standardLint = require('./partials/standardLint.js')
-function _interopRequireWildcard (e, t) { if (typeof WeakMap === 'function') var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; let o; let i; const f = { __proto__: null, default: e }; if (e === null || typeof e !== 'object' && typeof e !== 'function') return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f) } for (const t in e) t !== 'default' && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f })(e, t) }
-/**
- * Applies Standard code style linting to distribution files.
- * @memberOf module:js-build-tools
- * @returns {*}
- */
-const distLint = () => (0, _gulp.src)(gulpConfig.get('browser.from')).pipe((0, _standardLint.standardLint)({
-  fix: true
-})).pipe((0, _gulp.dest)(gulpConfig.get('dist.to')))
-exports.distLint = distLint

package/dist/distLint.min.js

@@ -1 +0,0 @@
-"use strict";require("core-js/modules/esnext.weak-map.delete-all.js"),Object.defineProperty(exports,"__esModule",{value:!0}),exports.distLint=void 0;var gulpConfig=_interopRequireWildcard(require("../gulp.config.js")),_gulp=require("gulp"),_standardLint=require("./partials/standardLint.js");function _interopRequireWildcard(e,t){if("function"==typeof WeakMap)var r=new WeakMap,i=new WeakMap;return(_interopRequireWildcard=function(e,t){if(!t&&e&&e.__esModule)return e;var n,o,s={__proto__:null,default:e};if(null===e||"object"!=typeof e&&"function"!=typeof e)return s;if(n=t?i:r){if(n.has(e))return n.get(e);n.set(e,s)}for(const t in e)"default"!==t&&{}.hasOwnProperty.call(e,t)&&((o=(n=Object.defineProperty)&&Object.getOwnPropertyDescriptor(e,t))&&(o.get||o.set)?n(s,t,o):s[t]=e[t]);return s})(e,t)}const distLint=()=>(0,_gulp.src)(gulpConfig.get("browser.from")).pipe((0,_standardLint.standardLint)({fix:!0})).pipe((0,_gulp.dest)(gulpConfig.get("dist.to")));exports.distLint=distLint;

package/dist/partials/standardLint.js

@@ -1,94 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.standardLint = void 0;
-require("core-js/modules/esnext.iterator.constructor.js");
-require("core-js/modules/esnext.iterator.for-each.js");
-var _nodePath = _interopRequireDefault(require("node:path"));
-var _through = _interopRequireDefault(require("through2"));
-var _loadPeer = require("./loadPeer.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// `standard` (17+) ships ESM-only, see importModule for how it is imported.
-const importStandard = () => (0, _loadPeer.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(_nodePath.default.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}
- */
-const standardLint = ({
-  fix = true
-} = {}, loadStandard = () => importStandard().then(({
-  default: standard
-}) => standard)) => {
-  const totals = {
-    errors: 0,
-    warnings: 0
-  };
-  return _through.default.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();
-  });
-};
-exports.standardLint = standardLint;

package/dist/test-helpers/standardLintWithRealStandard.js

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.standardLint = exports.loadStandardViaSubprocess = void 0;
-require("core-js/modules/es.json.stringify.js");
-var _nodeChild_process = require("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';
-const loadStandardViaSubprocess = () => Promise.resolve({
-  lintText: (text, options) => Promise.resolve().then(() => JSON.parse((0, _nodeChild_process.execFileSync)(process.execPath, ['--input-type=module', '--eval', script], {
-    input: JSON.stringify({
-      text,
-      options
-    }),
-    encoding: 'utf8',
-    cwd: process.cwd(),
-    maxBuffer: 256 * 1024 * 1024
-  })))
-});
-exports.loadStandardViaSubprocess = loadStandardViaSubprocess;
-const actual = jest.requireActual('../partials/standardLint.js');
-
-// Drop-in replacement for the partial module (see jest.mock in the lint/build tests): same API, real Standard.
-const standardLint = options => actual.standardLint(options, loadStandardViaSubprocess);
-exports.standardLint = standardLint;

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')))