@npmcli/template-oss 4.21.4 → 4.23.0

package/lib/util/parser.js

@@ -27,7 +27,7 @@ const traverse = (value, visit, keys = []) => {
   }
 }
 
-const fsOk = (code) => (error) => {
+const fsOk = code => error => {
   if (error.code === 'ENOENT') {
     return null
   }
@@ -37,101 +37,114 @@ const fsOk = (code) => (error) => {
 class Base {
   static types = []
   static header = 'This file is automatically added by {{ __NAME__ }}. Do not edit.'
-  comment = (v) => v
+  comment = v => v
   merge = false // supply a merge function which runs on prepare for certain types
   DELETE = template.DELETE
 
-  constructor (target, source, options, fileOptions) {
+  constructor(target, source, options, fileOptions) {
     this.target = target
     this.source = source
     this.options = options
     this.fileOptions = fileOptions
   }
 
-  header () {
+  header() {
     if (typeof this.comment === 'function') {
       return this.comment(this.template(this.constructor.header || ''))
     }
   }
 
-  clean () {
+  clean() {
     if (this.fileOptions.clean) {
       return fs.rm(this.target).catch(fsOk())
     }
     return null
   }
 
-  read (s) {
+  read(s) {
+    if (Array.isArray(s)) {
+      return Promise.all(s.map(f => this.read(f)))
+    }
     return fs.readFile(s, { encoding: 'utf-8' })
   }
 
-  template (s) {
+  template(s) {
+    if (Array.isArray(s)) {
+      return Promise.all(s.map(f => this.template(f)))
+    }
     return template(s, this.options)
   }
 
-  parse (s) {
+  parse(s) {
     return s
   }
 
-  prepare (s) {
+  prepare(s) {
     const header = this.header()
     return header ? `${header}\n\n${s}` : s
   }
 
-  prepareTarget (s) {
+  prepareTarget(s) {
     return s
   }
 
-  toString (s) {
+  toString(s) {
     return s.toString()
   }
 
-  async write (s) {
+  async write(s) {
     // XXX: find more efficient way to do this. we can build all possible dirs before get here
     await fs.mkdir(dirname(this.target), { owner: 'inherit', recursive: true, force: true })
     return fs.writeFile(this.target, this.toString(s), { owner: 'inherit' })
   }
 
-  diffPatch (t, s) {
+  diffPatch(t, s) {
     // create a patch and strip out the filename. if it ends up an empty string
     // then return true since the files are equal
-    return Diff.createPatch('', t.replace(/\r\n/g, '\n'), s.replace(/\r\n/g, '\n'))
-      .split('\n').slice(4).join('\n')
+    return Diff.createPatch('', t.replace(/\r\n/g, '\n'), s.replace(/\r\n/g, '\n')).split('\n').slice(4).join('\n')
   }
 
-  diff (t, s) {
+  diff(t, s) {
     return this.diffPatch(t, s)
   }
 
   // the apply methods are the only ones that should be called publically
   // XXX: everything is allowed to be overridden in base classes but we could
   // find a different solution than making everything public
-  applyWrite () {
-    return Promise.resolve(this.clean())
-      .then(() => this.read(this.source))
-      // replace template vars first, this will throw for nonexistant vars
-      // because it must be parseable after this step
-      .then((s) => this.template(s))
-      // parse into whatever data structure is necessary for maniuplating
-      // diffing, merging, etc. by default its a string
-      .then((s) => {
-        this.sourcePreParse = s
-        return this.parse(s)
-      })
-      // prepare the source for writing and diffing, pass in current
-      // target for merging. errors parsing or preparing targets are ok here
-      .then((s) => this.applyTarget().catch(() => null).then((t) => this.prepare(s, t)))
-      .then((s) => this.write(s))
-  }
-
-  applyTarget () {
-    return Promise.resolve(this.read(this.target))
-      .then((s) => this.parse(s))
-      // for only preparing the target for diffing
-      .then((s) => this.prepareTarget(s))
-  }
-
-  async applyDiff () {
+  applyWrite() {
+    return (
+      Promise.resolve(this.clean())
+        .then(() => this.read(this.source))
+        // replace template vars first, this will throw for nonexistant vars
+        // because it must be parseable after this step
+        .then(s => this.template(s))
+        // parse into whatever data structure is necessary for maniuplating
+        // diffing, merging, etc. by default its a string
+        .then(s => {
+          this.sourcePreParse = s
+          return this.parse(s)
+        })
+        // prepare the source for writing and diffing, pass in current
+        // target for merging. errors parsing or preparing targets are ok here
+        .then(s =>
+          this.applyTarget()
+            .catch(() => null)
+            .then(t => this.prepare(s, t)),
+        )
+        .then(s => this.write(s))
+    )
+  }
+
+  applyTarget() {
+    return (
+      Promise.resolve(this.read(this.target))
+        .then(s => this.parse(s))
+        // for only preparing the target for diffing
+        .then(s => this.prepareTarget(s))
+    )
+  }
+
+  async applyDiff() {
     // handle if old does not exist
     const targetError = 'ETARGETERROR'
     const target = await this.applyTarget().catch(fsOk(targetError))
@@ -142,10 +155,10 @@ class Base {
     }
 
     const source = await Promise.resolve(this.read(this.source))
-      .then((s) => this.template(s))
-      .then((s) => this.parse(s))
+      .then(s => this.template(s))
+      .then(s => this.parse(s))
       // gets the target to diff against in case it needs to merge, etc
-      .then((s) => this.prepare(s, target))
+      .then(s => this.prepare(s, target))
 
     // if there was a target error then there is no need to diff
     // so we just show the source with an error message
@@ -168,28 +181,28 @@ class Base {
 }
 
 class Gitignore extends Base {
-  static types = ['codeowners', '.gitignore']
-  comment = (c) => `# ${c}`
+  static types = ['codeowners', '.gitignore', '.prettierignore']
+  comment = c => `# ${c}`
 }
 
 class Js extends Base {
   static types = ['*.js', '*.cjs']
-  comment = (c) => `/* ${c} */`
+  comment = c => `/* ${c} */`
 }
 
 class Ini extends Base {
   static types = ['*.ini']
-  comment = (c) => `; ${c}`
+  comment = c => `; ${c}`
 
-  toString (s) {
+  toString(s) {
     return typeof s === 'string' ? s : ini.stringify(s)
   }
 
-  parse (s) {
+  parse(s) {
     return typeof s === 'string' ? ini.parse(s) : s
   }
 
-  prepare (s, t) {
+  prepare(s, t) {
     let source = s
     if (typeof this.merge === 'function' && t) {
       source = this.merge(t, s)
@@ -197,7 +210,7 @@ class Ini extends Base {
     return super.prepare(this.toString(source))
   }
 
-  diff (t, s) {
+  diff(t, s) {
     return jsonDiff(this.parse(t), this.parse(s), this.DELETE)
   }
 }
@@ -209,14 +222,14 @@ class IniMerge extends Ini {
 
 class Markdown extends Base {
   static types = ['*.md']
-  comment = (c) => `<!-- ${c} -->`
+  comment = c => `<!-- ${c} -->`
 }
 
 class Yml extends Base {
   static types = ['*.yml']
-  comment = (c) => ` ${c}`
+  comment = c => ` ${c}`
 
-  toString (s) {
+  toString(s) {
     try {
       return s.toString({ lineWidth: 0, indent: 2 })
     } catch (err) {
@@ -225,22 +238,22 @@ class Yml extends Base {
     }
   }
 
-  parse (s) {
+  parse(s) {
     return yaml.parseDocument(s)
   }
 
-  prepare (s) {
+  prepare(s) {
     s.commentBefore = this.header()
     return this.toString(s)
   }
 
-  prepareTarget (s) {
+  prepareTarget(s) {
     return this.toString(s)
   }
 }
 
 class YmlMerge extends Yml {
-  prepare (source, t) {
+  prepare(source, t) {
     if (t === null) {
       // If target does not exist or is in an
       // error state, we cant do anything but write
@@ -250,7 +263,7 @@ class YmlMerge extends Yml {
 
     const key = [].concat(this.key)
 
-    const getId = (node) => {
+    const getId = node => {
       const index = node.items.findIndex(p => p.key?.value === this.id)
       return index !== -1 ? node.items[index].value?.value : node.toJSON()
     }
@@ -278,17 +291,20 @@ class Json extends Base {
   static types = ['*.json']
   // its a json comment! not really but we do add a special key
   // to json objects
-  comment = (c) => ({ [`//${this.options.config.__NAME__}`]: c })
+  comment = c => ({ [`//${this.options.config.__NAME__}`]: c })
 
-  toString (s) {
-    return JSON.stringify(s, (_, v) => v === this.DELETE ? undefined : v, 2).trim() + '\n'
+  toString(s) {
+    return JSON.stringify(s, (_, v) => (v === this.DELETE ? undefined : v), 2).trim() + '\n'
   }
 
-  parse (s) {
+  parse(s) {
+    if (Array.isArray(s)) {
+      return s.map(f => this.parse(f)).reduce((a, f) => this.merge(a, f), {})
+    }
     return jsonParse(s)
   }
 
-  prepare (s, t) {
+  prepare(s, t) {
     let source = s
     if (typeof this.merge === 'function' && t) {
       source = this.merge(t, s)
@@ -296,7 +312,7 @@ class Json extends Base {
     return setFirst(this.header(), source)
   }
 
-  diff (t, s) {
+  diff(t, s) {
     return jsonDiff(t, s, this.DELETE)
   }
 }
@@ -313,7 +329,7 @@ class JsonMergeNoComment extends JsonMerge {
 class PackageJson extends JsonMerge {
   static types = ['package.json']
 
-  async prepare (s, t) {
+  async prepare(s, t) {
     // merge new source with current pkg content
     const update = super.prepare(s, t)
 
@@ -327,7 +343,7 @@ class PackageJson extends JsonMerge {
     return update
   }
 
-  async write (s) {
+  async write(s) {
     const pkg = await NpmPackageJson.load(dirname(this.target))
     pkg.update(s)
     traverse(pkg.content, (keys, value) => {
@@ -369,7 +385,7 @@ for (const parser of Object.values(Parsers)) {
   }
 }
 
-const getParser = (file) => {
+const getParser = file => {
   for (const [type, parser] of parserLookup) {
     if (minimatch(file, type, { nocase: true, dot: true, matchBase: true })) {
       return parser

package/lib/util/path.js

@@ -1,9 +1,9 @@
 const { posix, win32 } = require('path')
 
-const makePosix = (v) => v.split(win32.sep).join(posix.sep)
-const deglob = (v) => makePosix(v).replace(/[/*]+$/, '')
-const posixDir = (v) => `${v === '.' ? '' : deglob(v).replace(/\/$/, '')}${posix.sep}`
-const posixGlob = (str) => `${posixDir(str)}**`
+const makePosix = v => v.split(win32.sep).join(posix.sep)
+const deglob = v => makePosix(v).replace(/[/*]+$/, '')
+const posixDir = v => `${v === '.' ? '' : deglob(v).replace(/\/$/, '')}${posix.sep}`
+const posixGlob = str => `${posixDir(str)}**`
 
 module.exports = {
   makePosix,

package/lib/util/template.js

@@ -1,14 +1,15 @@
 const Handlebars = require('handlebars')
 const { basename, extname, join } = require('path')
+const { Range } = require('semver')
 const fs = require('fs')
 const DELETE = '__DELETE__'
 
-const safeValues = (obj) => Object.entries(obj).map(([key, value]) =>
-  [key, new Handlebars.SafeString(value)])
+const safeValues = obj => Object.entries(obj).map(([key, value]) => [key, new Handlebars.SafeString(value)])
 
-const partialName = (s) => basename(s, extname(s)) // remove extension
-  .replace(/^_/, '') // remove leading underscore
-  .replace(/-([a-z])/g, (_, g) => g.toUpperCase()) // camelcase
+const partialName = s =>
+  basename(s, extname(s)) // remove extension
+    .replace(/^_/, '') // remove leading underscore
+    .replace(/-([a-z])/g, (_, g) => g.toUpperCase()) // camelcase
 
 const makePartials = (dir, isBase) => {
   const partials = fs.readdirSync(dir).reduce((acc, f) => {
@@ -31,14 +32,17 @@ const makePartials = (dir, isBase) => {
   Handlebars.registerPartial(partials)
 }
 
-const setupHandlebars = (dirs) => {
+const setupHandlebars = dirs => {
   Handlebars.registerHelper('obj', ({ hash }) => Object.fromEntries(safeValues(hash)))
+  Handlebars.registerHelper('extGlob', arr => `{${arr.join(',')}}`)
   Handlebars.registerHelper('join', (arr, sep) => arr.join(typeof sep === 'string' ? sep : ', '))
   Handlebars.registerHelper('pluck', (arr, key) => arr.map(a => a[key]))
-  Handlebars.registerHelper('quote', (arr) => arr.map(a => `'${a}'`))
-  Handlebars.registerHelper('last', (arr) => arr[arr.length - 1])
-  Handlebars.registerHelper('json', (c) => JSON.stringify(c))
+  Handlebars.registerHelper('quote', arr => arr.map(a => `'${a}'`))
+  Handlebars.registerHelper('last', arr => arr[arr.length - 1])
+  Handlebars.registerHelper('json', c => JSON.stringify(c))
   Handlebars.registerHelper('del', () => JSON.stringify(DELETE))
+  Handlebars.registerHelper('semverRangeMajor', v => new Range(v).set[0][0].semver.major)
+  Handlebars.registerHelper('lte', (a, b) => a <= b)
 
   if (Array.isArray(dirs)) {
     const [baseDir, ...otherDirs] = dirs

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npmcli/template-oss",
-  "version": "4.21.4",
+  "version": "4.23.0",
   "description": "templated files used in npm CLI team oss projects",
   "main": "lib/content/index.js",
   "bin": {
@@ -10,21 +10,22 @@
     "template-oss-release-manager": "bin/release-manager.js"
   },
   "scripts": {
-    "lint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\"",
-    "lintfix": "npm run lint -- --fix",
+    "lint": "npm run eslint && npm run prettier -- --check",
+    "lintfix": "npm run eslint -- --fix && npm run prettier -- --write",
     "posttest": "npm run lint",
     "snap": "tap",
     "test": "tap",
     "template-oss-apply": "template-oss-apply --force",
     "postlint": "template-oss-check",
     "postinstall": "template-oss-apply",
+    "eslint": "eslint \"**/*.{js,cjs,ts,mjs,jsx,tsx}\"",
+    "prettier": "prettier \"**/*.{js,cjs,ts,mjs,jsx,tsx,json}\"",
     "test-all": "npm run test -ws -iwr --if-present",
-    "lint-all": "npm run lint -ws -iwr --if-present",
-    "test:record": "TAP_SNAPSHOT=1 NOCK_RECORD=1 tap"
+    "lint-all": "npm run lint -ws -iwr --if-present"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/npm/template-oss.git"
+    "url": "git+https://github.com/npm/template-oss.git"
   },
   "keywords": [
     "npm",
@@ -56,7 +57,7 @@
     "minimatch": "^9.0.2",
     "npm-package-arg": "^11.0.1",
     "proc-log": "^4.0.0",
-    "release-please": "16.3.1",
+    "release-please": "16.12.0",
     "semver": "^7.3.5",
     "undici": "^6.7.0",
     "yaml": "^2.1.1"
@@ -66,9 +67,12 @@
     "lib/"
   ],
   "devDependencies": {
+    "@github/prettier-config": "0.0.6",
     "@npmcli/eslint-config": "^4.0.0",
     "@npmcli/template-oss": "file:./",
+    "eslint-config-prettier": "^9.1.0",
     "nock": "^13.3.8",
+    "prettier": "^3.2.5",
     "tap": "^16.0.0"
   },
   "tap": {
@@ -86,7 +90,8 @@
   },
   "templateOSS": {
     "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
-    "publish": true
+    "publish": true,
+    "prettier": true
   },
   "engines": {
     "node": "^18.17.0 || >=20.5.0"

package/lib/release/node-workspace.js

@@ -1,103 +0,0 @@
-const { NodeWorkspace } = require('release-please/build/src/plugins/node-workspace')
-const { parseConventionalCommits } = require('release-please/build/src/commit')
-const { DEPS } = require('./util')
-const { WORKSPACE_MESSAGE } = require('./node-workspace-format')
-
-// This adds a preconfigure method to the release-please node-workspace plugin
-// which fixes https://github.com/googleapis/release-please/issues/2089 for our
-// use case. We should attempt to upstream this to release-please but it
-// fundamentally changes the way the node-workspace plugin behaves so it might
-// not be easy to land. For now we extend the base plugin and add one method
-// which is much better than previously when we needed to fork and maintain
-// release-please ourselves.
-/* istanbul ignore next: TODO fix flaky tests and enable coverage */
-class NpmNodeWorkspace extends NodeWorkspace {
-  updateCandidate (pr) {
-    // no-op so release-please node-workspace plugin does not add
-    // its broken changelog to the workspace releases. our changelog
-    // formatting and the preconfigure method below fix this.
-    return pr
-  }
-
-  async preconfigure (strategiesByPath, commitsByPath, releasesByPath) {
-    // First build a list of all releases that will happen based on the
-    // conventional commits
-    const candidates = []
-    for (const path in strategiesByPath) {
-      const pullRequest = await strategiesByPath[path].buildReleasePullRequest(
-        parseConventionalCommits(commitsByPath[path]),
-        releasesByPath[path]
-      )
-      // Release please types say this sometimes will return undefined but I could not
-      // get any scenario where that was the case. If it was undefined we would want to
-      // just ignore it anyway.
-      /* istanbul ignore else */
-      if (pullRequest) {
-        candidates.push({
-          path,
-          pullRequest,
-          config: this.repositoryConfig[path],
-        })
-      }
-    }
-
-    // Then build the graph of all those releases + any other connected workspaces
-    const { allPackages, candidatesByPackage } = await this.buildAllPackages(candidates)
-    const graph = await this.buildGraph(allPackages)
-    const packageNamesToUpdate = this.packageNamesToUpdate(graph, candidatesByPackage)
-    const graphPackages = this.buildGraphOrder(graph, packageNamesToUpdate)
-
-    // Then build a list of all the updated versions
-    const updatedVersions = {}
-    for (const pkg of graphPackages) {
-      const path = this.pathFromPackage(pkg)
-      const packageName = this.packageNameFromPackage(pkg)
-      const existingCandidate = candidatesByPackage[packageName]
-
-      if (existingCandidate) {
-        // If there is an existing pull request use that version
-        updatedVersions[packageName] = existingCandidate.pullRequest?.version
-      } else {
-        // Otherwise build another pull request (that will be discarded) just
-        // to see what the version would be if it only contained a deps commit.
-        // This is to make sure we use any custom versioning or release strategy.
-        const releasePullRequest = await strategiesByPath[path].buildReleasePullRequest(
-          parseConventionalCommits([{ message: `${DEPS}: ${Math.random()}` }]),
-          releasesByPath[path]
-        )
-        updatedVersions[packageName] = releasePullRequest?.version
-      }
-    }
-
-    // Then go through all the packages again and add deps commits for each
-    // updated workspace
-    for (const pkg of graphPackages) {
-      const path = this.pathFromPackage(pkg)
-      const packageName = this.packageNameFromPackage(pkg)
-      const graphPackage = graph.get(packageName)
-
-      // Update dependency versions add a deps commit to each path so it gets
-      // processed later. This else never happens in our cases because our
-      // packages always have deps, but keeping this around to make it easier to
-      // upstream in the future.
-      /* istanbul ignore else */
-      if (graphPackage.deps) {
-        for (const depName of graphPackage.deps) {
-          const depVersion = updatedVersions[depName]
-          // Same as the above check, we always have a version here but technically
-          // we could not in which it would be safe to ignore it.
-          /* istanbul ignore else */
-          if (depVersion) {
-            commitsByPath[path].push({
-              message: WORKSPACE_MESSAGE(depName, depVersion.toString()),
-            })
-          }
-        }
-      }
-    }
-
-    return strategiesByPath
-  }
-}
-
-module.exports = NpmNodeWorkspace