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

package/src/consistentDependencies.ts

@@ -28,7 +28,11 @@ export const consistentDependencies = createRuleFactory<Options>({
   validateOptions: Options.check,
 });
 
-function checkDeps(context: Context, args: Options, block: "dependencies" | "devDependencies" | "peerDependencies") {
+function checkDeps(
+  context: Context,
+  args: Options,
+  block: "dependencies" | "devDependencies" | "peerDependencies",
+) {
   const packageJson = context.getPackageJson();
   const packagePath = context.getPackageJsonPath();
   const dependencies = packageJson[block];
@@ -37,10 +41,9 @@ function checkDeps(context: Context, args: Options, block: "dependencies" | "dev
   const workspaceDependencies = workspacePackageJson[block];
 
   const ignoredDeps = args?.ignoredDependencies ?? [];
-  const depsToCheck =
-    workspaceDependencies == null || ignoredDeps.length === 0
-      ? workspaceDependencies
-      : omit(workspaceDependencies, ignoredDeps);
+  const depsToCheck = workspaceDependencies == null || ignoredDeps.length === 0
+    ? workspaceDependencies
+    : omit(workspaceDependencies, ignoredDeps);
 
   if (dependencies === undefined || depsToCheck === undefined) {
     return;
@@ -65,12 +68,17 @@ function checkDeps(context: Context, args: Options, block: "dependencies" | "dev
   }
 }
 
-function filterKeys(ob: Record<string, string>, filterOb: Record<string, string>) {
+function filterKeys(
+  ob: Record<string, string>,
+  filterOb: Record<string, string>,
+) {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const newOb: Record<string, any> = {};
 
   for (const key of Object.keys(filterOb)) {
-    if (ob[key] !== undefined && skippedVersions.indexOf(filterOb[key]) === -1) {
+    if (
+      ob[key] !== undefined && skippedVersions.indexOf(filterOb[key]) === -1
+    ) {
       newOb[key] = ob[key];
     }
   }
@@ -78,10 +86,15 @@ function filterKeys(ob: Record<string, string>, filterOb: Record<string, string>
   return newOb;
 }
 
-function omit<T>(obj: Record<string, T>, keysToOmit: readonly string[]): Record<string, T> {
+function omit<T>(
+  obj: Record<string, T>,
+  keysToOmit: readonly string[],
+): Record<string, T> {
   const newObj: Record<string, T> = {};
 
-  const filtered = Object.entries(obj).filter(([key]) => !keysToOmit.includes(key));
+  const filtered = Object.entries(obj).filter(([key]) =>
+    !keysToOmit.includes(key)
+  );
   for (const [key, value] of filtered) {
     newObj[key] = value;
   }

package/src/consistentVersions.ts

@@ -23,13 +23,24 @@ export const consistentVersions = createRuleFactory({
 });
 
 function checkConsistentVersions(context: Context, options: Options) {
-  for (const [dependencyPackageName, expectedPackageDependencyValue] of Object.entries(
-    options.matchDependencyVersions
-  )) {
+  for (
+    const [dependencyPackageName, expectedPackageDependencyValue] of Object
+      .entries(
+        options.matchDependencyVersions,
+      )
+  ) {
     if (Array.isArray(expectedPackageDependencyValue)) {
-      ensurePackageMatchesSomeVersion(context, dependencyPackageName, expectedPackageDependencyValue);
+      ensurePackageMatchesSomeVersion(
+        context,
+        dependencyPackageName,
+        expectedPackageDependencyValue,
+      );
     } else {
-      ensurePackageIsCorrectVersion(context, dependencyPackageName, expectedPackageDependencyValue);
+      ensurePackageIsCorrectVersion(
+        context,
+        dependencyPackageName,
+        expectedPackageDependencyValue,
+      );
     }
   }
 }
@@ -37,48 +48,59 @@ function checkConsistentVersions(context: Context, options: Options) {
 const ensurePackageIsCorrectVersion = (
   context: Context,
   dependencyPackageName: string,
-  expectedPackageDependencyValue: string
+  expectedPackageDependencyValue: string,
 ) => {
   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}'`
+      `Malformed expected package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${expectedPackageDependencyValue}'`,
     );
   }
 
-  const actualPackageDependencyValue = packageJson.dependencies && packageJson.dependencies[dependencyPackageName];
+  const actualPackageDependencyValue = packageJson.dependencies
+    && packageJson.dependencies[dependencyPackageName];
   const actualPackageDependencyVersion = coerce(actualPackageDependencyValue);
   if (
-    actualPackageDependencyVersion != null &&
-    actualPackageDependencyVersion.raw !== expectedPackageDependencyVersion.raw
+    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.`,
+      message:
+        `Expected dependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDependencyValue}' instead.`,
       fixer: () =>
         mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
-          input.dependencies![dependencyPackageName] = expectedPackageDependencyValue;
+          input.dependencies![dependencyPackageName] =
+            expectedPackageDependencyValue;
           return input;
         }),
     });
   }
 
-  const actualPackageDevDependencyValue =
-    packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
-  const actualPackageDevDependencyVersion = coerce(actualPackageDevDependencyValue);
+  const actualPackageDevDependencyValue = packageJson.devDependencies
+    && packageJson.devDependencies[dependencyPackageName];
+  const actualPackageDevDependencyVersion = coerce(
+    actualPackageDevDependencyValue,
+  );
   if (
-    actualPackageDevDependencyVersion != null &&
-    actualPackageDevDependencyVersion.raw !== expectedPackageDependencyVersion.raw
+    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`,
+      message:
+        `Expected devDependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDevDependencyValue}' instead`,
       fixer: () =>
         mutateJson<PackageJson>(packageJsonPath, context.host, (input) => {
-          input.devDependencies![dependencyPackageName] = expectedPackageDependencyValue;
+          input.devDependencies![dependencyPackageName] =
+            expectedPackageDependencyValue;
           return input;
         }),
     });
@@ -88,54 +110,69 @@ const ensurePackageIsCorrectVersion = (
 const ensurePackageMatchesSomeVersion = (
   context: Context,
   dependencyPackageName: string,
-  acceptedPackageDependencyValues: string[]
+  acceptedPackageDependencyValues: string[],
 ) => {
   const packageJson = context.getPackageJson();
   const packageJsonPath = context.getPackageJsonPath();
 
-  const acceptedPackageDependencyVersions: SemVer[] = acceptedPackageDependencyValues.map(
-    (acceptedPackageDependencyValue) => {
-      const acceptedPackageDependencyVersion = coerce(acceptedPackageDependencyValue);
-      if (acceptedPackageDependencyVersion == null) {
-        throw new Error(
-          `Malformed accepted package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${acceptedPackageDependencyValue}'`
+  const acceptedPackageDependencyVersions: SemVer[] =
+    acceptedPackageDependencyValues.map(
+      (acceptedPackageDependencyValue) => {
+        const acceptedPackageDependencyVersion = coerce(
+          acceptedPackageDependencyValue,
         );
-      }
-      return acceptedPackageDependencyVersion;
-    }
-  );
+        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 actualPackageDependencyValue = packageJson.dependencies
+    && packageJson.dependencies[dependencyPackageName];
   const actualPackageDependencyVersion = coerce(actualPackageDependencyValue);
   if (
-    actualPackageDependencyVersion != null &&
-    acceptedPackageDependencyVersions.every(
-      (acceptedPackageDependencyVersion) => actualPackageDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
+    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.`,
+      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);
+  const actualPackageDevDependencyValue = packageJson.devDependencies
+    && packageJson.devDependencies[dependencyPackageName];
+  const actualPackageDevDependencyVersion = coerce(
+    actualPackageDevDependencyValue,
+  );
   if (
-    actualPackageDevDependencyVersion != null &&
-    acceptedPackageDependencyVersions.every(
+    actualPackageDevDependencyVersion != null
+    && acceptedPackageDependencyVersions.every(
       (acceptedPackageDependencyVersion) =>
-        actualPackageDevDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
+        actualPackageDevDependencyVersion.raw
+          !== acceptedPackageDependencyVersion.raw,
     )
   ) {
     context.addError({
       file: packageJsonPath,
-      message: `Expected devDependency on ${dependencyPackageName} to match one of '${JSON.stringify(
-        acceptedPackageDependencyValues
-      )}', got '${actualPackageDevDependencyValue}' instead.`,
+      message:
+        `Expected devDependency on ${dependencyPackageName} to match one of '${
+          JSON.stringify(
+            acceptedPackageDependencyValues,
+          )
+        }', got '${actualPackageDevDependencyValue}' instead.`,
     });
   }
 };

package/src/fileContents.ts

@@ -13,24 +13,24 @@ import { createRuleFactory } from "./util/createRuleFactory.js";
 const Options = r.Union(
   r.Record({
     file: r.String,
-    generator: r.Function.withGuard((x): x is (context: Context) => string | Promise<string> => x != undefined),
+    generator: r.Function.withGuard((
+      x,
+    ): x is (context: Context) => string | Promise<string> => x != undefined),
     template: r.Undefined.optional(),
     templateFile: r.Undefined.optional(),
   }),
-
   r.Record({
     file: r.String,
     generator: r.Undefined.optional(),
     template: r.String.Or(r.Undefined),
     templateFile: r.Undefined.optional(),
   }),
-
   r.Record({
     file: r.String,
     generator: r.Undefined.optional(),
     template: r.Undefined.optional(),
     templateFile: r.String,
-  })
+  }),
 );
 
 type Options = r.Static<typeof Options>;
