feat(peerDependencyMeta): support peerDependencyMeta in package.json to ignore optional peer dependencies

Author: christopherthielen

src/checkPeerDependencies.ts

@@ -23,27 +23,35 @@ function getAllNestedPeerDependencies(options: CliOptions): Dependency[] {
 
 let recursiveCount = 0;
 
-const reportPeerDependencyStatus = (dep: Dependency, byDepender: boolean, force: boolean) => {
+const reportPeerDependencyStatus = (dep: Dependency, byDepender: boolean, showSatisfiedDep: boolean, showOptionalDep: boolean) => {
   const message = byDepender ?
-      `${dep.depender}@${dep.dependerVersion} requires ${dep.name} ${dep.version}` :
-      `${dep.name} ${dep.version} is required by ${dep.depender}@${dep.dependerVersion}`;
+      `${dep.depender.name}@${dep.depender.version} requires ${dep.name} ${dep.version}` :
+      `${dep.name} ${dep.version} is required by ${dep.depender.name}@${dep.depender.version}`;
 
   if (dep.semverSatisfies) {
-    if (force) {
+    if (showSatisfiedDep) {
       console.log(`  ✅  ${message} (${dep.installedVersion} is installed)`);
     }
   } else if (dep.isYalc) {
     console.log(`  ☑️  ${message} (${dep.installedVersion} is installed via yalc)`);
+  } else if (dep.installedVersion && dep.isPeerOptionalDependency) {
+    if (showOptionalDep) {
+      console.log(`  ☑️  ${message}) OPTIONAL (${dep.installedVersion} is installed)`);
+    }
   } else if (dep.installedVersion) {
     console.log(`  ❌  ${message}) (${dep.installedVersion} is installed)`);
+  } else if (dep.isPeerOptionalDependency) {
+    if (showOptionalDep) {
+      console.log(`  ☑️  ${message} OPTIONAL (${dep.name} is not installed)`);
+    }
   } else {
     console.log(`  ❌  ${message} (${dep.name} is not installed)`);
   }
 };
 
 function findSolutions(problems: Dependency[], allNestedPeerDependencies: Dependency[]) {
   console.log();
-  console.log('Searching for solutions...');
+  console.log(`Searching for solutions for ${problems.length} missing dependencies...`);
   console.log();
   const resolutions: Resolution[] = findPossibleResolutions(problems, allNestedPeerDependencies);
   const resolutionsWithSolutions = resolutions.filter(r => r.resolution);
@@ -104,16 +112,17 @@ function report(options: CliOptions, allNestedPeerDependencies: Dependency[]) {
   allNestedPeerDependencies.forEach(dep => {
     const isUnsatisfied = (dep: Dependency) => !dep.semverSatisfies && !dep.isYalc;
     const relatedPeerDeps = allNestedPeerDependencies.filter(other => other.name === dep.name && other !== dep);
-    const force = options.verbose || relatedPeerDeps.some(isUnsatisfied);
-    reportPeerDependencyStatus(dep, options.orderBy === 'depender', force);
+    const showIfSatisfied = options.verbose || relatedPeerDeps.some(isUnsatisfied);
+    const showOptionalDep = options.verbose;
+    reportPeerDependencyStatus(dep, options.orderBy === 'depender', showIfSatisfied, showOptionalDep);
   });
 }
 
 export function checkPeerDependencies(packageManager: string, options: CliOptions) {
   const allNestedPeerDependencies = getAllNestedPeerDependencies(options);
   report(options, allNestedPeerDependencies);
 
-  const problems = allNestedPeerDependencies.filter(dep => !dep.semverSatisfies && !dep.isYalc);
+  const problems = allNestedPeerDependencies.filter(dep => !dep.semverSatisfies && !dep.isYalc && !dep.isPeerOptionalDependency);
 
   if (!problems.length) {
     console.log('  ✅  All peer dependencies are met');

src/packageUtils.ts

@@ -16,41 +16,44 @@ interface PackageJson {
   peerDependencies: {
     [key: string]: string;
   };
+  // deprecated: use peerDependenciesMeta.foo.dev
+  peerDevDependencies: string[];
+  // See: https://github.com/yarnpkg/rfcs/blob/master/accepted/0000-optional-peer-dependencies.md
+  peerDependenciesMeta: {
+    [key: string]: {
+      optional?: boolean;
+      // non-standard
+      dev?: boolean;
+    };
+  };
   optionalDependencies: {
     [key: string]: string;
   };
-
-  // What is a peerDevDependency? This is not a standard.
-  // This is an array of package names found in `peerDependencies` which should be installed as devDependencies.
-  // This addresses a specific use case: to provide downstream projects with package building opinions such as
-  // a specific version of react and rollup and typescript.
-  // Example:
-  // peerDevDependencies: ["rollup", "typescript"]
-  peerDevDependencies: string[];
 }
 
 export interface Dependency {
   name: string;
   version: string;
-  depender: string;
-  dependerPath: string;
-  dependerVersion: string;
+  depender: PackageMeta;
+  type: 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies';
+  isPeerOptionalDependency: boolean;
+  isPeerDevDependency: boolean;
   installedVersion?: string | undefined;
   semverSatisfies?: boolean;
   isYalc?: boolean;
-  isPeerDevDependency?: boolean;
 }
 
-interface PackageDependencies {
-  packageName: string;
+interface PackageMeta {
+  name: string;
+  version: string;
+  packagePath: string;
   dependencies: Dependency[];
   devDependencies: Dependency[];
-  peerDependencies: Dependency[];
   optionalDependencies: Dependency[];
-  peerDevDependencies: string[];
+  peerDependencies: Dependency[];
 }
 
-type DependencyWalkVisitor = (packagePath: string, packageJson: PackageJson, packageDependencies: PackageDependencies) => void;
+type DependencyWalkVisitor = (packagePath: string, packageJson: PackageJson, packageMeta: PackageMeta) => void;
 
 export function gatherPeerDependencies(packagePath, options: CliOptions): Dependency[] {
   let peerDeps: Dependency[] = [];
@@ -80,7 +83,7 @@ export function walkPackageDependencyTree(packagePath: string, visitor: Dependen
   }
 
   const packageJson = readJson(packageJsonPath) as PackageJson;
-  const packageDependencies = getPackageDependencies(packagePath, packageJson);
+  const packageDependencies = getPackageMeta(packagePath, packageJson);
 
   if (options.debug) {
     console.log(packageJsonPath);
@@ -114,37 +117,39 @@ export function walkPackageDependencyTree(packagePath: string, visitor: Dependen
   if (isRootPackage || !options.runOnlyOnRootDependencies) packageDependencies.dependencies.forEach(walkDependency)
 }
 
-function buildDependencyArray(packagePath: string, packageJson: PackageJson, dependenciesObject: any): Dependency[] {
-  return Object.keys(dependenciesObject).map(name => ({
-    name: name,
-    version: dependenciesObject[name],
-    depender: packageJson.name,
-    dependerVersion: packageJson.version,
-    dependerPath: packagePath,
-  }));
+function buildDependencyArray(type: Dependency["type"], pkgJson: PackageJson, depender: PackageMeta): Dependency[] {
+  const dependenciesObject = pkgJson[type] || {};
+  const peerDependenciesMeta = pkgJson.peerDependenciesMeta || {};
+  // backwards compat
+  const peerDevDependencies = pkgJson.peerDevDependencies || [];
+
+  const packageNames = Object.keys(dependenciesObject);
+
+  return packageNames.map(name => {
+    const isPeerOptionalDependency= !!peerDependenciesMeta[name]?.optional;
+    const isPeerDevDependency = !!peerDependenciesMeta[name]?.dev || !!peerDevDependencies.includes(name);
+
+    return {
+      name,
+      type,
+      version: dependenciesObject[name],
+      isPeerDevDependency,
+      isPeerOptionalDependency,
+      depender,
+    };
+  });
 }
 
-export function getPackageDependencies(packagePath: string, packageJson: PackageJson): PackageDependencies {
-  const {
-    name,
-    dependencies = {},
-    devDependencies = {},
-    optionalDependencies = {},
-    peerDependencies = {},
-    peerDevDependencies = []
-  } = packageJson;
-
-  const applyPeerDevDependencies = (dep: Dependency): Dependency =>
-      ({ ...dep, isPeerDevDependency: peerDevDependencies.includes && peerDevDependencies.includes(dep.name) });
-
-  return {
-    packageName: name,
-    dependencies: buildDependencyArray(packagePath, packageJson, dependencies),
-    devDependencies: buildDependencyArray(packagePath, packageJson, devDependencies),
-    optionalDependencies: buildDependencyArray(packagePath, packageJson, optionalDependencies),
-    peerDependencies: buildDependencyArray(packagePath, packageJson, peerDependencies).map(applyPeerDevDependencies),
-    peerDevDependencies,
-  };
+export function getPackageMeta(packagePath: string, packageJson: PackageJson): PackageMeta {
+  const { name, version} = packageJson;
+  const packageMeta = { name, version, packagePath } as PackageMeta;
+
+  packageMeta.dependencies = buildDependencyArray("dependencies", packageJson, packageMeta);
+  packageMeta.devDependencies = buildDependencyArray("devDependencies", packageJson, packageMeta);
+  packageMeta.optionalDependencies = buildDependencyArray("optionalDependencies", packageJson, packageMeta);
+  packageMeta.peerDependencies = buildDependencyArray("peerDependencies", packageJson, packageMeta);
+
+  return packageMeta;
 }
 
 export function resolvePackageDir(basedir: string, packageName: string) {
@@ -181,17 +186,9 @@ export function getInstalledVersion(dep: Dependency): string | undefined {
 
 
 export function isSameDep(a: Dependency, b: Dependency) {
-  const keys: Array<keyof Dependency> = [
-    "name",
-    "version",
-    "depender",
-    "dependerPath",
-    "dependerVersion",
-    "installedVersion",
-    "semverSatisfies",
-    "isYalc",
-    "isPeerDevDependency",
-  ];
-
-  return keys.every(key => a[key] === b[key]);
+  const keys: Array<keyof Dependency> = [ "name", "version", "installedVersion", "semverSatisfies", "isYalc", "isPeerDevDependency", ];
+  return keys.every(key => a[key] === b[key]) &&
+      a.depender.name === b.depender.name &&
+      a.depender.version === b.depender.version &&
+      a.depender.packagePath === b.depender.packagePath;
 }