@monorepolint/rules 0.5.0-alpha.10 → 0.5.0-alpha.106

package/build/js/index.js

@@ -0,0 +1,1417 @@
+// src/alphabeticalDependencies.ts
+import * as r from "runtypes";
+
+// src/util/checkAlpha.ts
+import { diff } from "jest-diff";
+function checkAlpha(context, block) {
+  const packageJson = context.getPackageJson();
+  const packagePath = context.getPackageJsonPath();
+  const blockToSort = packageJson[block];
+  if (blockToSort === void 0) {
+    return;
+  }
+  const actualOrder = Object.keys(blockToSort);
+  const expectedOrder = actualOrder.slice().sort();
+  if (!arrayOrderCompare(actualOrder, expectedOrder)) {
+    context.addError({
+      file: packagePath,
+      message: createIncorrectOrderErrorMessage(block, packageJson.name),
+      longMessage: diff(expectedOrder, actualOrder, { expand: true }),
+      fixer: () => {
+        const expectedDependencies = {};
+        expectedOrder.forEach((dep) => {
+          expectedDependencies[dep] = blockToSort[dep];
+        });
+        const newPackageJson = { ...packageJson };
+        newPackageJson[block] = expectedDependencies;
+        context.host.writeJson(packagePath, newPackageJson);
+      }
+    });
+  }
+}
+function arrayOrderCompare(a, b) {
+  for (let index = 0; index < a.length; index++) {
+    if (a[index] !== b[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function createIncorrectOrderErrorMessage(block, packageName) {
+  return `Incorrect order of ${block} in ${packageName}'s package.json`;
+}
+
+// src/util/makeRule.ts
+var globalId = 0;
+function makeRule({
+  name,
+  check,
+  optionsRuntype,
+  printStats
+}) {
+  return function(ruleEntry) {
+    const id = `${name} :: ${globalId++}`;
+    return {
+      id,
+      check: (context) => check(context, ruleEntry.options, { id }),
+      name,
+      optionsRuntype,
+      ruleEntry,
+      printStats
+    };
+  };
+}
+
+// src/alphabeticalDependencies.ts
+var Options = r.Undefined;
+var alphabeticalDependencies = makeRule({
+  name: "alphabeticalDependencies",
+  check: (context) => {
+    checkAlpha(context, "dependencies");
+    checkAlpha(context, "devDependencies");
+    checkAlpha(context, "peerDependencies");
+  },
+  optionsRuntype: Options
+});
+
+// src/alphabeticalScripts.ts
+import * as r2 from "runtypes";
+var Options2 = r2.Undefined;
+var alphabeticalScripts = makeRule({
+  name: "alphabeticalScripts",
+  check: (context) => {
+    checkAlpha(context, "scripts");
+  },
+  optionsRuntype: Options2
+});
+
+// src/bannedDependencies.ts
+import { matchesAnyGlob } from "@monorepolint/utils";
+import { AggregateTiming } from "@monorepolint/utils";
+import * as path2 from "node:path";
+import * as r3 from "runtypes";
+
+// src/util/packageDependencyGraphService.ts
+import * as path from "node:path";
+import resolvePackagePath from "resolve-package-path";
+var PackageDependencyGraphService = class {
+  buildDependencyGraph(startPackageJsonPath, host, maxDepth) {
+    const nodes = /* @__PURE__ */ new Map();
+    const visit = (packageJsonPath, currentDepth) => {
+      if (nodes.has(packageJsonPath)) {
+        return nodes.get(packageJsonPath);
+      }
+      const packageJson = host.readJson(packageJsonPath);
+      const node = {
+        packageJson,
+        dependencies: /* @__PURE__ */ new Map(),
+        paths: {
+          packageJsonPath,
+          rootDirectory: path.dirname(packageJsonPath)
+        }
+      };
+      nodes.set(packageJsonPath, node);
+      const nextDepth = currentDepth + 1;
+      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);
+          if (dependencyPackageJsonPath == null) {
+            throw new Error(`Could not resolve ${dependency} from ${node.paths.rootDirectory}`);
+          }
+          node.dependencies.set(dependency, visit(dependencyPackageJsonPath, nextDepth));
+        }
+      }
+      return node;
+    };
+    return visit(startPackageJsonPath, 0);
+  }
+  *traverse(root, opts = { traverseAllPaths: false }) {
+    const visited = /* @__PURE__ */ new Set();
+    function* visit(node, importPath = []) {
+      if (!opts.traverseAllPaths && visited.has(node)) {
+        return;
+      }
+      if (importPath.indexOf(node) !== -1) {
+        return;
+      }
+      visited.add(node);
+      importPath = [...importPath, node];
+      yield { ...node, importPath };
+      for (const dependency of node.dependencies.values()) {
+        yield* visit(dependency, importPath);
+      }
+    }
+    yield* visit(root);
+  }
+};
+
+// src/bannedDependencies.ts
+var bannedDepGlobsField = r3.Union(
+  r3.Array(r3.String),
+  r3.Record({
+    glob: r3.Array(r3.String).optional(),
+    exact: r3.Array(r3.String).optional()
+  })
+);
+var Options3 = r3.Union(
+  r3.Record({
+    bannedDependencies: bannedDepGlobsField,
+    bannedTransitiveDependencies: r3.Undefined.optional()
+  }),
+  r3.Record({
+    bannedDependencies: bannedDepGlobsField.optional(),
+    bannedTransitiveDependencies: r3.Array(r3.String)
+  }),
+  r3.Record({
+    bannedDependencies: bannedDepGlobsField.optional(),
+    bannedTransitiveDependencies: r3.Array(r3.String).optional()
+  })
+);
+var setCache = /* @__PURE__ */ new Map();
+var aggregateTiming = new AggregateTiming(":bannedDependencies stats");
+var bannedDependencies = makeRule({
+  name: "bannedDependencies",
+  check: (context, opts, extra) => {
+    aggregateTiming.start((extra == null ? void 0 : extra.id) ?? "unknown id");
+    const packageJson = context.getPackageJson();
+    const packagePath = context.getPackageJsonPath();
+    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 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 (exacts) {
+      let set = setCache.get(exacts);
+      if (set === void 0) {
+        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 (violations.size > 0) {
+      context.addError({
+        file: packagePath,
+        message: `Found ${violations.size} banned dependencies of package.json:
+	` + Array.from(violations).map((v) => `'${v}'`).join(", ")
+      });
+    }
+    if (transitives) {
+      let set = setCache.get(transitives);
+      if (set === void 0) {
+        set = new Set(transitives);
+        setCache.set(transitives, set);
+      }
+      checkTransitives(context, set);
+    }
+    aggregateTiming.stop();
+  },
+  optionsRuntype: Options3,
+  printStats: () => {
+    aggregateTiming.printResults();
+  }
+});
+function populateProblemsExact(banned, dependencies, violations) {
+  for (const dependency of dependencies) {
+    if (banned.has(dependency)) {
+      violations.add(dependency);
+    }
+  }
+}
+function populateProblemsGlobs(bannedDependencyGlobs, dependencies, violations) {
+  for (const dependency of dependencies) {
+    if (matchesAnyGlob(dependency, bannedDependencyGlobs)) {
+      violations.add(dependency);
+    }
+  }
+}
+function checkTransitives(context, banned) {
+  const graphService = new PackageDependencyGraphService();
+  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(" -> ");
+        context.addError({
+          file: root.paths.packageJsonPath,
+          message: `Banned transitive dependencies in repo: ${pathing}`
+        });
+      }
+    }
+  }
+}
+function nameOrPackageJsonPath(node) {
+  return node.packageJson.name ?? node.paths.packageJsonPath;
+}
+
+// src/consistentDependencies.ts
+import { diff as diff2 } from "jest-diff";
+import * as r4 from "runtypes";
+var Options4 = r4.Record({
+  ignoredDependencies: r4.Array(r4.String).Or(r4.Undefined)
+}).Or(r4.Undefined);
+var skippedVersions = ["*", "latest"];
+var consistentDependencies = makeRule({
+  name: "consistentDependencies",
+  check: (context, args) => {
+    checkDeps(context, args, "dependencies");
+    checkDeps(context, args, "devDependencies");
+  },
+  optionsRuntype: Options4
+});
+function checkDeps(context, args, block) {
+  const packageJson = context.getPackageJson();
+  const packagePath = context.getPackageJsonPath();
+  const dependencies = packageJson[block];
+  const workspacePackageJson = context.getWorkspaceContext().getPackageJson();
+  const workspaceDependencies = workspacePackageJson[block];
+  const ignoredDeps = (args == null ? void 0 : args.ignoredDependencies) ?? [];
+  const depsToCheck = workspaceDependencies == null || ignoredDeps.length === 0 ? workspaceDependencies : omit(workspaceDependencies, ignoredDeps);
+  if (dependencies === void 0 || depsToCheck === void 0) {
+    return;
+  }
+  const expectedDependencies = {
+    ...dependencies,
+    ...filterKeys(depsToCheck, dependencies)
+  };
+  if (JSON.stringify(dependencies) !== JSON.stringify(expectedDependencies)) {
+    context.addError({
+      file: packagePath,
+      message: `Inconsistent ${block} with root in package.json`,
+      longMessage: diff2(expectedDependencies, dependencies, { expand: true }),
+      fixer: () => {
+        const newPackageJson = { ...packageJson };
+        newPackageJson[block] = expectedDependencies;
+        context.host.writeJson(packagePath, newPackageJson);
+      }
+    });
+  }
+}
+function filterKeys(ob, filterOb) {
+  const newOb = {};
+  for (const key of Object.keys(filterOb)) {
+    if (ob[key] !== void 0 && skippedVersions.indexOf(filterOb[key]) === -1) {
+      newOb[key] = ob[key];
+    }
+  }
+  return newOb;
+}
+function omit(obj, keysToOmit) {
+  const newObj = {};
+  const filtered = Object.entries(obj).filter(([key]) => !keysToOmit.includes(key));
+  for (const [key, value] of filtered) {
+    newObj[key] = value;
+  }
+  return newObj;
+}
+
+// src/consistentVersions.ts
+import { mutateJson } from "@monorepolint/utils";
+import * as r5 from "runtypes";
+import { coerce } from "semver";
+var Options5 = r5.Record({
+  matchDependencyVersions: r5.Dictionary(r5.Union(r5.String, r5.Array(r5.String)))
+});
+var consistentVersions = makeRule({
+  name: "consistentVersions",
+  check: checkConsistentVersions,
+  optionsRuntype: Options5
+});
+function checkConsistentVersions(context, options) {
+  for (const [dependencyPackageName, expectedPackageDependencyValue] of Object.entries(
+    options.matchDependencyVersions
+  )) {
+    if (Array.isArray(expectedPackageDependencyValue)) {
+      ensurePackageMatchesSomeVersion(context, dependencyPackageName, expectedPackageDependencyValue);
+    } else {
+      ensurePackageIsCorrectVersion(context, dependencyPackageName, expectedPackageDependencyValue);
+    }
+  }
+}
+var ensurePackageIsCorrectVersion = (context, dependencyPackageName, expectedPackageDependencyValue) => {
+  const packageJson = context.getPackageJson();
+  const packageJsonPath = context.getPackageJsonPath();
+  const expectedPackageDependencyVersion = coerce(expectedPackageDependencyValue);
+  if (expectedPackageDependencyVersion == null) {
+    throw new Error(
+      `Malformed expected package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${expectedPackageDependencyValue}'`
+    );
+  }
+  const actualPackageDependencyValue = packageJson.dependencies && packageJson.dependencies[dependencyPackageName];
+  const actualPackageDependencyVersion = coerce(actualPackageDependencyValue);
+  if (actualPackageDependencyVersion != null && actualPackageDependencyVersion.raw !== expectedPackageDependencyVersion.raw) {
+    context.addError({
+      file: packageJsonPath,
+      message: `Expected dependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDependencyValue}' instead.`,
+      fixer: () => mutateJson(packageJsonPath, context.host, (input) => {
+        input.dependencies[dependencyPackageName] = expectedPackageDependencyValue;
+        return input;
+      })
+    });
+  }
+  const actualPackageDevDependencyValue = packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
+  const actualPackageDevDependencyVersion = coerce(actualPackageDevDependencyValue);
+  if (actualPackageDevDependencyVersion != null && actualPackageDevDependencyVersion.raw !== expectedPackageDependencyVersion.raw) {
+    context.addError({
+      file: packageJsonPath,
+      message: `Expected devDependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDevDependencyValue}' instead`,
+      fixer: () => mutateJson(packageJsonPath, context.host, (input) => {
+        input.devDependencies[dependencyPackageName] = expectedPackageDependencyValue;
+        return input;
+      })
+    });
+  }
+};
+var ensurePackageMatchesSomeVersion = (context, dependencyPackageName, acceptedPackageDependencyValues) => {
+  const packageJson = context.getPackageJson();
+  const packageJsonPath = context.getPackageJsonPath();
+  const acceptedPackageDependencyVersions = acceptedPackageDependencyValues.map(
+    (acceptedPackageDependencyValue) => {
+      const acceptedPackageDependencyVersion = coerce(acceptedPackageDependencyValue);
+      if (acceptedPackageDependencyVersion == null) {
+        throw new Error(
+          `Malformed accepted package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${acceptedPackageDependencyValue}'`
+        );
+      }
+      return acceptedPackageDependencyVersion;
+    }
+  );
+  const actualPackageDependencyValue = packageJson.dependencies && packageJson.dependencies[dependencyPackageName];
+  const actualPackageDependencyVersion = coerce(actualPackageDependencyValue);
+  if (actualPackageDependencyVersion != null && acceptedPackageDependencyVersions.every(
+    (acceptedPackageDependencyVersion) => actualPackageDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
+  )) {
+    context.addError({
+      file: packageJsonPath,
+      message: `Expected dependency on ${dependencyPackageName} to match one of '${JSON.stringify(
+        acceptedPackageDependencyValues
+      )}', got '${actualPackageDependencyValue}' instead.`
+    });
+  }
+  const actualPackageDevDependencyValue = packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
+  const actualPackageDevDependencyVersion = coerce(actualPackageDevDependencyValue);
+  if (actualPackageDevDependencyVersion != null && acceptedPackageDependencyVersions.every(
+    (acceptedPackageDependencyVersion) => actualPackageDevDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
+  )) {
+    context.addError({
+      file: packageJsonPath,
+      message: `Expected devDependency on ${dependencyPackageName} to match one of '${JSON.stringify(
+        acceptedPackageDependencyValues
+      )}', got '${actualPackageDevDependencyValue}' instead.`
+    });
+  }
+};
+
+// src/fileContents.ts
+import { diff as diff3 } from "jest-diff";
+import * as path3 from "path";
+import * as r6 from "runtypes";
+var Options6 = r6.Union(
+  r6.Record({
+    file: r6.String,
+    generator: r6.Function,
+    template: r6.Undefined.optional(),
+    templateFile: r6.Undefined.optional()
+  }),
+  r6.Record({
+    file: r6.String,
+    generator: r6.Undefined.optional(),
+    template: r6.String,
+    templateFile: r6.Undefined.optional()
+  }),
+  r6.Record({
+    file: r6.String,
+    generator: r6.Undefined.optional(),
+    template: r6.Undefined.optional(),
+    templateFile: r6.String
+  })
+);
+var fileContents = makeRule({
+  name: "fileContents",
+  check: (context, opts) => {
+    const fullPath = path3.join(context.packageDir, opts.file);
+    const expectedContent = getExpectedContents(context, opts);
+    const pathExists = context.host.exists(fullPath);
+    const actualContent = pathExists ? context.host.readFile(fullPath, { encoding: "utf-8" }) : void 0;
+    if (actualContent !== expectedContent) {
+      context.addError({
+        file: fullPath,
+        message: "Expect file contents to match",
+        longMessage: diff3(expectedContent, actualContent, { expand: true }),
+        fixer: () => {
+          if (expectedContent === void 0) {
+            if (pathExists)
+              context.host.deleteFile(fullPath);
+          } else {
+            context.host.mkdir(path3.dirname(fullPath), { recursive: true });
+            context.host.writeFile(fullPath, expectedContent, { encoding: "utf-8" });
+          }
+        }
+      });
+    }
+  },
+  optionsRuntype: Options6
+});
+var optionsCache = /* @__PURE__ */ new Map();
+function getExpectedContents(context, opts) {
+  if (optionsCache.has(opts)) {
+    const cachedEntry = optionsCache.get(opts);
+    if (cachedEntry && typeof cachedEntry === "function") {
+      return cachedEntry(context);
+    }
+    return cachedEntry;
+  }
+  if (opts.generator) {
+    optionsCache.set(opts, opts.generator);
+    return opts.generator(context);
+  } else if (opts.templateFile) {
+    const { packageDir: workspacePackageDir } = context.getWorkspaceContext();
+    const fullPath = path3.resolve(workspacePackageDir, opts.templateFile);
+    const template = context.host.readFile(fullPath, { encoding: "utf-8" });
+    optionsCache.set(opts, template);
+    return template;
+  } else {
+    optionsCache.set(opts, opts.template);
+    return opts.template;
+  }
+}
+
+// src/mustSatisfyPeerDependencies.ts
+import { mutateJson as mutateJson2 } from "@monorepolint/utils";
+import * as path4 from "node:path";
+import * as r7 from "runtypes";
+import { coerce as coerce2 } from "semver";
+import resolvePackagePath2 from "resolve-package-path";
+var Options7 = r7.Union(
+  r7.Partial({
+    skipUnparseableRanges: r7.Undefined,
+    dependencyWhitelist: r7.Undefined,
+    dependencyBlacklist: r7.Undefined,
+    enforceForDevDependencies: r7.Undefined
+  }),
+  r7.Record({
+    skipUnparseableRanges: r7.Boolean
+  }).And(
+    r7.Partial({
+      dependencyWhitelist: r7.Undefined,
+      dependencyBlacklist: r7.Undefined,
+      enforceForDevDependencies: r7.Undefined
+    })
+  ),
+  r7.Record({
+    dependencyWhitelist: r7.Array(r7.String)
+  }).And(
+    r7.Partial({
+      skipUnparseableRanges: r7.Undefined,
+      dependencyBlacklist: r7.Undefined,
+      enforceForDevDependencies: r7.Undefined
+    })
+  ),
+  r7.Record({
+    dependencyBlacklist: r7.Array(r7.String)
+  }).And(
+    r7.Partial({
+      skipUnparseableRanges: r7.Undefined,
+      dependencyWhitelist: r7.Undefined,
+      enforceForDevDependencies: r7.Undefined
+    })
+  ),
+  r7.Record({
+    enforceForDevDependencies: r7.Boolean
+  }).And(
+    r7.Partial({
+      skipUnparseableRanges: r7.Undefined,
+      dependencyWhitelist: r7.Undefined,
+      dependencyBlacklist: r7.Undefined
+    })
+  ),
+  r7.Record({
+    skipUnparseableRanges: r7.Boolean,
+    dependencyWhitelist: r7.Array(r7.String)
+  }).And(
+    r7.Partial({
+      dependencyBlacklist: r7.Undefined,
+      enforceForDevDependencies: r7.Undefined
+    })
+  ),
+  r7.Record({
+    skipUnparseableRanges: r7.Boolean,
+    dependencyBlacklist: r7.Array(r7.String)
+  }).And(
+    r7.Partial({
+      dependencyWhitelist: r7.Undefined,
+      enforceForDevDependencies: r7.Undefined
+    })
+  ),
+  r7.Record({
+    skipUnparseableRanges: r7.Boolean,
+    enforceForDevDependencies: r7.Boolean
+  }).And(
+    r7.Partial({
+      dependencyWhitelist: r7.Undefined,
+      dependencyBlacklist: r7.Undefined
+    })
+  ),
+  r7.Record({
+    dependencyWhitelist: r7.Array(r7.String),
+    dependencyBlacklist: r7.Array(r7.String)
+  }).And(
+    r7.Partial({
+      skipUnparseableRanges: r7.Undefined,
+      enforceForDevDependencies: r7.Undefined
+    })
+  ),
+  r7.Record({
+    dependencyWhitelist: r7.Array(r7.String),
+    enforceForDevDependencies: r7.Boolean
+  }).And(
+    r7.Partial({
+      skipUnparseableRanges: r7.Undefined,
+      dependencyBlacklist: r7.Undefined
+    })
+  ),
+  r7.Record({
+    dependencyBlacklist: r7.Array(r7.String),
+    enforceForDevDependencies: r7.Boolean
+  }).And(
+    r7.Partial({
+      skipUnparseableRanges: r7.Undefined,
+      dependencyWhitelist: r7.Undefined
+    })
+  ),
+  r7.Record({
+    skipUnparseableRanges: r7.Boolean,
+    dependencyWhitelist: r7.Array(r7.String),
+    dependencyBlacklist: r7.Array(r7.String)
+  }).And(
+    r7.Partial({
+      enforceForDevDependencies: r7.Undefined
+    })
+  ),
+  r7.Record({
+    skipUnparseableRanges: r7.Boolean,
+    dependencyWhitelist: r7.Array(r7.String),
+    enforceForDevDependencies: r7.Boolean
+  }).And(
+    r7.Partial({
+      dependencyBlacklist: r7.Undefined
+    })
+  ),
+  r7.Record({
+    skipUnparseableRanges: r7.Boolean,
+    dependencyBlacklist: r7.Array(r7.String),
+    enforceForDevDependencies: r7.Boolean
+  }).And(
+    r7.Partial({
+      dependencyWhitelist: r7.Undefined
+    })
+  ),
+  r7.Record({
+    dependencyWhitelist: r7.Array(r7.String),
+    dependencyBlacklist: r7.Array(r7.String),
+    enforceForDevDependencies: r7.Boolean
+  }).And(
+    r7.Partial({
+      skipUnparseableRanges: r7.Undefined
+    })
+  ),
+  r7.Record({
+    skipUnparseableRanges: r7.Boolean,
+    dependencyWhitelist: r7.Array(r7.String),
+    dependencyBlacklist: r7.Array(r7.String),
+    enforceForDevDependencies: r7.Boolean
+  })
+);
+var mustSatisfyPeerDependencies = makeRule({
+  name: "mustSatisfyPeerDependencies",
+  check: checkSatisfyPeerDependencies,
+  optionsRuntype: Options7
+});
+var MATCH_ANY_VERSION_RANGE = /^(\*|x)$/;
+var MATCH_GREATER_OR_EQUAL_VERSION_RANGE = /^>= ?\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-]+)*))?)?$/;
+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 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 })) {
+      continue;
+    }
+    const dependencyRange = packageDependencies[peerDependencyName];
+    if (dependencyRange != null) {
+      context.addError({
+        file: packageJsonPath,
+        message: `[0] Package ${packageName} has overloaded ${peerDependencyName} dependencies.
+	Peer dependency '${peerDependencyRange}' and regular dependency '${dependencyRange}'.`
+      });
+    }
+  }
+  const allRequiredPeerDependencies = {};
+  const allDependencies = enforceForDevDependencies ? [...Object.keys(packageDependencies), ...Object.keys(packageDevDependencies)] : Object.keys(packageDependencies);
+  for (const dependency of allDependencies) {
+    const dependencyPackageJsonPath = resolvePackagePath2(dependency, path4.dirname(packageJsonPath));
+    if (dependencyPackageJsonPath == null) {
+      throw new Error(`Could not resolve ${dependency} from ${path4.dirname(packageJsonPath)}`);
+    }
+    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 })) {
+        continue;
+      }
+      if (!isValidRange(range)) {
+        const message = `Unable to parse ${dependencyPackageJson.name}'s ${peerDependencyName} peer dependency range '${range}'.`;
+        if (skipUnparseableRanges) {
+          context.addWarning({ file: dependencyPackageJsonPath, message });
+          continue;
+        }
+        throw new Error(message);
+      }
+      if (allRequiredPeerDependencies[peerDependencyName] == null) {
+        allRequiredPeerDependencies[peerDependencyName] = [];
+      }
+      allRequiredPeerDependencies[peerDependencyName].push({ fromPackageName: dependencyPackageJson.name, range });
+    }
+  }
+  for (const [peerDependencyName, peerDependencyRequirements] of Object.entries(allRequiredPeerDependencies)) {
+    let mostStrictPeerRequirement = {
+      fromPeerDependencyRequirements: [peerDependencyRequirements[0]],
+      range: peerDependencyRequirements[0].range
+    };
+    for (const peerRequirement of peerDependencyRequirements) {
+      if (doesASatisfyB(mostStrictPeerRequirement.range, peerRequirement.range)) {
+        continue;
+      } else if (doesASatisfyB(peerRequirement.range, mostStrictPeerRequirement.range)) {
+        mostStrictPeerRequirement = {
+          fromPeerDependencyRequirements: [peerRequirement],
+          range: peerRequirement.range
+        };
+      } else {
+        const maybeIntersection = findIntersection(peerRequirement.range, mostStrictPeerRequirement.range);
+        if (maybeIntersection !== void 0) {
+          mostStrictPeerRequirement = {
+            fromPeerDependencyRequirements: [
+              ...mostStrictPeerRequirement.fromPeerDependencyRequirements,
+              peerRequirement
+            ],
+            range: maybeIntersection
+          };
+        } else {
+          context.addError({
+            file: packageJsonPath,
+            message: `[1] Package ${packageName} has conflicting inherited ${peerDependencyName} peer dependencies.
+	Dependency ${peerRequirement.fromPackageName} requires '${peerRequirement.range}' but
+	` + getMostStrictStatement(mostStrictPeerRequirement)
+          });
+        }
+      }
+    }
+    const packageDependencyRange = packageDependencies[peerDependencyName];
+    if (packageDependencyRange != null) {
+      if (!isValidRange(packageDependencyRange)) {
+        const message = `Unable to parse ${packageName}'s ${peerDependencyName} dependency range '${packageDependencyRange}'.`;
+        if (skipUnparseableRanges) {
+          context.addWarning({ file: packageJsonPath, message });
+        } else {
+          throw new Error(message);
+        }
+      } else if (!doesASatisfyB(packageDependencyRange, mostStrictPeerRequirement.range)) {
+        context.addError({
+          file: packageJsonPath,
+          message: `[2] Package ${packageName} dependency on ${peerDependencyName} '${packageDependencyRange}' does not satisfy inherited peer dependencies.
+	` + getMostStrictStatement(mostStrictPeerRequirement)
+        });
+      }
+    }
+    const packagePeerDependencyRange = packagePeerDependencies[peerDependencyName];
+    if (packageDependencyRange == null && packagePeerDependencyRange == null) {
+      context.addError({
+        file: packageJsonPath,
+        message: `[3] Package ${packageName} is missing required ${peerDependencyName} dependency.
+	` + getMostStrictStatement(mostStrictPeerRequirement),
+        fixer: getAddDependencyTypeFixer({
+          packageJsonPath,
+          dependencyType: "peerDependencies",
+          dependencyName: peerDependencyName,
+          version: mostStrictPeerRequirement.range,
+          host: context.host
+        })
+      });
+    }
+    if (packagePeerDependencyRange != null) {
+      if (!isValidRange(packagePeerDependencyRange)) {
+        const message = `Unable to parse ${packageName}'s ${peerDependencyName} peer dependency range '${packagePeerDependencyRange}'.`;
+        if (skipUnparseableRanges) {
+          context.addWarning({ file: packageJsonPath, message });
+        } else {
+          throw new Error(message);
+        }
+      } else if (!doesASatisfyB(packagePeerDependencyRange, mostStrictPeerRequirement.range)) {
+        context.addError({
+          file: packageJsonPath,
+          message: `[4] Package ${packageName} peer dependency on ${peerDependencyName} '${packagePeerDependencyRange}' is not strict enough.
+	` + getMostStrictStatement(mostStrictPeerRequirement),
+          fixer: getAddDependencyTypeFixer({
+            packageJsonPath,
+            dependencyType: "peerDependencies",
+            dependencyName: peerDependencyName,
+            version: mostStrictPeerRequirement.range,
+            host: context.host
+          })
+        });
+      }
+    }
+  }
+}
+function shouldSkipPackage({
+  dependencyBlacklist,
+  dependencyWhitelist,
+  packageName
+}) {
+  if (dependencyBlacklist != null && dependencyBlacklist.includes(packageName) || dependencyWhitelist != null && !dependencyWhitelist.includes(packageName)) {
+    return true;
+  }
+  return false;
+}
+function getMostStrictStatement(mostStrictPeerRequirement) {
+  if (mostStrictPeerRequirement.fromPeerDependencyRequirements.length === 1) {
+    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(", ");
+    return `Dependencies [${dependencyNames}] require [${dependencyRequirements}] respectively, resolving to '${mostStrictPeerRequirement.range}'.`;
+  }
+}
+function findIntersection(a, b) {
+  if (doesASatisfyB(a, b)) {
+    return a;
+  } else if (doesASatisfyB(b, a)) {
+    return b;
+  }
+  if (isAnyVersionRange(a) || isAnyVersionRange(b)) {
+    throw new Error();
+  }
+  const aVersions = a.includes("||") ? a.split("||").map((s) => s.trim()) : [a];
+  const bVersions = b.includes("||") ? b.split("||").map((s) => s.trim()) : [b];
+  const aIsGreaterOrEqualVersionRange = isGreaterOrEqualVersionRange(a);
+  const bIsGreaterOrEqualVersionRange = isGreaterOrEqualVersionRange(b);
+  if (aIsGreaterOrEqualVersionRange && bIsGreaterOrEqualVersionRange) {
+    throw new Error();
+  }
+  if (aIsGreaterOrEqualVersionRange) {
+    const aSemVer = coerce2(a);
+    const compatibleBVersions = bVersions.map((bVersion) => {
+      const bSemVer = coerce2(bVersion);
+      if (bVersion.startsWith("^") && bSemVer.major >= aSemVer.major) {
+        return `^${bSemVer.compare(aSemVer) >= 0 ? bSemVer.raw : aSemVer.raw}`;
+      }
+      return bSemVer.compare(aSemVer) !== -1 ? bVersion : void 0;
+    }).filter((bVersion) => bVersion != null);
+    if (compatibleBVersions.length === 0) {
+      return void 0;
+    }
+    return compatibleBVersions.join(" || ");
+  }
+  if (bIsGreaterOrEqualVersionRange) {
+    const bSemVer = coerce2(b);
+    const compatibleAVersions = aVersions.map((aVersion) => {
+      const aSemVer = coerce2(aVersion);
+      if (aVersion.startsWith("^") && aSemVer.major >= bSemVer.major) {
+        return `^${aSemVer.compare(bSemVer) >= 0 ? aSemVer.raw : bSemVer.raw}`;
+      }
+      return aSemVer.compare(bSemVer) !== -1 ? aVersion : void 0;
+    }).filter((aVersion) => aVersion != null);
+    if (compatibleAVersions.length === 0) {
+      return void 0;
+    }
+    return compatibleAVersions.join(" || ");
+  }
+  const compatibleVersions = aVersions.map((aVersion) => {
+    const aSemVer = coerce2(aVersion);
+    const majorMatchingBVersion = bVersions.find((m) => coerce2(m).major === aSemVer.major);
+    if (majorMatchingBVersion === void 0) {
+      return void 0;
+    }
+    if (doesASatisfyB(aVersion, majorMatchingBVersion)) {
+      return aVersion;
+    } else if (doesASatisfyB(majorMatchingBVersion, aVersion)) {
+      return majorMatchingBVersion;
+    } else {
+      return void 0;
+    }
+  }).filter((aVersion) => aVersion !== void 0);
+  if (compatibleVersions.length === 0) {
+    return void 0;
+  }
+  return compatibleVersions.join(" || ");
+}
+function doesASatisfyB(a, b) {
+  if (a === b) {
+    return true;
+  }
+  const aIsAnyVersionRange = isAnyVersionRange(a);
+  const bIsAnyVersionRange = isAnyVersionRange(b);
+  if (bIsAnyVersionRange) {
+    return true;
+  } else if (aIsAnyVersionRange) {
+    return false;
+  }
+  const aVersions = a.includes("||") ? a.split("||").map((s) => s.trim()) : [a];
+  const bVersions = b.includes("||") ? b.split("||").map((s) => s.trim()) : [b];
+  const aIsGreaterOrEqualVersionRange = isGreaterOrEqualVersionRange(a);
+  const bIsGreaterOrEqualVersionRange = isGreaterOrEqualVersionRange(b);
+  if (aIsGreaterOrEqualVersionRange && bIsGreaterOrEqualVersionRange) {
+    const aSemVer = coerce2(a);
+    const bSemVer = coerce2(b);
+    return aSemVer.compare(bSemVer) !== -1;
+  } else if (bIsGreaterOrEqualVersionRange) {
+    const bSemVer = coerce2(b);
+    return aVersions.every((aVersion) => {
+      const aSemVer = coerce2(aVersion);
+      return aSemVer.compare(bSemVer) !== -1;
+    });
+  } else if (aIsGreaterOrEqualVersionRange) {
+    return false;
+  }
+  return aVersions.every((aVersion) => {
+    const aSemVer = coerce2(aVersion);
+    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);
+    if (majorMatchingBVersionIsRange) {
+      return aSemVer.compare(majorMatchingBSemVer) !== -1;
+    } else {
+      if (aVersionIsRange) {
+        return false;
+      } else {
+        return aSemVer.compare(majorMatchingBSemVer) === 0;
+      }
+    }
+  });
+}
+function isAnyVersionRange(version) {
+  return MATCH_ANY_VERSION_RANGE.test(version);
+}
+function isGreaterOrEqualVersionRange(version) {
+  return MATCH_GREATER_OR_EQUAL_VERSION_RANGE.test(version);
+}
+function isMajorVersionRange(version) {
+  return MATCH_MAJOR_VERSION_RANGE.test(version);
+}
+function isValidRange(version) {
+  return RANGE_REGEX.test(version);
+}
+function getAddDependencyTypeFixer({
+  packageJsonPath,
+  dependencyType,
+  dependencyName,
+  version,
+  host
+}) {
+  return () => {
+    mutateJson2(packageJsonPath, host, (packageJson) => {
+      if (packageJson[dependencyType] == null) {
+        packageJson[dependencyType] = {};
+      }
+      packageJson[dependencyType][dependencyName] = version;
+      return packageJson;
+    });
+  };
+}
+
+// src/packageOrder.ts
+import { diff as diff4 } 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",
+  "description",
+  "author",
+  "contributors",
+  "url",
+  "license",
+  "type",
+  "exports",
+  "private",
+  "engines",
+  "bin",
+  "types",
+  "main",
+  "module",
+  "typings",
+  "style",
+  "sideEffects",
+  "workspaces",
+  "husky",
+  "lint-staged",
+  "files",
+  "scripts",
+  "resolutions",
+  "dependencies",
+  "peerDependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "publishConfig"
+];
+var packageOrder = makeRule({
+  name: "packageOrder",
+  check: (context, opts) => {
+    const packageJson = context.getPackageJson();
+    const packagePath = context.getPackageJsonPath();
+    const order = opts === void 0 ? defaultKeyOrder : opts.order;
+    const comparator = isOrderFunction(order) ? order(context) : createComparator(order);
+    const actualOrder = Object.keys(packageJson);
+    const expectedOrder = actualOrder.slice().sort(comparator);
+    if (!arrayOrderCompare2(actualOrder, expectedOrder)) {
+      context.addError({
+        file: packagePath,
+        message: "Incorrect order of fields in package.json",
+        longMessage: diff4(expectedOrder, actualOrder, { expand: true }),
+        fixer: () => {
+          const expectedPackageJson = {};
+          expectedOrder.forEach((key) => {
+            expectedPackageJson[key] = packageJson[key];
+          });
+          context.host.writeJson(packagePath, expectedPackageJson);
+        }
+      });
+    }
+  },
+  optionsRuntype: Options8
+});
+function arrayOrderCompare2(a, b) {
+  for (let index = 0; index < a.length; index++) {
+    if (a[index] !== b[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function createComparator(order) {
+  return (a, b) => {
+    const aIndex = order.indexOf(a);
+    const bIndex = order.indexOf(b);
+    if (aIndex >= 0 && bIndex < 0) {
+      return -1;
+    } else if (aIndex < 0 && bIndex >= 0) {
+      return 1;
+    }
+    const compared = aIndex - bIndex;
+    if (compared !== 0) {
+      return compared;
+    } else {
+      return a.localeCompare(b);
+    }
+  };
+}
+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 r9 from "runtypes";
+var Options9 = r9.Union(
+  r9.Record({
+    entries: r9.Dictionary(r9.Unknown)
+  }).And(
+    r9.Partial({
+      entriesExist: r9.Undefined
+    })
+  ),
+  r9.Record({
+    entriesExist: r9.Array(r9.String)
+  }).And(
+    r9.Partial({
+      entries: r9.Undefined
+    })
+  ),
+  r9.Record({
+    entries: r9.Dictionary(r9.Unknown),
+    entriesExist: r9.Array(r9.String)
+  })
+);
+var packageEntry = makeRule({
+  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)
+          });
+        }
+      }
+    }
+  },
+  optionsRuntype: Options9
+});
+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 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()
+      })
+    )
+  )
+});
+var MSG_NO_SCRIPTS_BLOCK = "No scripts block in package.json";
+var packageScript = makeRule({
+  name: "packageScript",
+  check: (context, options) => {
+    const packageJson = context.getPackageJson();
+    if (packageJson.scripts === void 0) {
+      context.addError({
+        file: context.getPackageJsonPath(),
+        message: MSG_NO_SCRIPTS_BLOCK,
+        fixer: () => {
+          mutateJson4(context.getPackageJsonPath(), context.host, (input) => {
+            input.scripts = {};
+            return input;
+          });
+        }
+      });
+      return;
+    }
+    for (const [name, value] of Object.entries(options.scripts)) {
+      const allowedValues = /* @__PURE__ */ new Set();
+      let fixValue;
+      let allowEmpty = false;
+      let fixToEmpty = false;
+      if (typeof value === "string") {
+        allowedValues.add(value);
+        fixValue = value;
+      } else {
+        for (const q of value.options) {
+          if (q === void 0) {
+            allowEmpty = true;
+          }
+          allowedValues.add(q);
+        }
+        fixToEmpty = Object.prototype.hasOwnProperty.call(value, "fixValue") && value.fixValue === void 0;
+        fixValue = value.fixValue;
+      }
+      const actualValue = packageJson.scripts[name];
+      if (!allowedValues.has(actualValue) && !(allowEmpty === true && actualValue === void 0)) {
+        let fixer;
+        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;
+              }
+              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"),
+          fixer
+        });
+      }
+    }
+  },
+  optionsRuntype: Options10
+});
+
+// src/standardTsconfig.ts
+import { matchesAnyGlob as matchesAnyGlob2 } from "@monorepolint/utils";
+import { diff as diff7 } from "jest-diff";
+import * as path5 from "path";
+import * as r11 from "runtypes";
+var DEFAULT_TSCONFIG_FILENAME = "tsconfig.json";
+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) {
+    count++;
+  }
+  if (template) {
+    count++;
+  }
+  if (templateFile) {
+    count++;
+  }
+  return count === 1 || "Expect one of { generator, template, templateFile }";
+});
+var standardTsconfig = makeRule({
+  name: "standardTsconfig",
+  check: async (context, opts) => {
+    const tsconfigFileName = opts.file ?? DEFAULT_TSCONFIG_FILENAME;
+    const fullPath = path5.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;
+    if (expectedContent === void 0) {
+      context.addWarning({
+        file: fullPath,
+        message: "Excluding from expect-standard-tsconfig"
+      });
+      return;
+    }
+    if (actualContent !== expectedContent) {
+      context.addError({
+        file: fullPath,
+        message: "Expect file contents to match",
+        longMessage: diff7(expectedContent, actualContent, { expand: true }),
+        fixer: () => {
+          context.host.writeFile(fullPath, expectedContent, {
+            encoding: "utf-8"
+          });
+        }
+      });
+    }
+  },
+  optionsRuntype: Options11
+});
+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);
+  } else if (opts.template) {
+    return makeGenerator(opts.template, opts.excludedReferences, opts.additionalReferences, opts.tsconfigReferenceFile);
+  } else {
+    throw new Error("Unable to make generator");
+  }
+}
+function makeGenerator(template, excludedReferences, additionalReferences, tsconfigReferenceFile) {
+  return async function generator(context) {
+    template = {
+      ...template,
+      references: []
+    };
+    const nameToDirectory = await context.getWorkspaceContext().getPackageNameToDir();
+    const packageJson = context.getPackageJson();
+    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;
+        template.references.push({
+          path: path5.relative(context.packageDir, absoluteReferencePath)
+        });
+      }
+    }
+    if (additionalReferences) {
+      for (const additionalReference of additionalReferences) {
+        template.references.push({
+          path: additionalReference
+        });
+      }
+    }
+    return JSON.stringify(template, void 0, 2) + "\n";
+  };
+}
+
+// src/nestedWorkspaces.ts
+import * as globby from "globby";
+import * as path6 from "node:path";
+import * as r12 from "runtypes";
+var Options12 = r12.Undefined;
+var nestedWorkspaces = makeRule({
+  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/*".`
+      });
+    }
+  },
+  optionsRuntype: Options12
+});
+
+// src/requireDependency.ts
+import { mutateJson as mutateJson5 } from "@monorepolint/utils";
+import { diff as diff8 } from "jest-diff";
+import * as r13 from "runtypes";
+var Options13 = r13.Partial({
+  dependencies: r13.Dictionary(r13.String),
+  devDependencies: r13.Dictionary(r13.String),
+  peerDependencies: r13.Dictionary(r13.String),
+  optionalDependencies: r13.Dictionary(r13.String)
+});
+var requireDependency = makeRule({
+  name: "requireDependency",
+  check: function expectPackageEntry(context, options) {
+    const packageJson = context.getPackageJson();
+    const packageJsonPath = context.getPackageJsonPath();
+    [
+      "dependencies",
+      "devDependencies",
+      "peerDependencies",
+      "optionalDependencies"
+    ].forEach((type) => {
+      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 (packageJson[type][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;
+              });
+            }
+          });
+        }
+      }
+    });
+  },
+  optionsRuntype: Options13
+});
+export {
+  alphabeticalDependencies,
+  alphabeticalScripts,
+  bannedDependencies,
+  consistentDependencies,
+  consistentVersions,
+  fileContents,
+  mustSatisfyPeerDependencies,
+  nestedWorkspaces,
+  packageEntry,
+  packageOrder,
+  packageScript,
+  requireDependency,
+  standardTsconfig
+};
+/*!
+ * Copyright 2019 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+/*!
+ * Copyright 2020 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+/*!
+ * Copyright 2023 Palantir Technologies, Inc.
+ *
+ * Licensed under the MIT license. See LICENSE file in the project root for details.
+ *
+ */
+/**
+ * @license Copyright 2019 Palantir Technologies, Inc. All rights reserved.
+ */
+//# sourceMappingURL=index.js.map