@sanity/pkg-utils 5.1.2 → 5.1.3-canary.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/pkg-utils",
-  "version": "5.1.2",
+  "version": "5.1.3-canary.0",
   "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-canary.0"
   },
   "peerDependencies": {
     "typescript": "5.4.2"

package/src/node/build.ts

@@ -36,7 +36,7 @@ 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 extMap = getPkgExtMap()
   const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'
 
   const ctx = await resolveBuildContext({

package/src/node/check.ts

@@ -19,7 +19,7 @@ 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 extMap = getPkgExtMap()
   const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'
   const ctx = await resolveBuildContext({config, cwd, extMap, logger, pkg, strict, tsconfig})
 

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

@@ -1,3 +1,4 @@
+import {fileEnding, legacyEnding} from '../../tasks/dts/getTargetPaths'
 import type {PkgExport} from '../config'
 import {isRecord} from '../isRecord'
 import type {PkgExtMap} from './pkgExt'
@@ -9,8 +10,9 @@ export function parseExports(options: {
   extMap: PkgExtMap
   pkg: PackageJSON
   strict: boolean
+  legacyExports: boolean
 }): (PkgExport & {_path: string})[] {
-  const {extMap, pkg, strict} = options
+  const {extMap, pkg, strict, legacyExports} = options
 
   const rootExport: PkgExport & {_path: string} = {
     _exported: true,
@@ -30,17 +32,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 +70,31 @@ 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.',
-            )
+          // @TODO do not run this check when legacyExports is true
+          if (legacyExports) {
+            const indexLegacyExport = (
+              exportEntry.browser?.import ||
+              exportEntry.import ||
+              exportEntry.browser?.require ||
+              exportEntry.require ||
+              ''
+            ).replace(fileEnding, 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) {

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,14 @@ export const DEFAULT_PKG_EXT_MAP: PkgExtMap = {
     commonjs: '.cjs',
     esm: '.js',
   },
+  // package.config.legacyExports: true
+  legacy: legacyEnding,
 }
 
-/** @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
+/**
+ * @deprecated use `pkgExtMap` instead
+ * @internal
+ */
+export function getPkgExtMap(): PkgExtMap {
+  return pkgExtMap
 }

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

@@ -1,6 +1,6 @@
-import {PkgExport} from '../config'
-import {PkgExtMap} from './pkgExt'
-import {PackageJSON} from './types'
+import type {PkgExport} from '../config'
+import type {PkgExtMap} from './pkgExt'
+import type {PackageJSON} from './types'
 
 export function validateExports(
   _exports: (PkgExport & {_path: string})[],
@@ -11,6 +11,7 @@ export function validateExports(
 
   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

@@ -76,7 +76,12 @@ export async function resolveBuildContext(options: {
     'node': nodeTarget,
   }
 
-  const parsedExports = parseExports({extMap, pkg, strict}).reduce<PkgExports>((acc, x) => {
+  const parsedExports = parseExports({
+    extMap,
+    pkg,
+    strict,
+    legacyExports: config?.legacyExports ?? false,
+  }).reduce<PkgExports>((acc, x) => {
     const {_path: exportPath, ...exportEntry} = x
 
     return {...acc, [exportPath]: exportEntry}

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)
 
@@ -115,10 +117,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 +137,22 @@ export function resolveRollupConfig(
     ? defaultPlugins.concat(userPlugins)
     : resolveConfigProperty(config?.rollup?.plugins, defaultPlugins)
 
+  // When using legacyExports then we need to hash the chunk file names to avoid chunks overwriting each other
+  if (config?.rollup?.hashChunkFileNames === false && config.legacyExports) {
+    throw new TypeError(
+      "when `legacyExports: true` you can't set `rollup.hashChunkFileNames: false` – this would cause chunks to overwrite each other. Please remove the `hashChunkFileNames` option or set it to `true",
+    )
+  }
+
+  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,28 +210,10 @@ 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',

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

@@ -0,0 +1,144 @@
+import chalk from 'chalk'
+import path from 'path'
+import {rollup} from 'rollup'
+import {Observable} from 'rxjs'
+
+import {createConsoleSpy} from '../../consoleSpy'
+import type {BuildContext} from '../../core'
+import type {RollupLegacyTask, TaskHandler} from '../types'
+import {resolveRollupConfig} from './resolveRollupConfig'
+
+/** @internal */
+export const rollupLegacyTask: TaskHandler<RollupLegacyTask> = {
+  name: (ctx, task) => {
+    const entries = task.entries.filter((e) => !e.path.includes('__$$bundle_'))
+
+    const targetLines = task.target.length
+      ? ['  target:', ...task.target.map((t) => `    - ${chalk.yellow(t)}`)]
+      : []
+
+    const entriesLines = entries.length
+      ? [
+          '  entries:',
+          ...entries.map((e) =>
+            [
+              '    - ',
+              `${chalk.cyan(path.join(ctx.pkg.name, e.path))}: `,
+              `${chalk.yellow(e.source)} ${chalk.gray('→')} ${chalk.yellow(e.output)}`,
+            ].join(''),
+          ),
+        ]
+      : []
+
+    // @TODO list out the root level files that are generated
+
+    return [
+      'Build legacy exports...',
+      `  format: ${chalk.yellow(task.format)}`,
+      ...targetLines,
+      ...entriesLines,
+    ].join('\n')
+  },
+  exec: (ctx, task) => {
+    return new Observable((observer) => {
+      execPromise(ctx, task)
+        .then((result) => {
+          observer.next(result)
+          observer.complete()
+        })
+        .catch((err) => observer.error(err))
+    })
+  },
+  complete: () => {
+    //
+  },
+  error: (_ctx, _task, err) => {
+    // eslint-disable-next-line no-console
+    console.error(err)
+  },
+}
+
+async function execPromise(ctx: BuildContext, task: RollupLegacyTask) {
+  const {distPath, files, logger} = ctx
+  const outDir = path.relative(ctx.cwd, distPath)
+
+  // Prevent rollup from printing directly to the console
+  const consoleSpy = createConsoleSpy({
+    onRestored: (messages) => {
+      for (const msg of messages) {
+        const text = String(msg.args[0])
+
+        if (msg.code === 'CIRCULAR_DEPENDENCY') {
+          continue // ignore
+        }
+
+        if (text.startsWith('Dynamic import can only')) {
+          continue // ignore
+        }
+
+        if (text.startsWith('Sourcemap is likely to be incorrect')) {
+          continue // ignore
+        }
+
+        if (msg.type === 'log') {
+          logger.info(...msg.args)
+        }
+
+        if (msg.type === 'warn') {
+          logger.warn(...msg.args)
+        }
+
+        if (msg.type === 'error') {
+          logger.error(...msg.args)
+        }
+      }
+    },
+  })
+
+  try {
+    const {inputOptions, outputOptions} = resolveRollupConfig(ctx, task)
+
+    // Create bundle
+    const bundle = await rollup({
+      ...inputOptions,
+      onwarn(warning) {
+        consoleSpy.messages.push({
+          type: 'warn',
+          code: warning.code,
+          args: [warning.message],
+        })
+      },
+    })
+
+    // generate output specific code in-memory
+    // you can call this function multiple times on the same bundle object
+    const {output} = await bundle.generate(outputOptions)
+
+    for (const chunkOrAsset of output) {
+      if (chunkOrAsset.type === 'asset') {
+        files.push({
+          type: 'asset',
+          path: path.resolve(outDir, chunkOrAsset.fileName),
+        })
+      } else {
+        files.push({
+          type: 'chunk',
+          path: path.resolve(outDir, chunkOrAsset.fileName),
+        })
+      }
+    }
+
+    // or write the bundle to disk
+    await bundle.write(outputOptions)
+
+    // closes the bundle
+    await bundle.close()
+
+    // Restore console
+    consoleSpy.restore()
+  } catch (err) {
+    // Restore console
+    consoleSpy.restore()
+    throw err
+  }
+}

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

@@ -4,8 +4,8 @@ import {rollup} from 'rollup'
 import {Observable} from 'rxjs'
 
 import {createConsoleSpy} from '../../consoleSpy'
-import {BuildContext} from '../../core'
-import {RollupTask, TaskHandler} from '../types'
+import type {BuildContext} from '../../core'
+import type {RollupTask, TaskHandler} from '../types'
 import {resolveRollupConfig} from './resolveRollupConfig'
 
 /** @internal */

package/src/node/tasks/types.ts

@@ -1,8 +1,8 @@
-import {RollupWatcherEvent} from 'rollup'
-import {Observable} from 'rxjs'
+import type {RollupWatcherEvent} from 'rollup'
+import type {Observable} from 'rxjs'
 
-import {BuildContext, PkgRuntime} from '../core'
-import {DtsResult, DtsTask, DtsWatchTask} from './dts'
+import type {BuildContext, PkgRuntime} from '../core'
+import type {DtsResult, DtsTask, DtsWatchTask} from './dts'
 
 /** @internal */
 export interface RollupTaskEntry {
@@ -21,6 +21,16 @@ export interface RollupTask {
   target: string[]
 }
 
+/** @internal */
+export interface RollupLegacyTask {
+  type: 'build:legacy'
+  buildId: string
+  entries: RollupTaskEntry[]
+  runtime: PkgRuntime
+  format: 'esm'
+  target: string[]
+}
+
 /** @internal */
 export interface RollupWatchTask {
   type: 'watch:js'
@@ -32,7 +42,7 @@ export interface RollupWatchTask {
 }
 
 /** @internal */
-export type BuildTask = DtsTask | RollupTask
+export type BuildTask = DtsTask | RollupTask | RollupLegacyTask
 
 /** @internal */
 export type WatchTask = DtsWatchTask | RollupWatchTask
@@ -49,6 +59,7 @@ export type TaskHandler<Task, Result = void> = {
 export interface BuildTaskHandlers {
   'build:dts': TaskHandler<DtsTask, DtsResult>
   'build:js': TaskHandler<RollupTask>
+  'build:legacy': TaskHandler<RollupLegacyTask>
 }
 
 /** @internal */

package/src/node/watch.ts

@@ -5,7 +5,7 @@ import {getPkgExtMap, loadConfig, loadPkgWithReporting} from './core'
 import {createLogger} from './logger'
 import {resolveBuildContext} from './resolveBuildContext'
 import {resolveWatchTasks} from './resolveWatchTasks'
-import {TaskHandler, WatchTask, watchTaskHandlers} from './tasks'
+import {type TaskHandler, type WatchTask, watchTaskHandlers} from './tasks'
 import {watchConfigFiles} from './watchConfigFiles'
 
 /** @public */
@@ -32,7 +32,7 @@ export async function watch(options: {
 
       const pkg = await loadPkgWithReporting({cwd, logger, strict})
       const config = await loadConfig({cwd})
-      const extMap = getPkgExtMap({legacyExports: config?.legacyExports ?? false})
+      const extMap = getPkgExtMap()
       const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'
 
       return resolveBuildContext({config, cwd, extMap, logger, pkg, strict, tsconfig})