@sanity/pkg-utils 6.0.2 → 6.2.0

package/dist/index.js

@@ -132,10 +132,23 @@ const pkgSchema = z.object({
     )
   ),
   browserslist: z.optional(z.union([z.string(), z.array(z.string())])),
-  sideEffects: z.optional(z.union([z.boolean(), z.array(z.string())]))
-});
+  sideEffects: z.optional(z.union([z.boolean(), z.array(z.string())])),
+  // @TODO type this properly
+  typesVersions: z.optional(z.any())
+}), typoMap = /* @__PURE__ */ new Map();
+for (const key of pkgSchema.keyof()._def.values)
+  typoMap.set(key.toUpperCase(), key);
 function validatePkg(input) {
-  return pkgSchema.parse(input);
+  const pkg = pkgSchema.parse(input), invalidKey = Object.keys(input).find((key) => {
+    const needle = key.toUpperCase();
+    return typoMap.has(needle) ? typoMap.get(needle) !== key : !1;
+  });
+  if (invalidKey)
+    throw new TypeError(
+      `
+- package.json: "${invalidKey}" is not a valid key. Did you mean "${typoMap.get(invalidKey.toUpperCase())}"?`
+    );
+  return pkg;
 }
 async function loadPkg(options2) {
   const { cwd } = options2, pkgPath = await pkgUp({ cwd });
@@ -212,7 +225,7 @@ async function loadPkgWithReporting(options2) {
 function formatPath(segments) {
   return segments.map((s, idx) => idx === 0 ? s : typeof s == "number" ? `[${s}]` : s.startsWith(".") ? `["${s}"]` : `.${s}`).join("");
 }
-const fileEnding = /\.[mc]?js$/, dtsEnding = ".d.ts", legacyEnding = ".esm.js", mtsEnding = ".d.mts", ctsEnding = ".d.cts";
+const fileEnding = /\.[mc]?js$/, dtsEnding = ".d.ts", defaultEnding = ".js", legacyEnding = `.esm${defaultEnding}`, mjsEnding = ".mjs", cjsEnding = ".cjs", mtsEnding = ".d.mts", ctsEnding = ".d.cts";
 function getTargetPaths(_type, expOrBundle) {
   const type = _type === "module" ? "module" : "commonjs", set = /* @__PURE__ */ new Set();
   return expOrBundle?.import && set.add(expOrBundle.import.replace(fileEnding, type === "module" ? dtsEnding : mtsEnding)), expOrBundle?.require && set.add(expOrBundle.require.replace(fileEnding, type === "commonjs" ? dtsEnding : ctsEnding)), isPkgExport(expOrBundle) && (expOrBundle.browser?.source || (expOrBundle.browser?.import && set.add(
@@ -234,13 +247,13 @@ function isPkgExport(exp) {
 const pkgExtMap = {
   // pkg.type: "commonjs"
   commonjs: {
-    commonjs: ".js",
-    esm: ".mjs"
+    commonjs: defaultEnding,
+    esm: mjsEnding
   },
   // pkg.type: "module"
   module: {
-    commonjs: ".cjs",
-    esm: ".js"
+    commonjs: cjsEnding,
+    esm: defaultEnding
   },
   // package.config.legacyExports: true
   legacy: legacyEnding
@@ -256,55 +269,121 @@ function validateExports(_exports, options2) {
   return errors;
 }
 function parseExports(options2) {
-  const { pkg, strict, legacyExports } = options2, rootExport = {
-    _exported: !0,
-    _path: ".",
-    source: pkg.source || "",
-    browser: pkg.browser && {
-      source: pkg.source || "",
-      require: pkg.main && pkg.browser[pkg.main],
-      import: pkg.module && pkg.browser[pkg.module]
-    },
-    require: pkg.main,
-    import: pkg.module,
-    default: pkg.module || pkg.main || ""
-  }, extraExports = [], errors = [];
-  if (strict && "typings" in pkg && errors.push("package.json: `typings` should be `types`"), pkg.exports) {
-    strict && !pkg.types && pkg.source?.endsWith(".ts") && errors.push(
-      "package.json: `types` must be declared for the npm listing to show as a TypeScript module."
-    ), strict && !pkg.exports["./package.json"] && errors.push('package.json: `exports["./package.json"] must be declared.');
-    for (const [exportPath, exportEntry] of Object.entries(pkg.exports))
-      if (exportPath.endsWith(".json"))
-        exportPath === "./package.json" && exportEntry !== "./package.json" && errors.push('package.json: `exports["./package.json"] must be "./package.json".');
-      else if (!(isRecord(exportEntry) && "svelte" in exportEntry))
-        if (isRecord(exportEntry))
-          if (exportPath === ".") {
-            if (exportEntry.require && rootExport.require && exportEntry.require !== rootExport.require && errors.push(
-              'package.json: mismatch between "main" and "exports.require". These must be equal.'
-            ), legacyExports) {
-              const indexLegacyExport = (exportEntry.browser?.import || exportEntry.import || exportEntry.browser?.require || exportEntry.require || "").replace(/(\.esm)?\.[mc]?js$/, legacyEnding);
-              indexLegacyExport !== rootExport.import && errors.push(
-                `package.json: "module" should be "${indexLegacyExport}" when "legacyExports" is true`
-              );
-            } else
-              exportEntry.import && rootExport.import && exportEntry.import !== rootExport.import && errors.push(
-                'package.json: mismatch between "module" and "exports.import" These must be equal.'
-              );
-            exportEntry.source && rootExport.source && exportEntry.source !== rootExport.source && errors.push(
-              'package.json: mismatch between "source" and "exports.source". These must be equal.'
-            ), Object.assign(rootExport, exportEntry);
-          } else {
-            const extraExport = {
-              _exported: !0,
-              _path: exportPath,
-              ...exportEntry
-            };
-            extraExports.push(extraExport);
-          }
-        else
-          errors.push("package.json: exports must be an object");
+  const { pkg, strict, legacyExports } = options2, type = pkg.type || "commonjs", errors = [];
+  if (pkg.source) {
+    if (strict && pkg.exports?.["."] && typeof pkg.exports["."] == "object" && "source" in pkg.exports["."] && pkg.exports["."].source === pkg.source)
+      errors.push(
+        'package.json: the "source" property can be removed, as it is equal to exports["."].source.'
+      );
+    else if (!pkg.exports && pkg.main) {
+      const extMap = pkgExtMap[type], importExport = pkg.main.replace(fileEnding, extMap.esm), requireExport = pkg.main.replace(fileEnding, extMap.commonjs), defaultExport = pkg.main.replace(fileEnding, defaultEnding), maybeBrowserCondition = [];
+      if (pkg.browser) {
+        const browserConditions = [];
+        if (pkg.module && pkg.browser?.[pkg.module])
+          browserConditions.push(
+            `      "import": ${JSON.stringify(pkg.browser[pkg.module].replace(fileEnding, extMap.esm))}`
+          );
+        else if (pkg.browser?.[pkg.main])
+          browserConditions.push(
+            `      "import": ${JSON.stringify(pkg.browser?.[pkg.main].replace(fileEnding, extMap.esm))}`
+          );
+        else if (legacyExports) {
+          const browserImport = pkg.main.replace(fileEnding, `.browser${extMap.esm}`);
+          browserConditions.push(`      "import": ${JSON.stringify(browserImport)}`);
+        }
+        if (pkg.browser?.[pkg.main])
+          browserConditions.push(
+            `      "require": ${JSON.stringify(pkg.browser[pkg.main].replace(fileEnding, extMap.commonjs))}`
+          );
+        else if (legacyExports) {
+          const browserRequire = pkg.main.replace(fileEnding, `.browser${extMap.commonjs}`);
+          browserConditions.push(`      "require": ${JSON.stringify(browserRequire)}`);
+        }
+        browserConditions.length && maybeBrowserCondition.push(
+          '    "browser": {',
+          `      "source": ${JSON.stringify(pkg.browser?.[pkg.source] || pkg.source)},`,
+          ...browserConditions,
+          "    }"
+        );
+      }
+      errors.push(
+        ...[
+          "package.json: `exports` are missing, it should be:",
+          '"exports": {',
+          '  ".": {',
+          `    "source": ${JSON.stringify(pkg.source)},`,
+          // If browser conditions are detected then add them to the suggestion
+          ...maybeBrowserCondition.length > 0 ? maybeBrowserCondition : [],
+          // If legacy exports are enabled we suggest the full list of exports, if not we can use the terse version
+          (legacyExports || type === "commonjs") && `    "import": ${JSON.stringify(importExport)},`,
+          (legacyExports || type === "module") && `    "require": ${JSON.stringify(requireExport)},`,
+          `    "default": ${JSON.stringify(defaultExport)}`,
+          "  },",
+          '  "./package.json": "./package.json"',
+          "}"
+        ].filter(Boolean)
+      );
+    }
   }
-  const _exports = [rootExport, ...extraExports];
+  if (errors.length)
+    throw new Error(`
+- ` + errors.join(`
+- `));
+  if (!pkg.exports)
+    throw new Error(
+      `
+- ` + [
+        "package.json: `exports` are missing, please set a minimal configuration, for example:",
+        '"exports": {',
+        '  ".": {',
+        '    "source": "./src/index.js",',
+        '    "default": "./dist/index.js"',
+        "  },",
+        '  "./package.json": "./package.json"',
+        "}"
+      ].join(`
+- `)
+    );
+  const _exports = [];
+  strict && "typings" in pkg && errors.push("package.json: `typings` should be `types`"), strict && !pkg.types && pkg.source?.endsWith(".ts") && errors.push(
+    "package.json: `types` must be declared for the npm listing to show as a TypeScript module."
+  ), strict && !pkg.exports["./package.json"] && errors.push('package.json: `exports["./package.json"] must be declared.');
+  for (const [exportPath, exportEntry] of Object.entries(pkg.exports))
+    if (exportPath.endsWith(".json"))
+      exportPath === "./package.json" && exportEntry !== "./package.json" && errors.push('package.json: `exports["./package.json"] must be "./package.json".');
+    else if (!(isRecord(exportEntry) && "svelte" in exportEntry))
+      if (isRecord(exportEntry)) {
+        const exp = {
+          _exported: !0,
+          _path: exportPath,
+          ...exportEntry
+        };
+        if (!exp.default) {
+          const fallback = type === "module" ? exp.import : exp.require;
+          fallback && (exp.default = fallback), legacyExports && (fallback ? errors.push(
+            `package.json - \`exports["${exp._path}"].default\` should be set to "${fallback}" when "legacyExports" is true`
+          ) : errors.push(
+            `package.json - \`exports["${exp._path}"].default\` should be specified when "legacyExports" is true`
+          ));
+        }
+        if (!exp.require && type === "commonjs" && exp.default && (exp.require = exp.default), !exp.import && type === "module" && exp.default && (exp.import = exp.default), exportPath === ".")
+          if (exportEntry.require && pkg.main && exportEntry.require !== pkg.main && errors.push(
+            'package.json: mismatch between "main" and "exports.require". These must be equal.'
+          ), legacyExports) {
+            const indexLegacyExport = (exportEntry.import || exportEntry.require || "").replace(
+              /(\.esm)?\.[mc]?js$/,
+              legacyEnding
+            );
+            indexLegacyExport !== pkg.module && errors.push(
+              `package.json: "module" should be "${indexLegacyExport}" when "legacyExports" is true`
+            );
+          } else
+            exportEntry.import && pkg.module && exportEntry.import !== pkg.module && errors.push(
+              'package.json: mismatch between "module" and "exports.import" These must be equal.'
+            );
+        _exports.push(exp);
+      } else
+        errors.push("package.json: exports must be an object");
   if (errors.push(...validateExports(_exports, { pkg })), errors.length)
     throw new Error(`
 - ` + errors.join(`