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

package/src/packageScript.ts

@@ -17,8 +17,8 @@ export const Options = r.Record({
       r.Record({
         options: r.Array(r.String.Or(r.Undefined)),
         fixValue: r.Union(r.String, r.Undefined, r.Literal(false)).optional(),
-      })
-    )
+      }),
+    ),
   ), // string => string
 });
 
@@ -35,10 +35,14 @@ export const packageScript = createRuleFactory<Options>({
         file: context.getPackageJsonPath(),
         message: MSG_NO_SCRIPTS_BLOCK,
         fixer: () => {
-          mutateJson<PackageJson>(context.getPackageJsonPath(), context.host, (input) => {
-            input.scripts = {};
-            return input;
-          });
+          mutateJson<PackageJson>(
+            context.getPackageJsonPath(),
+            context.host,
+            (input) => {
+              input.scripts = {};
+              return input;
+            },
+          );
         },
       });
       return;
@@ -59,26 +63,36 @@ export const packageScript = createRuleFactory<Options>({
           }
           allowedValues.add(q);
         }
-        fixToEmpty = Object.prototype.hasOwnProperty.call(value, "fixValue") && value.fixValue === undefined;
+        fixToEmpty = Object.prototype.hasOwnProperty.call(value, "fixValue")
+          && value.fixValue === undefined;
         fixValue = value.fixValue;
       }
 
       const actualValue = packageJson.scripts[name];
 
