@npmcli/template-oss 2.9.2 → 3.1.1

package/lib/postinstall/copy-content.js

@@ -1,133 +0,0 @@
-const { dirname, join, resolve } = require('path')
-const fs = require('@npmcli/fs')
-const PackageJson = require('@npmcli/package-json')
-
-const contentDir = resolve(__dirname, '..', 'content')
-
-// keys are destination paths in the target project
-// values are paths to contents relative to '../content/'
-const moduleFiles = {
-  '.eslintrc.js': './eslintrc.js',
-  '.gitignore': './gitignore',
-  '.npmrc': './npmrc',
-  'SECURITY.md': './SECURITY.md',
-}
-
-const repoFiles = {
-  '.commitlintrc.js': './commitlintrc.js',
-  '.github/workflows/ci.yml': './ci.yml',
-  '.github/ISSUE_TEMPLATE/bug.yml': './bug.yml',
-  '.github/ISSUE_TEMPLATE/config.yml': './config.yml',
-  '.github/CODEOWNERS': './CODEOWNERS',
-  '.github/dependabot.yml': './dependabot.yml',
-  '.github/workflows/audit.yml': './audit.yml',
-  '.github/workflows/codeql-analysis.yml': './codeql-analysis.yml',
-  '.github/workflows/post-dependabot.yml': './post-dependabot.yml',
-  '.github/workflows/pull-request.yml': './pull-request.yml',
-  '.github/workflows/release-please.yml': './release-please.yml',
-}
-
-// currently no workspace module files
-// const workspaceModuleFiles = {}
-
-const workspaceRepoFiles = {
-  '.github/workflows/release-please-%%pkgfsname%%.yml': './release-please-workspace.yml',
-  '.github/workflows/ci-%%pkgfsname%%.yml': './ci-workspace.yml',
-}
-
-const filesToDelete = [
-  // remove any eslint config files that aren't local to the project
-  /^\.eslintrc\.(?!(local\.)).*/,
-]
-
-const defaultConfig = {
-  applyRootRepoFiles: true,
-  applyWorkspaceRepoFiles: true,
-  applyRootModuleFiles: true,
-  windowsCI: true,
-}
-
-const findReplace = (str, replace = {}) => {
-  for (const [f, r] of Object.entries(replace)) {
-    str = str.replace(new RegExp(f, 'g'), r)
-  }
-  return str
-}
-
-const copyFile = async (source, target, replacements) => {
-  if (replacements) {
-    const content = await fs.readFile(source, { encoding: 'utf-8' })
-    return fs.writeFile(target, findReplace(content, replacements), { owner: 'inherit' })
-  }
-  return fs.copyFile(source, target, { owner: 'inherit' })
-}
-
-const copyFiles = async (targetDir, files, replacements) => {
-  for (let [target, source] of Object.entries(files)) {
-    target = findReplace(join(targetDir, target), replacements)
-    source = join(contentDir, source)
-    // if the target is a subdirectory of the path, mkdirp it first
-    if (dirname(target) !== targetDir) {
-      await fs.mkdir(dirname(target), {
-        owner: 'inherit',
-        recursive: true,
-        force: true,
-      })
-    }
-    await copyFile(source, target, replacements)
-  }
-}
-
-// given a root directory, copy all files in the content map
-// after purging any files we need to delete
-const copyContent = async (path, rootPath, config) => {
-  config = { ...defaultConfig, ...config }
-  const isWorkspace = path !== rootPath
-
-  const contents = await fs.readdir(path)
-
-  if (isWorkspace || config.applyRootModuleFiles) {
-    // delete files and copy moduleFiles if it's a workspace
-    // or if we enabled doing so for the root
-    for (const file of contents) {
-      if (filesToDelete.some((p) => p.test(file))) {
-        await fs.rm(join(path, file))
-      }
-    }
-    await copyFiles(path, moduleFiles)
-  }
-
-  if (!isWorkspace) {
-    if (config.applyRootRepoFiles) {
-      await copyFiles(rootPath, repoFiles)
-      if (!config.windowsCI) {
-        // copyFiles already did the mkdir so we can just fs.copyFile now
-        await fs.copyFile(
-          join(contentDir, 'ci-no-windows.yml'),
-          join(rootPath, '.github', 'workflows', 'ci.yml')
-        )
-      }
-    }
-    return
-  }
-
-  // only workspace now
-
-  // TODO: await copyFiles(path, workspaceModuleFiles)
-  // if we ever have workspace specific files
-
-  // transform and copy all workspace repo files
-  if (config.applyWorkspaceRepoFiles) {
-    const workspacePkg = (await PackageJson.load(path)).content
-    await copyFiles(rootPath, workspaceRepoFiles, {
-      '%%pkgname%%': workspacePkg.name,
-      '%%pkgfsname%%': workspacePkg.name.replace(/\//g, '-').replace(/@/g, ''),
-      '%%pkgpath%%': path.substring(rootPath.length + 1),
-    })
-  }
-}
-
-copyContent.moduleFiles = moduleFiles
-copyContent.repoFiles = repoFiles
-
-module.exports = copyContent

package/lib/postinstall/update-package.js

@@ -1,100 +0,0 @@
-const PackageJson = require('@npmcli/package-json')
-
-const {
-  version: TEMPLATE_VERSION,
-  name: TEMPLATE_NAME,
-} = require('../../package.json')
-
-const changes = {
-  author: 'GitHub Inc.',
-  files: ['bin', 'lib'],
-  scripts: {
-    lint: `eslint '**/*.js'`,
-    postlint: 'npm-template-check',
-    'template-copy': 'npm-template-copy --force',
-    lintfix: 'npm run lint -- --fix',
-    preversion: 'npm test',
-    postversion: 'npm publish',
-    prepublishOnly: 'git push origin --follow-tags',
-    snap: 'tap',
-    test: 'tap',
-    posttest: 'npm run lint',
-  },
-  engines: {
-    node: '^12.13.0 || ^14.15.0 || >=16',
-  },
-}
-
-const patchPackage = async (path, root, config) => {
-  const pkg = await PackageJson.load(path)
-  config = config || {}
-
-  // If we are running this on itself, we always run the script.
-  // We also don't set templateVersion in package.json because
-  // its not relavent and would cause git churn after running
-  // `npm version`.
-  const isDogfood = pkg.content.name === TEMPLATE_NAME
-  const currentVersion = (pkg.content.templateOSS === undefined) ?
-    pkg.content.templateVersion : pkg.content.templateOSS.version
-
-  // if the target package.json has a templateVersion field matching our own
-  // current version, we return false here so the postinstall script knows to
-  // exit early instead of running everything again
-  if (!config.force
-    && currentVersion === TEMPLATE_VERSION
-    && !isDogfood) {
-    return false
-  }
-
-  const templateConfig = {
-    templateOSS: {
-      ...pkg.content.templateOSS,
-      ...{ version: TEMPLATE_VERSION },
-    },
-  }
-
-  let update
-
-  if (path === root && !config.applyRootModuleFiles) {
-    // only update templateVersion if we're skipping root module files
-    update = {
-      ...templateConfig,
-    }
-  } else {
-    // we build a new object here so our exported set of changes is not modified
-    update = {
-      ...changes,
-      scripts: {
-        ...pkg.content.scripts,
-        ...changes.scripts,
-      },
-      ...templateConfig,
-    }
-  }
-
-  if (isDogfood) {
-    delete update.templateVersion
-    delete update.templateOSS
-  } else {
-    if (pkg.content.templateVersion) {
-      update.templateVersion = undefined
-    }
-    if (pkg.content.scripts && pkg.content.scripts['lint:fix']) {
-      // some old packages using standard had a lint:fix script
-      delete update.scripts['lint:fix']
-    }
-    if (pkg.content.standard) {
-      // remove standard configuration if it exists
-      update.standard = undefined
-    }
-  }
-
-  pkg.update(update)
-
-  await pkg.save()
-  return true
-}
-
-patchPackage.changes = changes
-
-module.exports = patchPackage

package/lib/postlint/check-gitignore.js

@@ -1,59 +0,0 @@
-const path = require('path')
-const fs = require('fs')
-const { sync: which } = require('which')
-const { spawnSync } = require('child_process')
-
-// The problem we are trying to solve is when a new .gitignore file
-// is copied into an existing repo, there could be files already checked in
-// to git that are now ignored by new gitignore rules. We want to warn
-// about these files.
-const check = async (root) => {
-  const git = path.resolve(root, '.git')
-  const gitignore = path.resolve(root, '.gitignore')
-
-  if (!fs.existsSync(git)) {
-    return []
-  }
-
-  if (!fs.existsSync(gitignore)) {
-    throw new Error(`${gitignore} must exist to run npm-template-check`)
-  }
-
-  const res = spawnSync(which('git'), [
-    'ls-files',
-    '--cached',
-    '--ignored',
-    // The .gitignore file has already been placed by now with the postinstall
-    // script so when this script runs via postlint, it can use that file
-    `--exclude-from=${gitignore}`,
-  ], { encoding: 'utf-8', cwd: root })
-
-  const files = res.stdout
-    .trim()
-    .split('\n')
-    .filter(Boolean)
-
-  if (!files.length) {
-    return []
-  }
-
-  const relativeGitignore = path.relative(root, gitignore)
-  const ignores = fs.readFileSync(gitignore)
-    .toString()
-    .split('\n')
-    .filter((l) => l && !l.trim().startsWith('#'))
-
-  const message = [
-    `The following files are tracked by git but matching a pattern in ${relativeGitignore}:`,
-    ...files.map((f) => `  ${f}`),
-  ].join('\n')
-
-  const solution = [
-    'Move files to not match one of these patterns:',
-    ...ignores.map((i) => `  ${i}`),
-  ].join('\n')
-
-  return [{ message, solution }]
-}
-
-module.exports = check

package/lib/postlint/check-package.js

@@ -1,90 +0,0 @@
-const PackageJson = require('@npmcli/package-json')
-const patchPackage = require('../postinstall/update-package.js')
-
-const unwantedPackages = [
-  '@npmcli/lint',
-  'eslint-plugin-promise',
-  'eslint-plugin-standard',
-  'eslint-plugin-import',
-  'standard',
-]
-
-const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key)
-
-const check = async (root) => {
-  const pkg = (await PackageJson.load(root)).content
-  const changes = Object.entries(patchPackage.changes)
-  const problems = []
-  const incorrectFields = []
-  // 1. ensure package.json changes have been applied
-  for (const [key, value] of changes) {
-    if (!hasOwn(pkg, key)) {
-      incorrectFields.push({
-        name: key,
-        found: pkg[key],
-        expected: value,
-      })
-    } else if (value && typeof value === 'object') {
-      for (const [subKey, subValue] of Object.entries(value)) {
-        if (!hasOwn(pkg[key], subKey) ||
-          pkg[key][subKey] !== subValue) {
-          incorrectFields.push({
-            name: `${key}.${subKey}`,
-            found: pkg[key][subKey],
-            expected: subValue,
-          })
-        }
-      }
-    } else {
-      if (pkg[key] !== patchPackage.changes[key]) {
-        incorrectFields.push({
-          name: key,
-          found: pkg[key],
-          expected: value,
-        })
-      }
-    }
-  }
-
-  if (incorrectFields.length) {
-    problems.push({
-      message: [
-        `The following package.json fields are incorrect:`,
-        ...incorrectFields.map((field) => {
-          const message = [
-            'Field:',
-            `${JSON.stringify(field.name)}`,
-            'Expected:',
-            `${JSON.stringify(field.expected)}`,
-            'Found:',
-            `${JSON.stringify(field.found)}`,
-          ].join(' ')
-          return `  ${message}`
-        }),
-      ].join('\n'),
-      solution: 'npm rm @npmcli/template-oss && npm i -D @npmcli/template-oss',
-    })
-  }
-
-  // 2. ensure packages that should not be present are removed
-  const mustRemove = unwantedPackages.filter((name) => {
-    return hasOwn(pkg.dependencies || {}, name) ||
-      hasOwn(pkg.devDependencies || {}, name)
-  })
-
-  if (mustRemove.length) {
-    problems.push({
-      message: [
-        'The following unwanted packages were found:',
-        ...mustRemove.map((p) => `  ${p}`),
-      ].join('\n'),
-      solution: `npm rm ${mustRemove.join(' ')}`,
-    })
-  }
-
-  return problems
-}
-
-check.unwantedPackages = unwantedPackages
-
-module.exports = check