validatePeerDeps.js

const { getWhyCommand, isPnpm } = require('./packageManager');

const { readFile } = require('node:fs/promises');
const { fdir: Fdir } = require('fdir');
const semver = require('semver');
const chalk = require('chalk');

const banner = require('./banner');
const track = require('../telemetry');
const { getPathFromCwd } = require('../lib/cwd');
const { paths } = require('../context');

/**
 * @param {unknown[]} list
 * @param {Function} fn
 */
const asyncMap = (list, fn) => {
  return Promise.all(list.map((item) => fn(item)));
};

const singletonPackages = ['@vanilla-extract/css'];

module.exports = async () => {
  if (isPnpm) {
    // pnpm doesn't nest dependencies in the same way as yarn or npm, so the method used below won't
    // work for detecting duplicate packages
    return;
  }

  try {
    /** @type {string[]} */
    const packages = [];

    const packagesToCheck = [...paths.compilePackages, ...singletonPackages];
    const packageNameByPattern = Object.fromEntries(
      packagesToCheck.map((packageName) => [
        `node_modules/${packageName}/package.json`,
        packageName,
      ]),
    );

    const patterns = Object.keys(packageNameByPattern);

    const results = await new Fdir()
      .withBasePath()
      .filter((file) => patterns.some((pattern) => file.endsWith(pattern)))
      .crawl('node_modules')
      .withPromise();

    for (const [pattern, packageName] of Object.entries(packageNameByPattern)) {
      const resultsForPackage = results.filter((result) =>
        result.endsWith(pattern),
      );

      if (resultsForPackage.length > 1) {
        const messages = [
          chalk`Multiple copies of {bold ${packageName}} are present in node_modules. This is likely to cause errors, but even if it works, it will probably result in an unnecessarily large bundle size.`,
        ];

        messages.push(
          resultsForPackage
            .map((depLocation) => {
              const { version } = require(getPathFromCwd(depLocation));

              return chalk`${depLocation.replace(
                '/package.json',
                '',
              )} ({bold ${version}})`;
            })
            .join('\n'),
        );

        messages.push(
          chalk`Try running "{blue.bold ${getWhyCommand()}} {bold ${packageName}}" to diagnose the issue`,
        );

        track.count('duplicate_compile_package', {
          compile_package: packageName,
        });
        banner('error', 'Error: Duplicate packages detected', messages);

        packages.push(...resultsForPackage);
      }
    }

    const compilePackages = new Map();

    await asyncMap(packages, async (p) => {
      const contents = await readFile(getPathFromCwd(p), {
        encoding: 'utf8',
      });

      const { name, version, peerDependencies = {} } = JSON.parse(contents);

      const peers = new Map();

      Object.keys(peerDependencies)
        .filter((dep) => paths.compilePackages.includes(dep))
        .forEach((dep) => {
          peers.set(dep, peerDependencies[dep]);
        });

      compilePackages.set(name, { version, p, peers });
    });

    for (const [packageName, { peers }] of compilePackages.entries()) {
      for (const [peerName, peerVersionRange] of peers.entries()) {
        const dep = compilePackages.get(peerName);

        if (dep && !semver.satisfies(dep.version, peerVersionRange)) {
          track.count('peer_dep_version_mismatch', {
            compile_package: packageName,
          });

          const peerIsBehind = semver.gtr(dep.version, peerVersionRange);

          const errorMessage = chalk`{bold ${packageName}} expected to find {bold ${peerName}} {yellow ${peerVersionRange}} but found {yellow ${dep.version}}.`;

          const peerBehindMessage = chalk`The best way to fix this is for {bold ${packageName}} to update its peer dependency on {bold ${peerName}}.`;

          const peerAheadMessage = chalk`The best way to fix this is to update your dependency on {bold ${peerName}}.`;

          banner('warning', 'Warning: Package version mismatch', [
            errorMessage,
            peerIsBehind ? peerBehindMessage : peerAheadMessage,
          ]);
        }
      }
    }
  } catch (e) {
    console.log('Error validating peer dependencies');
    console.error(e);
  }
};