@cubing/dev-config 0.6.2 → 0.6.4

package/bin/package.json.ts

@@ -155,7 +155,7 @@ try {
       break;
     }
     default:
-      throw new Error("Invalid command.") as never;
+      throw new Error("Invalid subcommand.") as never;
   }
 }
 
@@ -260,8 +260,11 @@ function field<T>(
     optional?: boolean;
     additionalChecks?: { [requirementMessage: string]: (t: T) => boolean };
     skipPrintingSuccess?: boolean;
+    mustBePopulatedMessage?: string;
   },
 ) {
+  const mustBePopulatedMessage = () =>
+    options?.mustBePopulatedMessage ?? "Field must be populated.";
   const { breadcrumbString, maybeValue } = traverse(breadcrumbs);
   if (!maybeValue) {
     if (options?.optional) {
@@ -270,7 +273,7 @@ function field<T>(
       }
       return;
     } else {
-      console.log(`❌ ${breadcrumbString} — Must be present.`);
+      console.log(`❌ ${breadcrumbString} — ${mustBePopulatedMessage()}`);
       exitCode = 1;
       return;
     }
@@ -294,9 +297,11 @@ function field<T>(
     }
   } else {
     if (category === "undefined") {
-      console.log(`❌ ${breadcrumbString} — Must be present.`);
+      console.log(`❌ ${breadcrumbString} — ${mustBePopulatedMessage()}.`);
     } else if (type === "undefined") {
-      console.log(`❌ ${breadcrumbString} — Present (but must not be).`);
+      console.log(
+        `❌ ${breadcrumbString} — Field is populated (but must not be).`,
+      );
     } else {
       if (Array.isArray(type)) {
         console.log(
@@ -313,7 +318,7 @@ function field<T>(
   }
 }
 
-function mustNotBePresent(breadcrumbs: Breadcrumbs) {
+function mustNotBePopulated(breadcrumbs: Breadcrumbs) {
   const { breadcrumbString, maybeValue } = traverse(breadcrumbs);
   if (maybeValue) {
     console.log(`❌ ${breadcrumbString} — Must not be present.`);
@@ -393,6 +398,19 @@ field(["type"], "string", {
     'Type must be `"module"`.': (type: string) => type === "module",
   },
 });
+if ("main" in packageJSON || "types" in packageJSON) {
+  field(["main"], "string", {
+    mustBePopulatedMessage: 'Must be populated if "types" is populated.',
+  });
+  field(["types"], "string", {
+    mustBePopulatedMessage: 'Must be populated if "main" is populated.',
+  });
+} else {
+  console.log("☑️ .main");
+  console.log("☑️ .types");
+}
+mustNotBePopulated(["module"]);
+mustNotBePopulated(["browser"]);
 field(["exports"], "object");
 field(["bin"], "object", { optional: true });
 field(["dependencies"], "object", { optional: true });
@@ -407,15 +425,6 @@ field(["files"], "array");
 field(["scripts"], "object");
 // Set to `"# no-op"` if needed.
 field(["scripts", "prepublishOnly"], "string");
-if ("main" in packageJSON || "types" in packageJSON) {
-  field(["main"], "string");
-  field(["types"], "string");
-} else {
-  console.log("☑️ .main");
-  console.log("☑️ .types");
-}
-mustNotBePresent(["module"]);
-mustNotBePresent(["browser"]);
 
 console.log("Checking paths of binaries and exports:");
 
@@ -485,7 +494,7 @@ function checkPath(
               break;
             }
             default:
-              throw new Error("Invalid command.") as never;
+              throw new Error("Invalid subcommand.") as never;
           }
         }
       }
@@ -500,14 +509,14 @@ function checkPath(
       // TODO: allow folders (with a required trailing slash)?
       if (!(await resolvedPath.existsAsFile())) {
         exitCode = 1;
-        return `❌ ${breadcrumbString} — Missing — ${value}`;
+        return `❌ ${breadcrumbString} — Path is not present on disk. — ${value}`;
       }
       if (options.mustBeExecutable) {
         if (!((await resolvedPath.stat()).mode ^ constants.X_OK)) {
           // This is not considered fixable because the binary may be the output
           // of a build process. In that case, the build process is responsible
           // for marking it as executable.
-          return `❌ ${breadcrumbString} — Must be executable — ${value}`;
+          return `❌ ${breadcrumbString} — File at path must be executable — ${value}`;
         }
       }
       return `✅ ${breadcrumbString} — OK — ${value}`;
@@ -520,14 +529,15 @@ checkPath(["types"], { expectPrefix: ResolutionPrefix.Relative });
 checkPath(["module"], { expectPrefix: ResolutionPrefix.Relative });
 checkPath(["browser"], { expectPrefix: ResolutionPrefix.Relative });
 
-if (packageJSON.exports) {
-  for (const [exportPath, value] of Object.entries(packageJSON.exports)) {
+const { exports } = packageJSON;
+if (exports) {
+  for (const [subpath, value] of Object.entries(exports)) {
     if (!value) {
       // biome-ignore lint/complexity/noUselessContinue: Explicit control flow.
       continue;
     } else if (typeof value === "string") {
       // TODO: error?
-      checkPath(["exports", [exportPath]], {
+      checkPath(["exports", [subpath]], {
         expectPrefix: ResolutionPrefix.Relative,
       });
     } else if (value === null) {
@@ -542,25 +552,70 @@ if (packageJSON.exports) {
 
       checks.push(
         (async () => {
-          const { breadcrumbString } = traverse(["exports", [exportPath]]);
+          const { breadcrumbString } = traverse(["exports", [subpath]]);
+          const fixingLines = [];
           const orderingErrorLines = [];
           /**
            * https://nodejs.org/api/packages.html#conditional-exports
            */
+          let updateKeys = false;
           if (keys.includes("types")) {
             if (keys[0] !== "types") {
-              orderingErrorLines.push(
-                `  ↪ "types" must be the first export if present.`,
-              );
+              switch (subcommand) {
+                case "check": {
+                  orderingErrorLines.push(
+                    `  ↪ "types" must be the first export if present — 📝 fixable!`,
+                  );
+                  break;
+                }
+                case "format": {
+                  fixingLines.push(
+                    `  ↪ "types" must be the first export if present — 📝 fixing!`,
+                  );
+                  keys.splice(keys.indexOf("types"), 1);
+                  keys.splice(0, 0, "types");
+                  updateKeys = true;
+                  break;
+                }
+                default:
+                  throw new Error("Invalid subcommand.") as never;
+              }
             }
           }
           if (keys.includes("default")) {
             if (keys.at(-1) !== "default") {
-              orderingErrorLines.push(
-                `  ↪ "default" must be the last export if present.`,
-              );
+              switch (subcommand) {
+                case "check": {
+                  orderingErrorLines.push(
+                    `  ↪ "default" must be the last export if present — 📝 fixable!`,
+                  );
+                  break;
+                }
+                case "format": {
+                  fixingLines.push(
+                    `  ↪ "default" must be the last export if present — 📝 fixing!`,
+                  );
+                  keys.splice(keys.indexOf("default"), 1);
+                  keys.push("default");
+                  updateKeys = true;
+                  break;
+                }
+                default:
+                  throw new Error("Invalid subcommand.") as never;
+              }
             }
           }
+          if (updateKeys) {
+            // TODO: avoid type wrangling.
+            const newConditionalExports: Record<string, string> = {};
+            for (const key of keys) {
+              newConditionalExports[key] = (value as Record<string, string>)[
+                key
+              ];
+            }
+            (exports as Record<string, Record<string, string>>)[subpath] =
+              newConditionalExports;
+          }
           for (const key of keys) {
             // Note `"require"` is *emphatically not allowed*.
             if (!["types", "import", "default"].includes(key)) {
@@ -569,19 +624,26 @@ if (packageJSON.exports) {
               );
             }
           }
-          if (orderingErrorLines) {
-            exitCode = 0;
+          if (orderingErrorLines.length > 0) {
+            exitCode = 1;
             return [
               `❌ ${breadcrumbString} — Invalid keys:`,
               ...orderingErrorLines,
             ].join("\n");
           } else {
-            return `✅ ${breadcrumbString} — Key set and ordering is okay..`;
+            if (fixingLines.length > 0) {
+              return [
+                `✅ ${breadcrumbString} — Fixing key ordering:`,
+                ...fixingLines,
+              ].join("\n");
+            } else {
+              return `✅ ${breadcrumbString} — Key set and ordering is okay.`;
+            }
           }
         })(),
       );
       for (const secondaryKey of keys) {
-        checkPath(["exports", [exportPath], secondaryKey], {
+        checkPath(["exports", [subpath], secondaryKey], {
           expectPrefix: ResolutionPrefix.Relative,
         });
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubing/dev-config",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Common dev configs for projects.",
   "author": {
     "name": "Lucas Garron",