@sanity/pkg-utils 5.1.2 → 5.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/pkg-utils",
-  "version": "5.1.2",
+  "version": "5.1.3",
   "description": "Simple utilities for modern npm packages.",
   "keywords": [
     "sanity-io",
@@ -132,7 +132,7 @@
     "typescript": "5.4.2",
     "vitest": "^1.4.0",
     "vitest-github-actions-reporter": "^0.11.1",
-    "@sanity/pkg-utils": "5.1.2"
+    "@sanity/pkg-utils": "5.1.3"
   },
   "peerDependencies": {
     "typescript": "5.4.2"

package/src/node/build.ts

@@ -1,4 +1,4 @@
-import {getPkgExtMap, loadConfig, loadPkgWithReporting} from './core'
+import {loadConfig, loadPkgWithReporting} from './core'
 import {createLogger} from './logger'
 import {resolveBuildContext} from './resolveBuildContext'
 import {resolveBuildTasks} from './resolveBuildTasks'
@@ -36,14 +36,12 @@ export async function build(options: {
   const pkg = await loadPkgWithReporting({cwd, logger, strict})
 
   const config = await loadConfig({cwd})
-  const extMap = getPkgExtMap({legacyExports: config?.legacyExports ?? false})
   const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'
 
   const ctx = await resolveBuildContext({
     config,
     cwd,
     emitDeclarationOnly,
-    extMap,
     logger,
     pkg,
     strict,

package/src/node/check.ts

@@ -2,7 +2,7 @@ import esbuild, {type BuildFailure} from 'esbuild'
 import path from 'path'
 
 import {createConsoleSpy} from './consoleSpy'
-import {getPkgExtMap, loadConfig, loadPkgWithReporting} from './core'
+import {loadConfig, loadPkgWithReporting} from './core'
 import {fileExists} from './fileExists'
 import {createLogger, type Logger} from './logger'
 import {printPackageTree} from './printPackageTree'
@@ -19,9 +19,8 @@ export async function check(options: {
 
   const pkg = await loadPkgWithReporting({cwd, logger, strict})
   const config = await loadConfig({cwd})
-  const extMap = getPkgExtMap({legacyExports: config?.legacyExports ?? false})
   const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'
-  const ctx = await resolveBuildContext({config, cwd, extMap, logger, pkg, strict, tsconfig})
+  const ctx = await resolveBuildContext({config, cwd, logger, pkg, strict, tsconfig})
 
   printPackageTree(ctx)
 

package/src/node/core/contexts/buildContext.ts

@@ -1,8 +1,8 @@
-import ts from 'typescript'
+import type ts from 'typescript'
 
-import {Logger} from '../../logger'
-import {PkgConfigOptions, PkgExports, PkgRuntime} from '../config'
-import {PackageJSON, PkgExtMap} from '../pkg'
+import type {Logger} from '../../logger'
+import type {PkgConfigOptions, PkgExports, PkgRuntime} from '../config'
+import type {PackageJSON} from '../pkg'
 
 /** @internal */
 export interface BuildFile {
@@ -17,7 +17,6 @@ export interface BuildContext {
   distPath: string
   emitDeclarationOnly: boolean
   exports: PkgExports | undefined
-  extMap: PkgExtMap
   external: string[]
   files: BuildFile[]
   logger: Logger

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

@@ -1,16 +1,16 @@
+import {legacyEnding} from '../../tasks/dts/getTargetPaths'
 import type {PkgExport} from '../config'
 import {isRecord} from '../isRecord'
-import type {PkgExtMap} from './pkgExt'
 import type {PackageJSON} from './types'
 import {validateExports} from './validateExports'
 
 /** @internal */
 export function parseExports(options: {
-  extMap: PkgExtMap
   pkg: PackageJSON
   strict: boolean
+  legacyExports: boolean
 }): (PkgExport & {_path: string})[] {
-  const {extMap, pkg, strict} = options
+  const {pkg, strict, legacyExports} = options
 
   const rootExport: PkgExport & {_path: string} = {
     _exported: true,
@@ -30,17 +30,19 @@ export function parseExports(options: {
 
   const errors: string[] = []
 
-  if (strict && !pkg.types && pkg.source?.endsWith('.ts') && pkg.exports) {
-    errors.push(
-      'package.json: `types` must be declared for the npm listing to show as a TypeScript module.',
-    )
-  }
+  // @TODO validate typesVersions when legacyExports is true
 
   if (strict && 'typings' in pkg) {
     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.exports['./package.json']) {
       errors.push('package.json: `exports["./package.json"] must be declared.')
     }
@@ -66,10 +68,30 @@ export function parseExports(options: {
             )
           }
 
-          if (exportEntry.import && rootExport.import && exportEntry.import !== rootExport.import) {
-            errors.push(
-              'package.json: mismatch between "module" and "exports.import" These must be equal.',
-            )
+          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.',
+              )
+            }
           }
 
           if (exportEntry.source && rootExport.source && exportEntry.source !== rootExport.source) {
@@ -96,7 +118,7 @@ export function parseExports(options: {
 
   const _exports = [rootExport, ...extraExports]
 
-  errors.push(...validateExports(_exports, {extMap, pkg}))
+  errors.push(...validateExports(_exports, {pkg}))
 
   if (errors.length) {
     throw new Error('\n- ' + errors.join('\n- '))

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

@@ -1,11 +1,14 @@
+import {legacyEnding} from '../../tasks/dts/getTargetPaths'
+
 /** @internal */
 export interface PkgExtMap {
   commonjs: {commonjs: string; esm: string}
   module: {commonjs: string; esm: string}
+  legacy: string
 }
 
 /** @internal */
-export const DEFAULT_PKG_EXT_MAP: PkgExtMap = {
+export const pkgExtMap: PkgExtMap = {
   // pkg.type: "commonjs"
   commonjs: {
     commonjs: '.js',
@@ -17,22 +20,6 @@ export const DEFAULT_PKG_EXT_MAP: PkgExtMap = {
     commonjs: '.cjs',
     esm: '.js',
   },
-}
-
-/** @internal */
-export function getPkgExtMap(options: {legacyExports: boolean}): PkgExtMap {
-  const {legacyExports} = options
-
-  const ret = {...DEFAULT_PKG_EXT_MAP}
-
-  // Fall back to legacy file extensions for package.json with `"type": "commonjs"`
-  // NOTE: Not supported by Node 14+ and will be removed in a future version
-  if (legacyExports) {
-    ret['commonjs'] = {
-      commonjs: '.js',
-      esm: '.esm.js',
-    }
-  }
-
-  return ret
+  // package.config.legacyExports: true
+  legacy: legacyEnding,
 }

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

@@ -1,16 +1,17 @@
-import {PkgExport} from '../config'
-import {PkgExtMap} from './pkgExt'
-import {PackageJSON} from './types'
+import type {PkgExport} from '../config'
+import {pkgExtMap as extMap} from './pkgExt'
+import type {PackageJSON} from './types'
 
 export function validateExports(
   _exports: (PkgExport & {_path: string})[],
-  options: {extMap: PkgExtMap; pkg: PackageJSON},
+  options: {pkg: PackageJSON},
 ): string[] {
-  const {extMap, pkg} = options
+  const {pkg} = options
   const ext = extMap[pkg.type || 'commonjs']
 
   const errors: string[] = []
 
+  // @TODO validate that no exports declare the legacy exports
   for (const exp of _exports) {
     if (exp.require && !exp.require.endsWith(ext.commonjs)) {
       errors.push(

package/src/node/resolveBuildContext.ts

@@ -2,19 +2,18 @@ import browserslistToEsbuild from 'browserslist-to-esbuild'
 import path from 'path'
 
 import {
-  BuildContext,
+  type BuildContext,
   DEFAULT_BROWSERSLIST_QUERY,
   loadTSConfig,
-  PackageJSON,
+  type PackageJSON,
   parseExports,
-  PkgConfigOptions,
-  PkgExports,
-  PkgExtMap,
-  PkgRuntime,
+  type PkgConfigOptions,
+  type PkgExports,
+  type PkgRuntime,
   resolveConfigProperty,
 } from './core'
 import {findCommonDirPath, pathContains} from './core/findCommonPath'
-import {Logger} from './logger'
+import type {Logger} from './logger'
 import {resolveBrowserTarget} from './resolveBrowserTarget'
 import {resolveNodeTarget} from './resolveNodeTarget'
 
@@ -22,7 +21,6 @@ export async function resolveBuildContext(options: {
   config?: PkgConfigOptions
   cwd: string
   emitDeclarationOnly?: boolean
-  extMap: PkgExtMap
   logger: Logger
   pkg: PackageJSON
   strict: boolean
@@ -32,7 +30,6 @@ export async function resolveBuildContext(options: {
     config,
     cwd,
     emitDeclarationOnly = false,
-    extMap,
     logger,
     pkg,
     strict,
@@ -76,7 +73,11 @@ export async function resolveBuildContext(options: {
     'node': nodeTarget,
   }
 
-  const parsedExports = parseExports({extMap, pkg, strict}).reduce<PkgExports>((acc, x) => {
+  const parsedExports = parseExports({
+    pkg,
+    strict,
+    legacyExports: config?.legacyExports ?? false,
+  }).reduce<PkgExports>((acc, x) => {
     const {_path: exportPath, ...exportEntry} = x
 
     return {...acc, [exportPath]: exportEntry}
@@ -146,7 +147,6 @@ export async function resolveBuildContext(options: {
     emitDeclarationOnly,
     exports,
     external,
-    extMap,
     files: [],
     logger,
     pkg,

package/src/node/resolveBuildTasks.ts

@@ -2,8 +2,8 @@ import fs from 'fs'
 import path from 'path'
 
 import type {BuildContext, PkgExport, PkgFormat, PkgRuntime} from './core'
-import type {BuildTask, DtsTask, RollupTask, RollupTaskEntry} from './tasks'
-import {getTargetPaths} from './tasks/dts/getTargetPaths'
+import type {BuildTask, DtsTask, RollupLegacyTask, RollupTask, RollupTaskEntry} from './tasks'
+import {fileEnding, getTargetPaths, legacyEnding} from './tasks/dts/getTargetPaths'
 
 /** @internal */
 export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
@@ -23,6 +23,7 @@ export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
   }
 
   const rollupTasks: Record<string, RollupTask> = {}
+  const rollupLegacyTasks: Record<string, RollupLegacyTask> = {}
 
   function addRollupTaskEntry(format: PkgFormat, runtime: PkgRuntime, entry: RollupTaskEntry) {
     const buildId = `${format}:${runtime}`
@@ -41,6 +42,24 @@ export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
     }
   }
 
+  function addRollupLegacyTaskEntry(runtime: PkgRuntime, entry: RollupTaskEntry) {
+    const buildId = `esm:${runtime}`
+
+    if (rollupLegacyTasks[buildId]) {
+      rollupLegacyTasks[buildId].entries.push(entry)
+    } else {
+      rollupLegacyTasks[buildId] = {
+        type: 'build:legacy',
+        buildId,
+        entries: [entry],
+        runtime,
+        format: 'esm',
+        // @TODO set a different target here that is compatible with legacy bundlers and testing tools like brownfield jest
+        target: target[runtime],
+      }
+    }
+  }
+
   // Parse `dts` tasks
   for (const exp of exports) {
     const importId = path.join(pkg.name, exp._path)
@@ -149,6 +168,25 @@ export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
       })
     }
 
+    // Create rollup bundles that legacy export files will re-export
+    if (config?.legacyExports) {
+      for (const exp of exports) {
+        const runtime = exp.browser?.import || exp.browser?.require ? 'browser' : ctx.runtime
+        const output = exp.browser?.import || exp.import || exp.browser?.require || exp.require
+
+        if (!output) continue
+
+        // Change the suffix to what the legacy exports will use
+        const legacyOutput = output.replace(fileEnding, legacyEnding)
+
+        addRollupLegacyTaskEntry(runtime, {
+          path: exp._path,
+          source: exp.browser?.source || exp.source,
+          output: legacyOutput,
+        })
+      }
+    }
+
     for (const bundle of bundles) {
       const idx = bundles.indexOf(bundle)
 
@@ -169,16 +207,20 @@ export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
       }
     }
 
-    tasks.push(...Object.values(rollupTasks))
+    tasks.push(...Object.values(rollupTasks), ...Object.values(rollupLegacyTasks))
 
     // Write legacy exports files
     if (config?.legacyExports) {
       for (const exp of exports) {
         if (exp._exported && exp._path !== '.') {
-          const relativeTargetPath = (exp.browser?.import || exp.import || '').replace(
-            /\.[^/.]+$/,
-            '',
-          )
+          const output = (
+            exp.browser?.import ||
+            exp.import ||
+            exp.browser?.require ||
+            exp.require ||
+            ''
+          ).replace(fileEnding, legacyEnding)
+          const relativeTargetPath = output.replace(/\.[^/.]+$/, '')
 
           if (relativeTargetPath) {
             fs.writeFileSync(

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

@@ -40,7 +40,11 @@ export async function buildTypes(options: {
   const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics)
 
   for (const diagnostic of allDiagnostics) {
-    printDiagnostic({cwd, logger, diagnostic})
+    // @TODO match the import with known export paths
+    // Ignore TS2307 errors as they'll be captured elsewhere if they're actually a problem
+    if (diagnostic.code !== 2307) {
+      printDiagnostic({cwd, logger, diagnostic})
+    }
   }
 
   if (emitResult.emitSkipped) {

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

@@ -1,7 +1,11 @@
 import type {PackageJSON, PkgBundle, PkgExport} from '../../core'
 
-const fileEnding = /\.[mc]?js$/
-const dtsEnding = '.d.ts'
+/** @internal */
+export const fileEnding = /\.[mc]?js$/
+/** @internal */
+export const dtsEnding = '.d.ts'
+/** @internal */
+export const legacyEnding = '.esm.js'
 const mtsEnding = '.d.mts'
 const ctsEnding = '.d.cts'
 

package/src/node/tasks/index.ts

@@ -1,6 +1,6 @@
 import {dtsTask, dtsWatchTask} from './dts'
-import {rollupTask, rollupWatchTask} from './rollup'
-import {BuildTaskHandlers, WatchTaskHandlers} from './types'
+import {rollupLegacyTask, rollupTask, rollupWatchTask} from './rollup'
+import type {BuildTaskHandlers, WatchTaskHandlers} from './types'
 
 export * from './dts'
 export * from './rollup'
@@ -10,6 +10,7 @@ export * from './types'
 export const buildTaskHandlers: BuildTaskHandlers = {
   'build:dts': dtsTask,
   'build:js': rollupTask,
+  'build:legacy': rollupLegacyTask,
 }
 
 /** @internal */

package/src/node/tasks/rollup/index.ts

@@ -1,2 +1,3 @@
+export * from './rollupLegacyTask'
 export * from './rollupTask'
 export * from './rollupWatchTask'

package/src/node/tasks/rollup/resolveRollupConfig.ts

@@ -9,8 +9,9 @@ import path from 'path'
 import type {InputOptions, OutputOptions, Plugin} from 'rollup'
 import esbuild from 'rollup-plugin-esbuild'
 
+import {pkgExtMap as extMap} from '../../../node/core/pkg/pkgExt'
 import {type BuildContext, resolveConfigProperty} from '../../core'
-import type {RollupTask, RollupWatchTask} from '../types'
+import type {RollupLegacyTask, RollupTask, RollupWatchTask} from '../types'
 
 export interface RollupConfig {
   inputOptions: InputOptions
@@ -20,11 +21,12 @@ export interface RollupConfig {
 /** @internal */
 export function resolveRollupConfig(
   ctx: BuildContext,
-  buildTask: RollupTask | RollupWatchTask,
+  buildTask: RollupTask | RollupLegacyTask | RollupWatchTask,
 ): RollupConfig {
   const {format, runtime, target} = buildTask
-  const {config, cwd, exports: _exports, extMap, external, distPath, logger, pkg, ts} = ctx
-  const outputExt = extMap[pkg.type || 'commonjs'][format]
+  const {config, cwd, exports: _exports, external, distPath, logger, pkg, ts} = ctx
+  const isLegacyExports = buildTask.type === 'build:legacy'
+  const outputExt = isLegacyExports ? extMap.legacy : extMap[pkg.type || 'commonjs'][format]
   const minify = config?.minify ?? false
   const outDir = path.relative(cwd, distPath)
 
@@ -83,11 +85,9 @@ export function resolveRollupConfig(
       entries: {...pathAliases},
     }),
     nodeResolve({
-      // mainFields: ['module', 'jsnext', 'main'],
       browser: runtime === 'browser',
-      // exportConditions: [runtime === 'node' ? 'node' : 'browser'],
       extensions: ['.cjs', '.mjs', '.js', '.jsx', '.json', '.node'],
-      preferBuiltins: true, // runtime === 'node',
+      preferBuiltins: true,
     }),
     commonjs(),
     json(),
@@ -107,7 +107,7 @@ export function resolveRollupConfig(
     Array.isArray(config?.babel?.plugins) &&
       getBabelOutputPlugin({
         babelrc: false,
-        plugins: config?.babel?.plugins,
+        plugins: config.babel.plugins,
       }),
     minify &&
       terser({
@@ -115,10 +115,10 @@ export function resolveRollupConfig(
         output: {
           comments: (_node, comment) => {
             const text = comment.value
-            const type = comment.type
+            const cType = comment.type
 
             // Check if this is a multiline comment
-            if (type === 'comment2') {
+            if (cType === 'comment2') {
               // Keep licensing comments
               return /@preserve|@license|@cc_on/i.test(text)
             }
@@ -135,6 +135,15 @@ export function resolveRollupConfig(
     ? defaultPlugins.concat(userPlugins)
     : resolveConfigProperty(config?.rollup?.plugins, defaultPlugins)
 
+  const hashChunkFileNames = config?.rollup?.hashChunkFileNames ?? false
+  const chunksFolder = isLegacyExports
+    ? '_legacy'
+    : hashChunkFileNames
+      ? '_chunks'
+      : '_chunks-[format]'
+  const chunkFileNames = `${chunksFolder}/${hashChunkFileNames ? '[name]-[hash]' : '[name]'}${outputExt}`
+  const entryFileNames = isLegacyExports ? '[name].js' : `[name]${outputExt}`
+
   return {
     inputOptions: {
       context: cwd,
@@ -192,31 +201,13 @@ export function resolveRollupConfig(
       experimentalLogSideEffects: config?.rollup?.experimentalLogSideEffects,
     },
     outputOptions: {
-      chunkFileNames: () => {
-        const parts = outputExt.split('.')
-        const prefix = config?.rollup?.hashChunkFileNames ? '[name]-[hash]' : '[name]'
-        const folder = config?.rollup?.hashChunkFileNames ? '_chunks' : '_chunks-[format]'
-
-        if (parts.length === 3) {
-          return `${folder}/${prefix}.${parts[2]}`
-        }
-
-        return `${folder}/${prefix}${outputExt}`
-      },
+      chunkFileNames,
       compact: minify,
       dir: outDir,
-      entryFileNames: () => {
-        const parts = outputExt.split('.')
-
-        if (parts.length === 3) {
-          return `[name].${parts[2]}`
-        }
-
-        return `[name]${outputExt}`
-      },
+      entryFileNames,
       esModule: true,
       format,
-      interop: 'compat',
+      interop: 'auto',
       sourcemap: config?.sourcemap ?? true,
       hoistTransitiveImports: false,
       ...config?.rollup?.output,