@@ -42,13 +42,17 @@ export const fileContents = createRuleFactory<Options>({
     const expectedContent = await getExpectedContents(context, opts);
 
     const pathExists = context.host.exists(fullPath);
-    const actualContent = pathExists ? context.host.readFile(fullPath, { encoding: "utf-8" }) : undefined;
+    const actualContent = pathExists
+      ? context.host.readFile(fullPath, { encoding: "utf-8" })
+      : undefined;
     if (actualContent !== expectedContent) {
-      const longMessage =
-        pathExists && expectedContent == undefined ? undefined : diff(expectedContent, actualContent, { expand: true });
+      const longMessage = pathExists && expectedContent == undefined
+        ? undefined
+        : diff(expectedContent, actualContent, { expand: true });
 
-      const message =
-        pathExists && expectedContent == undefined ? "File should not exist" : "Expect file contents to match";
+      const message = pathExists && expectedContent == undefined
+        ? "File should not exist"
+        : "Expect file contents to match";
 
       context.addError({
         file: fullPath,
@@ -59,7 +63,9 @@ export const fileContents = createRuleFactory<Options>({
             if (pathExists) context.host.deleteFile(fullPath);
           } else {
             context.host.mkdir(path.dirname(fullPath), { recursive: true });
-            context.host.writeFile(fullPath, expectedContent, { encoding: "utf-8" });
+            context.host.writeFile(fullPath, expectedContent, {
+              encoding: "utf-8",
+            });
           }
         },
       });
@@ -70,7 +76,9 @@ export const fileContents = createRuleFactory<Options>({
 
 const optionsCache = new Map<
   Options,
-  ((context: Context) => Promise<string> | string | undefined) | string | undefined
+  | ((context: Context) => Promise<string> | string | undefined)
+  | string
+  | undefined
 >();
 
 async function getExpectedContents(context: Context, opts: Options) {

package/src/index.ts

@@ -12,12 +12,12 @@ export { consistentDependencies } from "./consistentDependencies.js";
 export { consistentVersions } from "./consistentVersions.js";
 export { fileContents } from "./fileContents.js";
 export { mustSatisfyPeerDependencies } from "./mustSatisfyPeerDependencies.js";
-export { packageOrder } from "./packageOrder.js";
+export { nestedWorkspaces } from "./nestedWorkspaces.js";
 export { packageEntry } from "./packageEntry.js";
+export { packageOrder } from "./packageOrder.js";
 export { packageScript } from "./packageScript.js";
-export { standardTsconfig } from "./standardTsconfig.js";
-export { nestedWorkspaces } from "./nestedWorkspaces.js";
 export { requireDependency } from "./requireDependency.js";
+export { standardTsconfig } from "./standardTsconfig.js";
 
 export {
   createRuleFactory,