@monorepolint/rules 0.6.0-alpha.1 → 0.6.0-alpha.3

package/build/js/index.js

@@ -113,11 +113,19 @@ var PackageDependencyGraphService = class {
       if (maxDepth == null || nextDepth <= maxDepth) {
         const dependencies = packageJson.dependencies != null ? Object.keys(packageJson.dependencies) : [];
         for (const dependency of dependencies) {
-          const dependencyPackageJsonPath = resolvePackagePath(dependency, node.paths.rootDirectory);
+          const dependencyPackageJsonPath = resolvePackagePath(
+            dependency,
+            node.paths.rootDirectory
+          );
           if (dependencyPackageJsonPath == null) {
-            throw new Error(`Could not resolve ${dependency} from ${node.paths.rootDirectory}`);
+            throw new Error(
+              `Could not resolve ${dependency} from ${node.paths.rootDirectory}`
+            );
           }
-          node.dependencies.set(dependency, visit(dependencyPackageJsonPath, nextDepth));
+          node.dependencies.set(
+            dependency,
+            visit(dependencyPackageJsonPath, nextDepth)
+          );
         }
       }
       return node;
@@ -178,17 +186,17 @@ var bannedDependencies = createRuleFactory({
     const curDeps = packageJson.dependencies && Object.keys(packageJson.dependencies);
     const curDevDeps = packageJson.devDependencies && Object.keys(packageJson.devDependencies);
     const curPeerDeps = packageJson.peerDependencies && Object.keys(packageJson.peerDependencies);
-    const { bannedDependencies: banned, bannedTransitiveDependencies: transitives } = opts;
+    const {
+      bannedDependencies: banned,
+      bannedTransitiveDependencies: transitives
+    } = opts;
     const globs = banned && (Array.isArray(banned) ? banned : banned.glob);
     const exacts = banned && (Array.isArray(banned) ? void 0 : banned.exact);
     const violations = /* @__PURE__ */ new Set();
     if (globs) {
-      if (curDeps)
-        populateProblemsGlobs(globs, curDeps, violations);
-      if (curDevDeps)
-        populateProblemsGlobs(globs, curDevDeps, violations);
-      if (curPeerDeps)
-        populateProblemsGlobs(globs, curPeerDeps, violations);
+      if (curDeps) populateProblemsGlobs(globs, curDeps, violations);
+      if (curDevDeps) populateProblemsGlobs(globs, curDevDeps, violations);
+      if (curPeerDeps) populateProblemsGlobs(globs, curPeerDeps, violations);
     }
     if (exacts) {
       let set = setCache.get(exacts);
@@ -196,12 +204,9 @@ var bannedDependencies = createRuleFactory({
         set = new Set(exacts);
         setCache.set(exacts, set);
       }
-      if (curDeps)
-        populateProblemsExact(set, curDeps, violations);
-      if (curDevDeps)
-        populateProblemsExact(set, curDevDeps, violations);
-      if (curPeerDeps)
-        populateProblemsExact(set, curPeerDeps, violations);
+      if (curDeps) populateProblemsExact(set, curDeps, violations);
+      if (curDevDeps) populateProblemsExact(set, curDevDeps, violations);
+      if (curPeerDeps) populateProblemsExact(set, curPeerDeps, violations);
     }
     if (violations.size > 0) {
       context.addError({
@@ -241,12 +246,18 @@ function populateProblemsGlobs(bannedDependencyGlobs, dependencies, violations)
 }
 function checkTransitives(context, banned) {
   const graphService = new PackageDependencyGraphService();
-  const root = graphService.buildDependencyGraph(path2.resolve(context.getPackageJsonPath()), context.host);
+  const root = graphService.buildDependencyGraph(
+    path2.resolve(context.getPackageJsonPath()),
+    context.host
+  );
   for (const { dependencies, importPath } of graphService.traverse(root)) {
     for (const [dependency] of dependencies) {
       if (banned.has(dependency)) {
         const [, ...importPathWithoutRoot] = importPath;
-        const pathing = [...importPathWithoutRoot.map(nameOrPackageJsonPath), dependency].join(" -> ");
+        const pathing = [
+          ...importPathWithoutRoot.map(nameOrPackageJsonPath),
+          dependency
+        ].join(" -> ");
         context.addError({
           file: root.paths.packageJsonPath,
           message: `Banned transitive dependencies in repo: ${pathing}`
@@ -313,7 +324,9 @@ function filterKeys(ob, filterOb) {
 }
 function omit(obj, keysToOmit) {
   const newObj = {};
-  const filtered = Object.entries(obj).filter(([key]) => !keysToOmit.includes(key));
+  const filtered = Object.entries(obj).filter(
+    ([key]) => !keysToOmit.includes(key)
+  );
   for (const [key, value] of filtered) {
     newObj[key] = value;
   }
@@ -337,16 +350,26 @@ function checkConsistentVersions(context, options) {
     options.matchDependencyVersions
   )) {
     if (Array.isArray(expectedPackageDependencyValue)) {
-      ensurePackageMatchesSomeVersion(context, dependencyPackageName, expectedPackageDependencyValue);
+      ensurePackageMatchesSomeVersion(
+        context,
+        dependencyPackageName,
+        expectedPackageDependencyValue
+      );
     } else {
-      ensurePackageIsCorrectVersion(context, dependencyPackageName, expectedPackageDependencyValue);
+      ensurePackageIsCorrectVersion(
+        context,
+        dependencyPackageName,
+        expectedPackageDependencyValue
+      );
     }
   }
 }
 var ensurePackageIsCorrectVersion = (context, dependencyPackageName, expectedPackageDependencyValue) => {
   const packageJson = context.getPackageJson();
   const packageJsonPath = context.getPackageJsonPath();
-  const expectedPackageDependencyVersion = coerce(expectedPackageDependencyValue);
+  const expectedPackageDependencyVersion = coerce(
+    expectedPackageDependencyValue
+  );
   if (expectedPackageDependencyVersion == null) {
     throw new Error(
       `Malformed expected package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${expectedPackageDependencyValue}'`
@@ -365,7 +388,9 @@ var ensurePackageIsCorrectVersion = (context, dependencyPackageName, expectedPac
     });
   }
   const actualPackageDevDependencyValue = packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
-  const actualPackageDevDependencyVersion = coerce(actualPackageDevDependencyValue);
+  const actualPackageDevDependencyVersion = coerce(
+    actualPackageDevDependencyValue
+  );
   if (actualPackageDevDependencyVersion != null && actualPackageDevDependencyVersion.raw !== expectedPackageDependencyVersion.raw) {
     context.addError({
       file: packageJsonPath,
@@ -382,7 +407,9 @@ var ensurePackageMatchesSomeVersion = (context, dependencyPackageName, acceptedP
   const packageJsonPath = context.getPackageJsonPath();
   const acceptedPackageDependencyVersions = acceptedPackageDependencyValues.map(
     (acceptedPackageDependencyValue) => {
-      const acceptedPackageDependencyVersion = coerce(acceptedPackageDependencyValue);
+      const acceptedPackageDependencyVersion = coerce(
+        acceptedPackageDependencyValue
+      );
       if (acceptedPackageDependencyVersion == null) {
         throw new Error(
           `Malformed accepted package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${acceptedPackageDependencyValue}'`
@@ -404,7 +431,9 @@ var ensurePackageMatchesSomeVersion = (context, dependencyPackageName, acceptedP
     });
   }
   const actualPackageDevDependencyValue = packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
-  const actualPackageDevDependencyVersion = coerce(actualPackageDevDependencyValue);
+  const actualPackageDevDependencyVersion = coerce(
+    actualPackageDevDependencyValue
+  );
   if (actualPackageDevDependencyVersion != null && acceptedPackageDependencyVersions.every(
     (acceptedPackageDependencyVersion) => actualPackageDevDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
   )) {
@@ -431,7 +460,7 @@ var Options4 = r4.Union(
   r4.Record({
     file: r4.String,
     generator: r4.Undefined.optional(),
-    template: r4.String,
+    template: r4.String.Or(r4.Undefined),
     templateFile: r4.Undefined.optional()
   }),
   r4.Record({
@@ -449,17 +478,20 @@ var fileContents = createRuleFactory({
     const pathExists = context.host.exists(fullPath);
     const actualContent = pathExists ? context.host.readFile(fullPath, { encoding: "utf-8" }) : void 0;
     if (actualContent !== expectedContent) {
+      const longMessage = pathExists && expectedContent == void 0 ? void 0 : diff3(expectedContent, actualContent, { expand: true });
+      const message = pathExists && expectedContent == void 0 ? "File should not exist" : "Expect file contents to match";
       context.addError({
         file: fullPath,
-        message: "Expect file contents to match",
-        longMessage: diff3(expectedContent, actualContent, { expand: true }),
+        message,
+        longMessage,
         fixer: () => {
           if (expectedContent === void 0) {
-            if (pathExists)
-              context.host.deleteFile(fullPath);
+            if (pathExists) context.host.deleteFile(fullPath);
           } else {
             context.host.mkdir(path3.dirname(fullPath), { recursive: true });
-            context.host.writeFile(fullPath, expectedContent, { encoding: "utf-8" });
+            context.host.writeFile(fullPath, expectedContent, {
+              encoding: "utf-8"
+            });
           }
         }
       });
@@ -494,9 +526,9 @@ async function getExpectedContents(context, opts) {
 // src/mustSatisfyPeerDependencies.ts
 import { mutateJson as mutateJson2 } from "@monorepolint/utils";
 import * as path4 from "node:path";
+import resolvePackagePath2 from "resolve-package-path";
 import * as r5 from "runtypes";
 import { coerce as coerce2 } from "semver";
-import resolvePackagePath2 from "resolve-package-path";
 var Options5 = r5.Union(
   r5.Partial({
     skipUnparseableRanges: r5.Undefined,
@@ -647,15 +679,26 @@ var MATCH_GREATER_OR_EQUAL_VERSION_RANGE = /^>= ?\d+(?:\.\d+|\.\d+\.\d+(?:-((?:0
 var MATCH_MAJOR_VERSION_RANGE = /^(?:\^?\d+|\^?\d+\.x|\^?\d+\.x\.x|\^\d+\.\d+|\^\d+\.\d+\.x|\^\d+\.\d+\.\d+(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)$/;
 var RANGE_REGEX = /^(\*|x|>= ?\d+(?:\.\d+|\.\d+\.\d+(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)?|\^?\d+(\.x|\.x\.x|\.\d+|\.\d+\.x|\.\d+\.\d+(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)?( \|\| \^?\d+(\.x|\.x\.x|\.\d+|\.\d+\.x|\.\d+\.\d+(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)?)*)$/;
 function checkSatisfyPeerDependencies(context, opts) {
-  const { dependencyBlacklist, dependencyWhitelist, enforceForDevDependencies, skipUnparseableRanges } = opts;
+  const {
+    dependencyBlacklist,
+    dependencyWhitelist,
+    enforceForDevDependencies,
+    skipUnparseableRanges
+  } = opts;
   const packageJsonPath = path4.resolve(context.getPackageJsonPath());
   const packageJson = context.host.readJson(packageJsonPath);
   const packageDependencies = packageJson.dependencies || {};
   const packageDevDependencies = packageJson.devDependencies || {};
   const packagePeerDependencies = packageJson.peerDependencies || {};
   const packageName = packageJson.name || packageJsonPath;
-  for (const [peerDependencyName, peerDependencyRange] of Object.entries(packagePeerDependencies)) {
-    if (shouldSkipPackage({ dependencyBlacklist, dependencyWhitelist, packageName: peerDependencyName })) {
+  for (const [peerDependencyName, peerDependencyRange] of Object.entries(
+    packagePeerDependencies
+  )) {
+    if (shouldSkipPackage({
+      dependencyBlacklist,
+      dependencyWhitelist,
+      packageName: peerDependencyName
+    })) {
       continue;
     }
     const dependencyRange = packageDependencies[peerDependencyName];
@@ -668,19 +711,35 @@ function checkSatisfyPeerDependencies(context, opts) {
     }
   }
   const allRequiredPeerDependencies = {};
-  const allDependencies = enforceForDevDependencies ? [...Object.keys(packageDependencies), ...Object.keys(packageDevDependencies)] : Object.keys(packageDependencies);
+  const allDependencies = enforceForDevDependencies ? [
+    ...Object.keys(packageDependencies),
+    ...Object.keys(packageDevDependencies)
+  ] : Object.keys(packageDependencies);
   for (const dependency of allDependencies) {
-    const dependencyPackageJsonPath = resolvePackagePath2(dependency, path4.dirname(packageJsonPath));
+    const dependencyPackageJsonPath = resolvePackagePath2(
+      dependency,
+      path4.dirname(packageJsonPath)
+    );
     if (dependencyPackageJsonPath == null) {
-      throw new Error(`Could not resolve ${dependency} from ${path4.dirname(packageJsonPath)}`);
+      throw new Error(
+        `Could not resolve ${dependency} from ${path4.dirname(packageJsonPath)}`
+      );
     }
-    const dependencyPackageJson = context.host.readJson(dependencyPackageJsonPath);
+    const dependencyPackageJson = context.host.readJson(
+      dependencyPackageJsonPath
+    );
     const requiredPeerDependencies = dependencyPackageJson.peerDependencies;
     if (requiredPeerDependencies == null) {
       continue;
     }
-    for (const [peerDependencyName, range] of Object.entries(requiredPeerDependencies)) {
-      if (shouldSkipPackage({ dependencyBlacklist, dependencyWhitelist, packageName: peerDependencyName })) {
+    for (const [peerDependencyName, range] of Object.entries(
+      requiredPeerDependencies
+    )) {
+      if (shouldSkipPackage({
+        dependencyBlacklist,
+        dependencyWhitelist,
+        packageName: peerDependencyName
+      })) {
         continue;
       }
       if (!isValidRange(range)) {
@@ -694,10 +753,15 @@ function checkSatisfyPeerDependencies(context, opts) {
       if (allRequiredPeerDependencies[peerDependencyName] == null) {
         allRequiredPeerDependencies[peerDependencyName] = [];
       }
-      allRequiredPeerDependencies[peerDependencyName].push({ fromPackageName: dependencyPackageJson.name, range });
+      allRequiredPeerDependencies[peerDependencyName].push({
+        fromPackageName: dependencyPackageJson.name,
+        range
+      });
     }
   }
-  for (const [peerDependencyName, peerDependencyRequirements] of Object.entries(allRequiredPeerDependencies)) {
+  for (const [peerDependencyName, peerDependencyRequirements] of Object.entries(
+    allRequiredPeerDependencies
+  )) {
     let mostStrictPeerRequirement = {
       fromPeerDependencyRequirements: [peerDependencyRequirements[0]],
       range: peerDependencyRequirements[0].range
@@ -711,7 +775,10 @@ function checkSatisfyPeerDependencies(context, opts) {
           range: peerRequirement.range
         };
       } else {
-        const maybeIntersection = findIntersection(peerRequirement.range, mostStrictPeerRequirement.range);
+        const maybeIntersection = findIntersection(
+          peerRequirement.range,
+          mostStrictPeerRequirement.range
+        );
         if (maybeIntersection !== void 0) {
           mostStrictPeerRequirement = {
             fromPeerDependencyRequirements: [
@@ -770,7 +837,10 @@ function checkSatisfyPeerDependencies(context, opts) {
         } else {
           throw new Error(message);
         }
-      } else if (!doesASatisfyB(packagePeerDependencyRange, mostStrictPeerRequirement.range)) {
+      } else if (!doesASatisfyB(
+        packagePeerDependencyRange,
+        mostStrictPeerRequirement.range
+      )) {
         context.addError({
           file: packageJsonPath,
           message: `[4] Package ${packageName} peer dependency on ${peerDependencyName} '${packagePeerDependencyRange}' is not strict enough.
@@ -802,8 +872,12 @@ function getMostStrictStatement(mostStrictPeerRequirement) {
     const dependencyName = mostStrictPeerRequirement.fromPeerDependencyRequirements[0].fromPackageName;
     return `Dependency ${dependencyName} requires '${mostStrictPeerRequirement.range}'.`;
   } else {
-    const dependencyNames = mostStrictPeerRequirement.fromPeerDependencyRequirements.map((peerDependencyRequirement) => peerDependencyRequirement.fromPackageName).join(", ");
-    const dependencyRequirements = mostStrictPeerRequirement.fromPeerDependencyRequirements.map((peerDependencyRequirement) => `'${peerDependencyRequirement.range}'`).join(", ");
+    const dependencyNames = mostStrictPeerRequirement.fromPeerDependencyRequirements.map(
+      (peerDependencyRequirement) => peerDependencyRequirement.fromPackageName
+    ).join(", ");
+    const dependencyRequirements = mostStrictPeerRequirement.fromPeerDependencyRequirements.map(
+      (peerDependencyRequirement) => `'${peerDependencyRequirement.range}'`
+    ).join(", ");
     return `Dependencies [${dependencyNames}] require [${dependencyRequirements}] respectively, resolving to '${mostStrictPeerRequirement.range}'.`;
   }
 }
@@ -853,13 +927,21 @@ function findIntersection(a, b) {
   }
   const compatibleVersions = aVersions.map((aVersion) => {
     const aSemVer = coerce2(aVersion);
-    const majorMatchingBVersion = bVersions.find((m) => coerce2(m).major === aSemVer.major);
+    const majorMatchingBVersion = bVersions.find(
+      (m) => coerce2(m).major === aSemVer.major
+    );
     if (majorMatchingBVersion === void 0) {
       return void 0;
     }
-    if (doesASatisfyB(aVersion, majorMatchingBVersion)) {
+    if (doesASatisfyB(
+      aVersion,
+      majorMatchingBVersion
+    )) {
       return aVersion;
-    } else if (doesASatisfyB(majorMatchingBVersion, aVersion)) {
+    } else if (doesASatisfyB(
+      majorMatchingBVersion,
+      aVersion
+    )) {
       return majorMatchingBVersion;
     } else {
       return void 0;
@@ -900,13 +982,17 @@ function doesASatisfyB(a, b) {
   }
   return aVersions.every((aVersion) => {
     const aSemVer = coerce2(aVersion);
-    const majorMatchingBVersion = bVersions.find((m) => coerce2(m).major === aSemVer.major);
+    const majorMatchingBVersion = bVersions.find(
+      (m) => coerce2(m).major === aSemVer.major
+    );
     if (majorMatchingBVersion === void 0) {
       return false;
     }
     const aVersionIsRange = isMajorVersionRange(aVersion);
     const majorMatchingBSemVer = coerce2(majorMatchingBVersion);
-    const majorMatchingBVersionIsRange = isMajorVersionRange(majorMatchingBVersion);
+    const majorMatchingBVersionIsRange = isMajorVersionRange(
+      majorMatchingBVersion
+    );
     if (majorMatchingBVersionIsRange) {
       return aSemVer.compare(majorMatchingBSemVer) !== -1;
     } else {
@@ -948,12 +1034,133 @@ function getAddDependencyTypeFixer({
   };
 }
 
-// src/packageOrder.ts
-import { diff as diff4 } from "jest-diff";
+// src/nestedWorkspaces.ts
+import * as globby from "globby";
+import * as path5 from "node:path";
 import * as r6 from "runtypes";
-var Options6 = r6.Record({
-  order: r6.Union(r6.Array(r6.String), r6.Function)
-}).Or(r6.Undefined);
+var Options6 = r6.Undefined;
+var nestedWorkspaces = createRuleFactory({
+  name: "nestedWorkspaces",
+  check: (context) => {
+    const rootPackageJson = context.getWorkspaceContext().getPackageJson();
+    const packageJsonPaths = globby.globbySync([
+      "*/**/package.json",
+      "!**/node_modules/**"
+    ]);
+    const workspaces = Array.isArray(rootPackageJson.workspaces) ? rootPackageJson.workspaces : rootPackageJson.workspaces !== void 0 ? rootPackageJson.workspaces.packages : void 0;
+    if (workspaces === void 0 && packageJsonPaths.length > 0) {
+      context.addError({
+        file: context.getPackageJsonPath(),
+        message: 'The "workspace" field is missing, even though there are workspaces in the repository.'
+      });
+      return;
+    }
+    const workspacePackageJsons = (workspaces || []).map(
+      (item) => `${item}/package.json`
+    );
+    const expandedWorkspacesGlobs = globby.globbySync([
+      ...workspacePackageJsons,
+      "!**/node_modules/**"
+    ]);
+    const difference = packageJsonPaths.filter(
+      (packageJsonPath) => !expandedWorkspacesGlobs.includes(packageJsonPath)
+    );
+    if (difference.length !== 0) {
+      const differencesList = difference.map(
+        (packageJsonPath) => path5.dirname(packageJsonPath)
+      ).join(", ");
+      context.addError({
+        file: context.getPackageJsonPath(),
+        message: `The "workspace" field is missing one or more values: ${differencesList}. You may be able to use a glob to avoid listing each workspace individually, e.g. "packages/nested-workspace/*".`
+      });
+    }
+  },
+  validateOptions: Options6.check
+});
+
+// src/packageEntry.ts
+import { mutateJson as mutateJson3 } from "@monorepolint/utils";
+import { diff as diff4 } from "jest-diff";
+import * as r7 from "runtypes";
+var Options7 = r7.Union(
+  r7.Record({
+    entries: r7.Dictionary(r7.Unknown)
+    // string => unknown, enforces existence of keys and their values
+  }).And(
+    r7.Partial({
+      entriesExist: r7.Undefined
+    })
+  ),
+  r7.Record({
+    entriesExist: r7.Array(r7.String)
+    // enforces existence of keys, but not values
+  }).And(
+    r7.Partial({
+      entries: r7.Undefined
+    })
+  ),
+  r7.Record({
+    entries: r7.Dictionary(r7.Unknown),
+    // string => unknown, enforces existence of keys and their values
+    entriesExist: r7.Array(r7.String)
+  })
+);
+var packageEntry = createRuleFactory({
+  name: "packageEntry",
+  check: (context, options) => {
+    const packageJson = context.getPackageJson();
+    if (options.entries) {
+      for (const key of Object.keys(options.entries)) {
+        const value = options.entries[key];
+        const entryDiff = diff4(
+          JSON.stringify(value) + "\n",
+          (JSON.stringify(packageJson[key]) || "") + "\n"
+        );
+        if (typeof value !== "object" && value !== packageJson[key] || entryDiff == null || !entryDiff.includes("Compared values have no visual difference")) {
+          context.addError({
+            file: context.getPackageJsonPath(),
+            message: createStandardizedEntryErrorMessage(key),
+            longMessage: entryDiff,
+            fixer: () => {
+              mutateJson3(
+                context.getPackageJsonPath(),
+                context.host,
+                (input) => {
+                  input[key] = value;
+                  return input;
+                }
+              );
+            }
+          });
+        }
+      }
+    }
+    if (options.entriesExist) {
+      for (const key of options.entriesExist) {
+        if (packageJson[key] === void 0) {
+          context.addError({
+            file: context.getPackageJsonPath(),
+            message: createExpectedEntryErrorMessage(key)
+          });
+        }
+      }
+    }
+  },
+  validateOptions: Options7.check
+});
+function createStandardizedEntryErrorMessage(key) {
+  return `Expected standardized entry for '${key}'`;
+}
+function createExpectedEntryErrorMessage(key) {
+  return `Expected entry for '${key}' to exist`;
+}
+
+// src/packageOrder.ts
+import { diff as diff5 } from "jest-diff";
+import * as r8 from "runtypes";
+var Options8 = r8.Record({
+  order: r8.Union(r8.Array(r8.String), r8.Function)
+}).Or(r8.Undefined);
 var defaultKeyOrder = [
   "name",
   "version",
@@ -998,7 +1205,7 @@ var packageOrder = createRuleFactory({
       context.addError({
         file: packagePath,
         message: "Incorrect order of fields in package.json",
-        longMessage: diff4(expectedOrder, actualOrder, { expand: true }),
+        longMessage: diff5(expectedOrder, actualOrder, { expand: true }),
         fixer: () => {
           const expectedPackageJson = {};
           expectedOrder.forEach((key) => {
@@ -1009,7 +1216,7 @@ var packageOrder = createRuleFactory({
       });
     }
   },
-  validateOptions: Options6.check
+  validateOptions: Options8.check
 });
 function arrayOrderCompare2(a, b) {
   for (let index = 0; index < a.length; index++) {
@@ -1040,87 +1247,17 @@ function isOrderFunction(order) {
   return !Array.isArray(order);
 }
 
-// src/packageEntry.ts
-import { mutateJson as mutateJson3 } from "@monorepolint/utils";
-import { diff as diff5 } from "jest-diff";
-import * as r7 from "runtypes";
-var Options7 = r7.Union(
-  r7.Record({
-    entries: r7.Dictionary(r7.Unknown)
-    // string => unknown, enforces existence of keys and their values
-  }).And(
-    r7.Partial({
-      entriesExist: r7.Undefined
-    })
-  ),
-  r7.Record({
-    entriesExist: r7.Array(r7.String)
-    // enforces existence of keys, but not values
-  }).And(
-    r7.Partial({
-      entries: r7.Undefined
-    })
-  ),
-  r7.Record({
-    entries: r7.Dictionary(r7.Unknown),
-    // string => unknown, enforces existence of keys and their values
-    entriesExist: r7.Array(r7.String)
-  })
-);
-var packageEntry = createRuleFactory({
-  name: "packageEntry",
-  check: (context, options) => {
-    const packageJson = context.getPackageJson();
-    if (options.entries) {
-      for (const key of Object.keys(options.entries)) {
-        const value = options.entries[key];
-        const entryDiff = diff5(JSON.stringify(value) + "\n", (JSON.stringify(packageJson[key]) || "") + "\n");
-        if (typeof value !== "object" && value !== packageJson[key] || entryDiff == null || !entryDiff.includes("Compared values have no visual difference")) {
-          context.addError({
-            file: context.getPackageJsonPath(),
-            message: createStandardizedEntryErrorMessage(key),
-            longMessage: entryDiff,
-            fixer: () => {
-              mutateJson3(context.getPackageJsonPath(), context.host, (input) => {
-                input[key] = value;
-                return input;
-              });
-            }
-          });
-        }
-      }
-    }
-    if (options.entriesExist) {
-      for (const key of options.entriesExist) {
-        if (packageJson[key] === void 0) {
-          context.addError({
-            file: context.getPackageJsonPath(),
-            message: createExpectedEntryErrorMessage(key)
-          });
-        }
-      }
-    }
-  },
-  validateOptions: Options7.check
-});
-function createStandardizedEntryErrorMessage(key) {
-  return `Expected standardized entry for '${key}'`;
-}
-function createExpectedEntryErrorMessage(key) {
-  return `Expected entry for '${key}' to exist`;
-}
-
 // src/packageScript.ts
 import { mutateJson as mutateJson4 } from "@monorepolint/utils";
 import { diff as diff6 } from "jest-diff";
-import * as r8 from "runtypes";
-var Options8 = r8.Record({
-  scripts: r8.Dictionary(
-    r8.Union(
-      r8.String,
-      r8.Record({
-        options: r8.Array(r8.String.Or(r8.Undefined)),
-        fixValue: r8.Union(r8.String, r8.Undefined, r8.Literal(false)).optional()
+import * as r9 from "runtypes";
+var Options9 = r9.Record({
+  scripts: r9.Dictionary(
+    r9.Union(
+      r9.String,
+      r9.Record({
+        options: r9.Array(r9.String.Or(r9.Undefined)),
+        fixValue: r9.Union(r9.String, r9.Undefined, r9.Literal(false)).optional()
       })
     )
   )
@@ -1136,10 +1273,14 @@ var packageScript = createRuleFactory({
         file: context.getPackageJsonPath(),
         message: MSG_NO_SCRIPTS_BLOCK,
         fixer: () => {
-          mutateJson4(context.getPackageJsonPath(), context.host, (input) => {
-            input.scripts = {};
-            return input;
-          });
+          mutateJson4(
+            context.getPackageJsonPath(),
+            context.host,
+            (input) => {
+              input.scripts = {};
+              return input;
+            }
+          );
         }
       });
       return;
@@ -1168,43 +1309,127 @@ var packageScript = createRuleFactory({
         if (fixValue !== false && (fixValue !== void 0 || fixToEmpty === true)) {
           const q = fixValue;
           fixer = () => {
-            mutateJson4(context.getPackageJsonPath(), context.host, (input) => {
-              if (fixToEmpty && q === void 0) {
-                delete input.scripts[name];
-              } else {
-                input.scripts[name] = q;
+            mutateJson4(
+              context.getPackageJsonPath(),
+              context.host,
+              (input) => {
+                if (fixToEmpty && q === void 0) {
+                  delete input.scripts[name];
+                } else {
+                  input.scripts[name] = q;
+                }
+                return input;
               }
-              return input;
-            });
+            );
           };
         }
         const validOptionsString = Array.from(allowedValues.values()).map((a) => a === void 0 ? "(empty)" : `'${a}'`).join(", ");
         context.addError({
           file: context.getPackageJsonPath(),
           message: `Expected standardized script entry for '${name}'. Valid options: ${validOptionsString}`,
-          longMessage: diff6(validOptionsString + "\n", (packageJson.scripts[name] || "") + "\n"),
+          longMessage: diff6(
+            validOptionsString + "\n",
+            (packageJson.scripts[name] || "") + "\n"
+          ),
           fixer
         });
       }
     }
   },
-  validateOptions: Options8.check
+  validateOptions: Options9.check
+});
+
+// src/requireDependency.ts
+import { mutateJson as mutateJson5 } from "@monorepolint/utils";
+import { diff as diff7 } from "jest-diff";
+import * as r10 from "runtypes";
+var Options10 = r10.Partial({
+  dependencies: r10.Dictionary(r10.String.optional()),
+  devDependencies: r10.Dictionary(r10.String.optional()),
+  peerDependencies: r10.Dictionary(r10.String.optional()),
+  optionalDependencies: r10.Dictionary(r10.String.optional())
+});
+var requireDependency = createRuleFactory({
+  name: "requireDependency",
+  check: function expectPackageEntry(context, options) {
+    const packageJson = context.getPackageJson();
+    const packageJsonPath = context.getPackageJsonPath();
+    [
+      "dependencies",
+      "devDependencies",
+      "peerDependencies",
+      "optionalDependencies"
+    ].forEach((type) => {
+      var _a;
+      const expectedEntries = options[type];
+      if (!expectedEntries) {
+        return;
+      }
+      if (packageJson[type] === void 0) {
+        context.addError({
+          file: packageJsonPath,
+          message: `No ${type} block, cannot add required ${type}.`,
+          fixer: () => {
+            mutateJson5(packageJsonPath, context.host, (input) => {
+              input[type] = Object.fromEntries(
+                Object.entries(expectedEntries).filter(
+                  ([, v]) => v !== void 0
+                )
+              );
+              return input;
+            });
+          }
+        });
+        return;
+      }
+      for (const [dep, version] of Object.entries(options[type])) {
+        if (((_a = packageJson[type]) == null ? void 0 : _a[dep]) !== version) {
+          context.addError({
+            file: packageJsonPath,
+            message: `Expected dependency ${dep}@${version}`,
+            longMessage: diff7(
+              `${dep}@${version}
+`,
+              `${dep}@${packageJson[type][dep] || "missing"}
+`
+            ),
+            fixer: () => {
+              mutateJson5(
+                packageJsonPath,
+                context.host,
+                (input) => {
+                  if (version === void 0) {
+                    input[type] = { ...input[type] };
+                    delete input[type][dep];
+                  } else {
+                    input[type] = { ...input[type], [dep]: version };
+                  }
+                  return input;
+                }
+              );
+            }
+          });
+        }
+      }
+    });
+  },
+  validateOptions: Options10.check
 });
 
 // src/standardTsconfig.ts
 import { matchesAnyGlob as matchesAnyGlob2 } from "@monorepolint/utils";
-import { diff as diff7 } from "jest-diff";
-import * as path5 from "path";
-import * as r9 from "runtypes";
+import { diff as diff8 } from "jest-diff";
+import * as path6 from "path";
+import * as r11 from "runtypes";
 var DEFAULT_TSCONFIG_FILENAME = "tsconfig.json";
-var Options9 = r9.Partial({
-  file: r9.String,
-  generator: r9.Function,
-  tsconfigReferenceFile: r9.String,
-  template: r9.Record({}).Or(r9.String),
-  templateFile: r9.String,
-  excludedReferences: r9.Array(r9.String).Or(r9.Undefined),
-  additionalReferences: r9.Array(r9.String).Or(r9.Undefined)
+var Options11 = r11.Partial({
+  file: r11.String,
+  generator: r11.Function,
+  tsconfigReferenceFile: r11.String,
+  template: r11.Record({}).Or(r11.String),
+  templateFile: r11.String,
+  excludedReferences: r11.Array(r11.String).Or(r11.Undefined),
+  additionalReferences: r11.Array(r11.String).Or(r11.Undefined)
 }).withConstraint(({ generator, template, templateFile }) => {
   let count = 0;
   if (generator) {
@@ -1222,7 +1447,7 @@ var standardTsconfig = createRuleFactory({
   name: "standardTsconfig",
   check: async (context, opts) => {
     const tsconfigFileName = opts.file ?? DEFAULT_TSCONFIG_FILENAME;
-    const fullPath = path5.resolve(context.packageDir, tsconfigFileName);
+    const fullPath = path6.resolve(context.packageDir, tsconfigFileName);
     const generator = getGenerator(context, opts);
     const expectedContent = await generator(context);
     const actualContent = context.host.exists(fullPath) ? context.host.readFile(fullPath, { encoding: "utf-8" }) : void 0;
@@ -1237,7 +1462,7 @@ var standardTsconfig = createRuleFactory({
       context.addError({
         file: fullPath,
         message: "Expect file contents to match",
-        longMessage: diff7(expectedContent, actualContent, { expand: true }),
+        longMessage: diff8(expectedContent, actualContent, { expand: true }),
         fixer: () => {
           context.host.writeFile(fullPath, expectedContent, {
             encoding: "utf-8"
@@ -1246,18 +1471,30 @@ var standardTsconfig = createRuleFactory({
       });
     }
   },
-  validateOptions: Options9.check
+  validateOptions: Options11.check
 });
 function getGenerator(context, opts) {
   if (opts.generator) {
     return opts.generator;
   } else if (opts.templateFile) {
     const { packageDir: workspacePackageDir } = context.getWorkspaceContext();
-    const fullPath = path5.resolve(workspacePackageDir, opts.templateFile);
-    const template = JSON.parse(context.host.readFile(fullPath, { encoding: "utf-8" }));
-    return makeGenerator(template, opts.excludedReferences, opts.additionalReferences, opts.tsconfigReferenceFile);
+    const fullPath = path6.resolve(workspacePackageDir, opts.templateFile);
+    const template = JSON.parse(
+      context.host.readFile(fullPath, { encoding: "utf-8" })
+    );
+    return makeGenerator(
+      template,
+      opts.excludedReferences,
+      opts.additionalReferences,
+      opts.tsconfigReferenceFile
+    );
   } else if (opts.template) {
-    return makeGenerator(opts.template, opts.excludedReferences, opts.additionalReferences, opts.tsconfigReferenceFile);
+    return makeGenerator(
+      opts.template,
+      opts.excludedReferences,
+      opts.additionalReferences,
+      opts.tsconfigReferenceFile
+    );
   } else {
     throw new Error("Unable to make generator");
   }
@@ -1270,13 +1507,16 @@ function makeGenerator(template, excludedReferences, additionalReferences, tscon
     };
     const nameToDirectory = await context.getWorkspaceContext().getPackageNameToDir();
     const packageJson = context.getPackageJson();
-    const deps = [...Object.keys(packageJson.dependencies || {}), ...Object.keys(packageJson.devDependencies || {})];
+    const deps = [
+      ...Object.keys(packageJson.dependencies || {}),
+      ...Object.keys(packageJson.devDependencies || {})
+    ];
     for (const dep of deps) {
       const packageDir = nameToDirectory.get(dep);
       if (packageDir !== void 0 && (excludedReferences === void 0 || !matchesAnyGlob2(dep, excludedReferences))) {
-        const absoluteReferencePath = tsconfigReferenceFile !== void 0 ? path5.join(packageDir, tsconfigReferenceFile) : packageDir;
+        const absoluteReferencePath = tsconfigReferenceFile !== void 0 ? path6.join(packageDir, tsconfigReferenceFile) : packageDir;
         template.references.push({
-          path: path5.relative(context.packageDir, absoluteReferencePath)
+          path: path6.relative(context.packageDir, absoluteReferencePath)
         });
       }
     }
@@ -1290,98 +1530,6 @@ function makeGenerator(template, excludedReferences, additionalReferences, tscon
     return JSON.stringify(template, void 0, 2) + "\n";
   };
 }
-
-// src/nestedWorkspaces.ts
-import * as globby from "globby";
-import * as path6 from "node:path";
-import * as r10 from "runtypes";
-var Options10 = r10.Undefined;
-var nestedWorkspaces = createRuleFactory({
-  name: "nestedWorkspaces",
-  check: (context) => {
-    const rootPackageJson = context.getWorkspaceContext().getPackageJson();
-    const packageJsonPaths = globby.globbySync(["*/**/package.json", "!**/node_modules/**"]);
-    const workspaces = Array.isArray(rootPackageJson.workspaces) ? rootPackageJson.workspaces : rootPackageJson.workspaces !== void 0 ? rootPackageJson.workspaces.packages : void 0;
-    if (workspaces === void 0 && packageJsonPaths.length > 0) {
-      context.addError({
-        file: context.getPackageJsonPath(),
-        message: 'The "workspace" field is missing, even though there are workspaces in the repository.'
-      });
-      return;
-    }
-    const workspacePackageJsons = (workspaces || []).map((item) => `${item}/package.json`);
-    const expandedWorkspacesGlobs = globby.globbySync([...workspacePackageJsons, "!**/node_modules/**"]);
-    const difference = packageJsonPaths.filter((packageJsonPath) => !expandedWorkspacesGlobs.includes(packageJsonPath));
-    if (difference.length !== 0) {
-      const differencesList = difference.map((packageJsonPath) => path6.dirname(packageJsonPath)).join(", ");
-      context.addError({
-        file: context.getPackageJsonPath(),
-        message: `The "workspace" field is missing one or more values: ${differencesList}. You may be able to use a glob to avoid listing each workspace individually, e.g. "packages/nested-workspace/*".`
-      });
-    }
-  },
-  validateOptions: Options10.check
-});
-
-// src/requireDependency.ts
-import { mutateJson as mutateJson5 } from "@monorepolint/utils";
-import { diff as diff8 } from "jest-diff";
-import * as r11 from "runtypes";
-var Options11 = r11.Partial({
-  dependencies: r11.Dictionary(r11.String),
-  devDependencies: r11.Dictionary(r11.String),
-  peerDependencies: r11.Dictionary(r11.String),
-  optionalDependencies: r11.Dictionary(r11.String)
-});
-var requireDependency = createRuleFactory({
-  name: "requireDependency",
-  check: function expectPackageEntry(context, options) {
-    const packageJson = context.getPackageJson();
-    const packageJsonPath = context.getPackageJsonPath();
-    [
-      "dependencies",
-      "devDependencies",
-      "peerDependencies",
-      "optionalDependencies"
-    ].forEach((type) => {
-      var _a;
-      if (!options[type]) {
-        return;
-      }
-      if (packageJson[type] === void 0) {
-        context.addError({
-          file: packageJsonPath,
-          message: `No ${type} block, cannot add required ${type}.`,
-          fixer: () => {
-            mutateJson5(packageJsonPath, context.host, (input) => {
-              input[type] = options[type];
-              return input;
-            });
-          }
-        });
-        return;
-      }
-      for (const [dep, version] of Object.entries(options[type])) {
-        if (((_a = packageJson[type]) == null ? void 0 : _a[dep]) !== version) {
-          context.addError({
-            file: packageJsonPath,
-            message: `Expected dependency ${dep}@${version}`,
-            longMessage: diff8(`${dep}@${version}
-`, `${dep}@${packageJson[type][dep] || "missing"}
-`),
-            fixer: () => {
-              mutateJson5(packageJsonPath, context.host, (input) => {
-                input[type] = { ...input[type], [dep]: version };
-                return input;
-              });
-            }
-          });
-        }
-      }
-    });
-  },
-  validateOptions: Options11.check
-});
 export {
   alphabeticalDependencies,
   alphabeticalScripts,