@sanity/pkg-utils 6.0.2 → 6.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/pkg-utils",
-  "version": "6.0.2",
+  "version": "6.2.0",
   "description": "Simple utilities for modern npm packages.",
   "keywords": [
     "sanity-io",
@@ -34,7 +34,6 @@
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
-  "source": "./src/node/index.ts",
   "types": "./dist/index.d.ts",
   "bin": {
     "pkg": "./bin/pkg-utils.cjs",
@@ -44,7 +43,8 @@
     "bin",
     "dist",
     "!dist/stats.html",
-    "src"
+    "src",
+    "!src/**/*.test.ts"
   ],
   "commitlint": {
     "extends": [
@@ -132,10 +132,10 @@
     "rollup-plugin-visualizer": "^5.12.0",
     "semver": "^7.6.0",
     "ts-node": "^10.9.2",
-    "typescript": "5.4.2",
+    "typescript": "5.4.4",
     "vitest": "^1.4.0",
     "vitest-github-actions-reporter": "^0.11.1",
-    "@sanity/pkg-utils": "6.0.2"
+    "@sanity/pkg-utils": "6.2.0"
   },
   "peerDependencies": {
     "typescript": "5.4.x"
@@ -159,9 +159,9 @@
     "lint": "eslint . --ext .cjs,.js,.ts,.tsx",
     "playground:build": "pnpm --filter './playground/**' build",
     "playground:clean": "pnpm --filter './playground/**' --silent clean",
-    "test": "run-s playground:clean test:clean vitest:run",
-    "test:clean": "rimraf test/env/__tmp__",
-    "vitest:run": "vitest run",
+    "pretest": "run-s playground:clean",
+    "test": "vitest",
+    "test:update-snapshots": "pnpm test run -- --update",
     "watch": "node -r esbuild-register scripts/watch"
   }
 }

package/src/node/core/pkg/parseExports.ts

@@ -1,6 +1,7 @@
-import {legacyEnding} from '../../tasks/dts/getTargetPaths'
+import {defaultEnding, fileEnding, legacyEnding} from '../../tasks/dts/getTargetPaths'
 import type {PkgExport} from '../config'
 import {isRecord} from '../isRecord'
+import {pkgExtMap} from './pkgExt'
 import type {PackageJSON} from './types'
 import {validateExports} from './validateExports'
 
@@ -11,8 +12,109 @@ export function parseExports(options: {
   legacyExports: boolean
 }): (PkgExport & {_path: string})[] {
   const {pkg, strict, legacyExports} = options
+  const type = pkg.type || 'commonjs'
+  const errors: string[] = []
+
+  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]
+      const importExport = pkg.main.replace(fileEnding, extMap.esm)
+      const requireExport = pkg.main.replace(fileEnding, extMap.commonjs)
+      const defaultExport = pkg.main.replace(fileEnding, defaultEnding)
+
+      const 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)}`)
+        }
+
+        if (browserConditions.length) {
+          maybeBrowserCondition.push(
+            `    "browser": {`,
+            `      "source": ${JSON.stringify(pkg.browser?.[pkg.source] || pkg.source)},`,
+            ...browserConditions,
+            `    }`,
+          )
+        }
+      }
 
-  const rootExport: PkgExport & {_path: string} = {
+      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) as string[]),
+      )
+    }
+  }
+
+  if (errors.length) {
+    throw new Error('\n- ' + errors.join('\n- '))
+  }
+
+  if (!pkg.exports) {
+    throw new Error(
+      '\n- ' +
+        [
+          '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('\n- '),
+    )
+  }
+
+  /*
+  const rootExports: PkgExport & {_path: string} = {
     _exported: true,
     _path: '.',
     source: pkg.source || '',
@@ -21,14 +123,25 @@ export function parseExports(options: {
       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 || '',
+    require: legacyExports
+      ? pkg.main
+      : typeof pkg.exports?.['.'] === 'object' && 'require' in pkg.exports['.']
+        ? pkg.exports['.'].require
+        : '',
+    import: legacyExports
+      ? pkg.module
+      : typeof pkg.exports?.['.'] === 'object' && 'import' in pkg.exports['.']
+        ? pkg.exports['.'].import
+        : '',
+    default: legacyExports
+      ? pkg.module || pkg.main || ''
+      : typeof pkg.exports?.['.'] === 'object' && 'default' in pkg.exports['.']
+        ? pkg.exports['.'].default || ''
+        : pkg.module || pkg.main || '',
   }
+  // */
 
-  const extraExports: (PkgExport & {_path: string})[] = []
-
-  const errors: string[] = []
+  const _exports: (PkgExport & {_path: string})[] = []
 
   // @TODO validate typesVersions when legacyExports is true
 
@@ -36,88 +149,96 @@ export function parseExports(options: {
     errors.push('package.json: `typings` should be `types`')
   }
 
-  if (pkg.exports) {
-    if (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.',
-      )
-    }
+  if (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.',
+    )
+  }
 
-    if (strict && !pkg.exports['./package.json']) {
-      errors.push('package.json: `exports["./package.json"] must be declared.')
-    }
+  if (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')) {
-        if (exportPath === './package.json') {
-          if (exportEntry !== './package.json') {
-            errors.push('package.json: `exports["./package.json"] must be "./package.json".')
-          }
+  for (const [exportPath, exportEntry] of Object.entries(pkg.exports)) {
+    if (exportPath.endsWith('.json')) {
+      if (exportPath === './package.json') {
+        if (exportEntry !== './package.json') {
+          errors.push('package.json: `exports["./package.json"] must be "./package.json".')
         }
-      } else if (isRecord(exportEntry) && 'svelte' in exportEntry) {
-        // @TODO should we report a warning or a debug message here about a detected svelte export that is ignored?
-      } else if (isRecord(exportEntry)) {
-        if (exportPath === '.') {
-          if (
-            exportEntry.require &&
-            rootExport.require &&
-            exportEntry.require !== rootExport.require
-          ) {
+      }
+    } else if (isRecord(exportEntry) && 'svelte' in exportEntry) {
+      // @TODO should we report a warning or a debug message here about a detected svelte export that is ignored?
+    } else if (isRecord(exportEntry)) {
+      const exp = {
+        _exported: true,
+        _path: exportPath,
+        ...exportEntry,
+      } satisfies PkgExport & {_path: string}
+
+      // Infer the `default` condition based on the `type` and other conditions
+      if (!exp.default) {
+        const fallback = type === 'module' ? exp.import : exp.require
+
+        if (fallback) {
+          exp.default = fallback
+        }
+
+        if (legacyExports) {
+          if (fallback) {
             errors.push(
-              'package.json: mismatch between "main" and "exports.require". These must be equal.',
+              `package.json - \`exports["${exp._path}"].default\` should be set to "${fallback}" when "legacyExports" is true`,
             )
-          }
-
-          if (legacyExports) {
-            const indexLegacyExport = (
-              exportEntry.browser?.import ||
-              exportEntry.import ||
-              exportEntry.browser?.require ||
-              exportEntry.require ||
-              ''
-            ).replace(/(\.esm)?\.[mc]?js$/, legacyEnding)
-
-            if (indexLegacyExport !== rootExport.import) {
-              errors.push(
-                `package.json: "module" should be "${indexLegacyExport}" when "legacyExports" is true`,
-              )
-            }
           } else {
-            if (
-              exportEntry.import &&
-              rootExport.import &&
-              exportEntry.import !== rootExport.import
-            ) {
-              errors.push(
-                'package.json: mismatch between "module" and "exports.import" These must be equal.',
-              )
-            }
+            errors.push(
+              `package.json - \`exports["${exp._path}"].default\` should be specified when "legacyExports" is true`,
+            )
           }
+        }
+      }
 
-          if (exportEntry.source && rootExport.source && exportEntry.source !== rootExport.source) {
+      // Infer the `require` condition based on the `type` and other conditions
+      if (!exp.require && type === 'commonjs' && exp.default) {
+        exp.require = exp.default
+      }
+
+      // Infer the `import` condition based on the `type` and other conditions
+      if (!exp.import && type === 'module' && exp.default) {
+        exp.import = exp.default
+      }
+
+      if (exportPath === '.') {
+        if (exportEntry.require && pkg.main && exportEntry.require !== pkg.main) {
+          errors.push(
+            'package.json: mismatch between "main" and "exports.require". These must be equal.',
+          )
+        }
+
+        if (legacyExports) {
+          const indexLegacyExport = (exportEntry.import || exportEntry.require || '').replace(
+            /(\.esm)?\.[mc]?js$/,
+            legacyEnding,
+          )
+
+          if (indexLegacyExport !== pkg.module) {
             errors.push(
-              'package.json: mismatch between "source" and "exports.source". These must be equal.',
+              `package.json: "module" should be "${indexLegacyExport}" when "legacyExports" is true`,
             )
           }
-
-          Object.assign(rootExport, exportEntry)
         } else {
-          const extraExport: PkgExport & {_path: string} = {
-            _exported: true,
-            _path: exportPath,
-            ...exportEntry,
+          if (exportEntry.import && pkg.module && exportEntry.import !== pkg.module) {
+            errors.push(
+              'package.json: mismatch between "module" and "exports.import" These must be equal.',
+            )
           }
-
-          extraExports.push(extraExport)
         }
-      } else {
-        errors.push('package.json: exports must be an object')
       }
+
+      _exports.push(exp)
+    } else {
+      errors.push('package.json: exports must be an object')
     }
   }
 
-  const _exports = [rootExport, ...extraExports]
-
   errors.push(...validateExports(_exports, {pkg}))
 
   if (errors.length) {

package/src/node/core/pkg/pkgExt.ts

@@ -1,4 +1,4 @@
-import {legacyEnding} from '../../tasks/dts/getTargetPaths'
+import {cjsEnding, defaultEnding, legacyEnding, mjsEnding} from '../../tasks/dts/getTargetPaths'
 
 /** @internal */
 export interface PkgExtMap {
@@ -8,18 +8,18 @@ export interface PkgExtMap {
 }
 
 /** @internal */
-export const pkgExtMap: PkgExtMap = {
+export 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,
-}
+} satisfies PkgExtMap

package/src/node/core/pkg/validatePkg.ts

@@ -51,8 +51,31 @@ 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())])),
+  // @TODO type this properly
+  typesVersions: z.optional(z.any()),
 })
 
+// Create a map over known keys to catch casing mistakes
+const typoMap = new Map<string, string>()
+
+for (const key of pkgSchema.keyof()._def.values) {
+  typoMap.set(key.toUpperCase(), key)
+}
+
 export function validatePkg(input: unknown): PackageJSON {
-  return pkgSchema.parse(input)
+  const pkg = pkgSchema.parse(input)
+
+  const invalidKey = Object.keys(input as PackageJSON).find((key) => {
+    const needle = key.toUpperCase()
+    return typoMap.has(needle) ? typoMap.get(needle) !== key : false
+  })
+
+  if (invalidKey) {
+    throw new TypeError(
+      `
+- package.json: "${invalidKey}" is not a valid key. Did you mean "${typoMap.get(invalidKey.toUpperCase())}"?`,
+    )
+  }
+
+  return pkg
 }

package/src/node/tasks/dts/getTargetPaths.ts

@@ -3,11 +3,17 @@ import type {PackageJSON, PkgBundle, PkgExport} from '../../core'
 /** @internal */
 export const fileEnding = /\.[mc]?js$/
 /** @internal */
-export const dtsEnding = '.d.ts'
+export const dtsEnding = '.d.ts' as const
 /** @internal */
-export const legacyEnding = '.esm.js'
-const mtsEnding = '.d.mts'
-const ctsEnding = '.d.cts'
+export const defaultEnding = '.js' as const
+/** @internal */
+export const legacyEnding = `.esm${defaultEnding}` as const
+/** @internal */
+export const mjsEnding = '.mjs' as const
+/** @internal */
+export const cjsEnding = '.cjs' as const
+const mtsEnding = '.d.mts' as const
+const ctsEnding = '.d.cts' as const
 
 /** @internal */
 export function getTargetPaths(

package/src/node/core/findCommonPath.test.ts

@@ -1,10 +0,0 @@
-import {expect, test} from 'vitest'
-
-import {findCommonDirPath} from './findCommonPath'
-
-test('should find common parent directory of paths', () => {
-  expect(findCommonDirPath(['test/a', 'test/b/a'])).toBe('test')
-  expect(findCommonDirPath(['/test/a', '/test/b/a'])).toBe('/test')
-  expect(findCommonDirPath(['/test/a/b', '/test/a/b/c'])).toBe('/test/a')
-  expect(findCommonDirPath(['test/a/b', 'test/a/b', 'test/b/c', 'test/b/a'])).toBe('test')
-})