-      if (!allowedValues.has(actualValue) && !(allowEmpty === true && actualValue === undefined)) {
+      if (
+        !allowedValues.has(actualValue)
+        && !(allowEmpty === true && actualValue === undefined)
+      ) {
         let fixer;
 
-        if (fixValue !== false && (fixValue !== undefined || fixToEmpty === true)) {
+        if (
+          fixValue !== false && (fixValue !== undefined || fixToEmpty === true)
+        ) {
           const q = fixValue;
           fixer = () => {
-            mutateJson<PackageJson>(context.getPackageJsonPath(), context.host, (input) => {
-              if (fixToEmpty && q === undefined) {
-                delete input.scripts![name];
-              } else {
-                input.scripts![name] = q!;
-              }
-              return input;
-            });
+            mutateJson<PackageJson>(
+              context.getPackageJsonPath(),
+              context.host,
+              (input) => {
+                if (fixToEmpty && q === undefined) {
+                  delete input.scripts![name];
+                } else {
+                  input.scripts![name] = q!;
+                }
+                return input;
+              },
+            );
           };
         }
 
@@ -88,8 +102,12 @@ export const packageScript = createRuleFactory<Options>({
 
         context.addError({
           file: context.getPackageJsonPath(),
-          message: `Expected standardized script entry for '${name}'. Valid options: ${validOptionsString}`,
-          longMessage: diff(validOptionsString + "\n", (packageJson.scripts[name] || "") + "\n"),
+          message:
+            `Expected standardized script entry for '${name}'. Valid options: ${validOptionsString}`,
+          longMessage: diff(
+            validOptionsString + "\n",
+            (packageJson.scripts[name] || "") + "\n",
+          ),
           fixer,
         });
       }

package/src/requireDependency.ts

@@ -12,10 +12,10 @@ import * as r from "runtypes";
 import { createRuleFactory } from "./util/createRuleFactory.js";
 
 const Options = r.Partial({
-  dependencies: r.Dictionary(r.String),
-  devDependencies: r.Dictionary(r.String),
-  peerDependencies: r.Dictionary(r.String),
-  optionalDependencies: r.Dictionary(r.String),
+  dependencies: r.Dictionary(r.String.optional()),
+  devDependencies: r.Dictionary(r.String.optional()),
+  peerDependencies: r.Dictionary(r.String.optional()),
+  optionalDependencies: r.Dictionary(r.String.optional()),
 });
 
 type Options = r.Static<typeof Options>;
@@ -32,7 +32,8 @@ export const requireDependency = createRuleFactory({
       "peerDependencies" as const,
       "optionalDependencies" as const,
     ].forEach((type) => {
-      if (!options[type]) {
+      const expectedEntries = options[type];
+      if (!expectedEntries) {
         return;
       }
 
@@ -42,7 +43,11 @@ export const requireDependency = createRuleFactory({
           message: `No ${type} block, cannot add required ${type}.`,
           fixer: () => {
             mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
-              input[type] = options[type];
+              input[type] = Object.fromEntries(
+                Object.entries(expectedEntries).filter(([, v]) =>
+                  v !== undefined
+                ),
+              ) as Record<string, string>;
               return input;
             });
           },
@@ -55,12 +60,24 @@ export const requireDependency = createRuleFactory({
           context.addError({
             file: packageJsonPath,
             message: `Expected dependency ${dep}@${version}`,
-            longMessage: diff(`${dep}@${version}\n`, `${dep}@${packageJson[type]![dep] || "missing"}\n`)!,
+            longMessage: diff(
+              `${dep}@${version}\n`,
+              `${dep}@${packageJson[type]![dep] || "missing"}\n`,
+            )!,
             fixer: () => {
-              mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
-                input[type] = { ...input[type], [dep]: version };
-                return input;
-              });
+              mutateJson<PackageJson>(
+                packageJsonPath,
+                context.host,
+                (input) => {
+                  if (version === undefined) {
+                    input[type] = { ...input[type] };
+                    delete input[type][dep];
+                  } else {
+                    input[type] = { ...input[type], [dep]: version };
+                  }
+                  return input;
+                },
+              );
             },
           });
         }

package/src/standardTsconfig.ts

@@ -84,11 +84,23 @@ function getGenerator(context: Context, opts: Options) {
   } else if (opts.templateFile) {
     const { packageDir: workspacePackageDir } = context.getWorkspaceContext();
     const fullPath = path.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 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");
   }
@@ -99,7 +111,7 @@ function makeGenerator(
   template: any,
   excludedReferences: ReadonlyArray<string> | undefined,
   additionalReferences: ReadonlyArray<string> | undefined,
-  tsconfigReferenceFile?: string
+  tsconfigReferenceFile?: string,
 ) {
   return async function generator(context: Context) {
     template = {
@@ -107,15 +119,24 @@ function makeGenerator(
       references: [],
     }; // make a copy and ensure we have a references array
 
-    const nameToDirectory = await context.getWorkspaceContext().getPackageNameToDir();
+    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 !== undefined && (excludedReferences === undefined || !matchesAnyGlob(dep, excludedReferences))) {
-        const absoluteReferencePath =
-          tsconfigReferenceFile !== undefined ? path.join(packageDir, tsconfigReferenceFile) : packageDir;
+      if (
+        packageDir !== undefined
+        && (excludedReferences === undefined
+          || !matchesAnyGlob(dep, excludedReferences))
+      ) {
+        const absoluteReferencePath = tsconfigReferenceFile !== undefined
+          ? path.join(packageDir, tsconfigReferenceFile)
+          : packageDir;
         template.references.push({
           path: path.relative(context.packageDir, absoluteReferencePath),
         });

package/src/util/checkAlpha.ts

@@ -10,7 +10,7 @@ import { diff } from "jest-diff";
 
 export function checkAlpha(
   context: Context,
-  block: "dependencies" | "devDependencies" | "peerDependencies" | "scripts"
+  block: "dependencies" | "devDependencies" | "peerDependencies" | "scripts",
 ) {
   const packageJson = context.getPackageJson();
   const packagePath = context.getPackageJsonPath();
@@ -54,6 +54,9 @@ function arrayOrderCompare(a: ReadonlyArray<string>, b: ReadonlyArray<string>) {
   return true;
 }
 
-export function createIncorrectOrderErrorMessage(block: string, packageName: string) {
+export function createIncorrectOrderErrorMessage(
+  block: string,
+  packageName: string,
+) {
   return `Incorrect order of ${block} in ${packageName}'s package.json`;
 }

package/src/util/createRuleFactory.ts

@@ -2,7 +2,11 @@ import { Context, RuleEntry, RuleModule } from "@monorepolint/config";
 
 export type ValidateOptionsFn<X> = (options: unknown) => asserts options is X;
 export type RuleFactoryFn<T> = (ruleEntry: RuleEntry<T>) => RuleModule<T>;
-export type RuleCheckFn<O> = (context: Context, options: O, extra: { id: string }) => Promise<unknown> | unknown;
+export type RuleCheckFn<O> = (
+  context: Context,
+  options: O,
+  extra: { id: string },
+) => Promise<unknown> | unknown;
 
 export interface RuleFactoryOptions<X> {
   name: string;
@@ -18,7 +22,7 @@ export function createRuleFactory<X>({
   validateOptions,
   printStats,
 }: RuleFactoryOptions<X>): RuleFactoryFn<X> {
-  return function (ruleEntry) {
+  return function(ruleEntry) {
     const id = ruleEntry.id ?? `${name} :: ${globalId++}`;
     return {
       id,

package/src/util/packageDependencyGraphService.ts

@@ -19,7 +19,11 @@ export interface IPackageDependencyGraphNode {
 /** Service abstraction for constructing and traversing package dependency graphs. */
 export interface IPackageDependencyGraphService {
   /** Construct a graph of package dependencies. */
-  buildDependencyGraph(packageJsonPath: string, host: Host, maxDepth?: number): IPackageDependencyGraphNode;
+  buildDependencyGraph(
+    packageJsonPath: string,
+    host: Host,
+    maxDepth?: number,
+  ): IPackageDependencyGraphNode;
 
   /** Traverse a package dependency graph. */
   traverse(
@@ -27,20 +31,27 @@ export interface IPackageDependencyGraphService {
     opts?: {
       /** Traverse each unique path to a given package (potentially slow). */
       traverseAllPaths?: boolean;
-    }
-  ): IterableIterator<IPackageDependencyGraphNode & { importPath: IPackageDependencyGraphNode[] }>;
+    },
+  ): IterableIterator<
+    IPackageDependencyGraphNode & { importPath: IPackageDependencyGraphNode[] }
+  >;
 }
 
 /** Default implementation of the package dependency graph service. */
-export class PackageDependencyGraphService implements IPackageDependencyGraphService {
+export class PackageDependencyGraphService
+  implements IPackageDependencyGraphService
+{
   /** Construct a graph of package dependencies and return the root node. */
   public buildDependencyGraph(
     startPackageJsonPath: string,
     host: Host,
-    maxDepth?: number
+    maxDepth?: number,
   ): IPackageDependencyGraphNode {
     const nodes = new Map<string, IPackageDependencyGraphNode>();
-    const visit = (packageJsonPath: string, currentDepth: number): IPackageDependencyGraphNode => {
+    const visit = (
+      packageJsonPath: string,
+      currentDepth: number,
+    ): IPackageDependencyGraphNode => {
       if (nodes.has(packageJsonPath)) {
         return nodes.get(packageJsonPath)!;
       }
@@ -60,14 +71,24 @@ export class PackageDependencyGraphService implements IPackageDependencyGraphSer
 
       const nextDepth = currentDepth + 1;
       if (maxDepth == null || nextDepth <= maxDepth) {
-        const dependencies = packageJson.dependencies != null ? Object.keys(packageJson.dependencies) : [];
+        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),
+          );
         }
       }
 
@@ -80,14 +101,20 @@ export class PackageDependencyGraphService implements IPackageDependencyGraphSer
   /** Traverse a package dependency graph with an iterator. */
   public *traverse(
     root: IPackageDependencyGraphNode,
-    opts = { traverseAllPaths: false }
-  ): IterableIterator<IPackageDependencyGraphNode & { importPath: IPackageDependencyGraphNode[] }> {
+    opts = { traverseAllPaths: false },
+  ): IterableIterator<
+    IPackageDependencyGraphNode & { importPath: IPackageDependencyGraphNode[] }
+  > {
     const visited = new Set<IPackageDependencyGraphNode>();
 
     function* visit(
       node: IPackageDependencyGraphNode,
-      importPath: IPackageDependencyGraphNode[] = []
-    ): IterableIterator<IPackageDependencyGraphNode & { importPath: IPackageDependencyGraphNode[] }> {
+      importPath: IPackageDependencyGraphNode[] = [],
+    ): IterableIterator<
+      IPackageDependencyGraphNode & {
+        importPath: IPackageDependencyGraphNode[];
+      }
+    > {
       // Don't visit a package more than once unless explicitly asked to traverse all paths
       if (!opts.traverseAllPaths && visited.has(node)) {
         return;

package/vitest.config.mjs

@@ -1,14 +1,17 @@
-
-import { coverageConfigDefaults, defineProject, defaultExclude } from 'vitest/config'
+import {
+  coverageConfigDefaults,
+  defaultExclude,
+  defineProject,
+} from "vitest/config";
 
 export default defineProject({
   test: {
-   exclude: [...defaultExclude, "**/build/**"],
+    exclude: [...defaultExclude, "**/build/**"],
     coverage: {
       provider: "v8",
       enabled: true,
-      exclude: [...coverageConfigDefaults.exclude, "vitest.config.*"]
-    }
+      pool: "forks",
+      exclude: [...coverageConfigDefaults.exclude, "vitest.config.*"],
+    },
   },
-})
-          
+});