@cubing/dev-config 0.6.1 → 0.6.3

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;
   }
 }
 
@@ -485,7 +485,7 @@ function checkPath(
               break;
             }
             default:
-              throw new Error("Invalid command.") as never;
+              throw new Error("Invalid subcommand.") as never;
           }
         }
       }
@@ -520,13 +520,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") {
-      checkPath(["exports", [exportPath]], {
+      // TODO: error?
+      checkPath(["exports", [subpath]], {
         expectPrefix: ResolutionPrefix.Relative,
       });
     } else if (value === null) {
@@ -537,8 +539,102 @@ if (packageJSON.exports) {
         "❌ .exports — Must use an object (instead of an array).",
       );
     } else {
-      for (const secondaryKey of Object.keys(value as Record<string, string>)) {
-        checkPath(["exports", [exportPath], secondaryKey], {
+      const keys = Object.keys(value as Record<string, string>);
+
+      checks.push(
+        (async () => {
+          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") {
+              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") {
+              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)) {
+              orderingErrorLines.push(
+                `  ↪ Key must not be present: ${JSON.stringify(key)}`,
+              );
+            }
+          }
+          if (orderingErrorLines.length > 0) {
+            exitCode = 1;
+            return [
+              `❌ ${breadcrumbString} — Invalid keys:`,
+              ...orderingErrorLines,
+            ].join("\n");
+          } else {
+            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", [subpath], secondaryKey], {
           expectPrefix: ResolutionPrefix.Relative,
         });
       }

package/package.json

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