@monorepolint/rules 0.6.0-alpha.2 → 0.6.0-alpha.4

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,7 +186,10 @@ 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();
@@ -235,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}`
@@ -331,16 +348,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}'`
@@ -359,7 +386,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,
@@ -376,7 +405,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}'`
@@ -398,7 +429,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
   )) {
@@ -454,7 +487,9 @@ var fileContents = createRuleFactory({
             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"
+            });
           }
         }
       });
@@ -486,12 +521,37 @@ async function getExpectedContents(context, opts) {
   }
 }
 
+// src/forceError.ts
+var forceError = createRuleFactory({
+  name: "forceError",
+  check: async (context, opts) => {
+    context.addError({
+      message: (opts == null ? void 0 : opts.customMessage) ?? "Forced error (often used to debug package selection)",
+      file: context.getPackageJsonPath()
+    });
+  },
+  validateOptions: (opts) => {
+    if (opts == null) return;
+    if (typeof opts !== "object") {
+      throw new Error("options must be an object if provided");
+    }
+    const numKeys = Object.keys(opts).length;
+    if (numKeys === 0) return;
+    if (Object.keys(opts).length > 1 || !("customMessage" in opts)) {
+      throw new Error("options must only have `customMessage` property");
+    }
+    if (typeof opts.customMessage !== "string") {
+      throw new Error("customMessage must be a string");
+    }
+  }
+});
+
 // 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,
@@ -642,15 +702,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];
@@ -663,19 +734,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)) {
@@ -689,10 +776,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
@@ -706,7 +798,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: [
@@ -765,7 +860,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.
@@ -852,9 +950,15 @@ function findIntersection(a, b) {
     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;
@@ -901,7 +1005,9 @@ function doesASatisfyB(a, b) {
     }
     const aVersionIsRange = isMajorVersionRange(aVersion);
     const majorMatchingBSemVer = coerce2(majorMatchingBVersion);
-    const majorMatchingBVersionIsRange = isMajorVersionRange(majorMatchingBVersion);
+    const majorMatchingBVersionIsRange = isMajorVersionRange(
+      majorMatchingBVersion
+    );
     if (majorMatchingBVersionIsRange) {
       return aSemVer.compare(majorMatchingBSemVer) !== -1;
     } else {
@@ -943,12 +1049,153 @@ 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/oncePerPackage.ts
+import * as r7 from "runtypes";
+var Options7 = r7.Record({
+  singletonKey: r7.String.Or(r7.Symbol),
+  customMessage: r7.String.optional()
+});
+var visitedMap = /* @__PURE__ */ new Map();
+var oncePerPackage = createRuleFactory({
+  name: "oncePerPackage",
+  check: async (context, options) => {
+    const visited = visitedMap.get(options.singletonKey) ?? /* @__PURE__ */ new Set();
+    visitedMap.set(options.singletonKey, visited);
+    if (visited.has(context.getName())) {
+      context.addError({
+        message: "This package has already been visited for this key: " + options.singletonKey.toString(),
+        file: context.getPackageJsonPath()
+      });
+    } else {
+      visited.add(context.getName());
+    }
+  },
+  validateOptions: Options7.assert
+});
+
+// src/packageEntry.ts
+import { mutateJson as mutateJson3 } from "@monorepolint/utils";
+import { diff as diff4 } from "jest-diff";
+import * as r8 from "runtypes";
+var Options8 = r8.Union(
+  r8.Record({
+    entries: r8.Dictionary(r8.Unknown)
+    // string => unknown, enforces existence of keys and their values
+  }).And(
+    r8.Partial({
+      entriesExist: r8.Undefined
+    })
+  ),
+  r8.Record({
+    entriesExist: r8.Array(r8.String)
+    // enforces existence of keys, but not values
+  }).And(
+    r8.Partial({
+      entries: r8.Undefined
+    })
+  ),
+  r8.Record({
+    entries: r8.Dictionary(r8.Unknown),
+    // string => unknown, enforces existence of keys and their values
+    entriesExist: r8.Array(r8.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: Options8.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 r9 from "runtypes";
+var Options9 = r9.Record({
+  order: r9.Union(r9.Array(r9.String), r9.Function)
+}).Or(r9.Undefined);
 var defaultKeyOrder = [
   "name",
   "version",
@@ -993,7 +1240,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) => {
@@ -1004,7 +1251,7 @@ var packageOrder = createRuleFactory({
       });
     }
   },
-  validateOptions: Options6.check
+  validateOptions: Options9.check
 });
 function arrayOrderCompare2(a, b) {
   for (let index = 0; index < a.length; index++) {
@@ -1035,87 +1282,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 r10 from "runtypes";
+var Options10 = r10.Record({
+  scripts: r10.Dictionary(
+    r10.Union(
+      r10.String,
+      r10.Record({
+        options: r10.Array(r10.String.Or(r10.Undefined)),
+        fixValue: r10.Union(r10.String, r10.Undefined, r10.Literal(false)).optional()
       })
     )
   )
@@ -1131,10 +1308,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;
@@ -1163,43 +1344,125 @@ 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: Options10.check
+});
+
+// src/requireDependency.ts
+import { mutateJson as mutateJson5 } from "@monorepolint/utils";
+import { diff as diff7 } from "jest-diff";
+import * as r11 from "runtypes";
+var Options11 = r11.Partial({
+  dependencies: r11.Dictionary(r11.String.optional()),
+  devDependencies: r11.Dictionary(r11.String.optional()),
+  peerDependencies: r11.Dictionary(r11.String.optional()),
+  optionalDependencies: r11.Dictionary(r11.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: Options11.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 r12 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 Options12 = r12.Partial({
+  file: r12.String,
+  generator: r12.Function,
+  tsconfigReferenceFile: r12.String,
+  template: r12.Record({}).Or(r12.String),
+  templateFile: r12.String,
+  excludedReferences: r12.Array(r12.String).Or(r12.Undefined),
+  additionalReferences: r12.Array(r12.String).Or(r12.Undefined)
 }).withConstraint(({ generator, template, templateFile }) => {
   let count = 0;
   if (generator) {
@@ -1217,7 +1480,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;
@@ -1232,7 +1495,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"
@@ -1241,18 +1504,30 @@ var standardTsconfig = createRuleFactory({
       });
     }
   },
-  validateOptions: Options9.check
+  validateOptions: Options12.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");
   }
@@ -1265,13 +1540,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)
         });
       }
     }
@@ -1285,98 +1563,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,
@@ -1385,8 +1571,10 @@ export {
   consistentVersions,
   createRuleFactory,
   fileContents,
+  forceError,
   mustSatisfyPeerDependencies,
   nestedWorkspaces,
+  oncePerPackage,
   packageEntry,
   packageOrder,
   packageScript,