@sanity/pkg-utils 5.1.0 → 5.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/pkg-utils",
-  "version": "5.1.0",
+  "version": "5.1.1",
   "description": "Simple utilities for modern npm packages.",
   "keywords": [
     "sanity-io",
@@ -25,7 +25,6 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "source": "./src/node/index.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs",
@@ -133,7 +132,7 @@
     "typescript": "5.4.2",
     "vitest": "^1.4.0",
     "vitest-github-actions-reporter": "^0.11.1",
-    "@sanity/pkg-utils": "5.1.0"
+    "@sanity/pkg-utils": "5.1.1"
   },
   "peerDependencies": {
     "typescript": "5.4.2"

package/src/node/build.ts

@@ -3,7 +3,7 @@ import {createLogger} from './logger'
 import {resolveBuildContext} from './resolveBuildContext'
 import {resolveBuildTasks} from './resolveBuildTasks'
 import {createSpinner} from './spinner'
-import {BuildTask, buildTaskHandlers, TaskHandler} from './tasks'
+import {type BuildTask, buildTaskHandlers, type TaskHandler} from './tasks'
 
 /**
  * Build the distribution files of a npm package.

package/src/node/check.ts

@@ -41,14 +41,14 @@ export async function check(options: {
       if (exp.import && !fileExists(path.resolve(cwd, exp.import))) {
         missingFiles.push(exp.import)
       }
+    }
 
-      if (exp.types && !fileExists(path.resolve(cwd, exp.types))) {
-        missingFiles.push(exp.types)
-      }
+    if (ctx.pkg.types && !fileExists(path.resolve(cwd, ctx.pkg.types))) {
+      missingFiles.push(ctx.pkg.types)
     }
 
     if (missingFiles.length) {
-      logger.error('missing files')
+      logger.error(`missing files: ${missingFiles.join(', ')}`)
       process.exit(1)
     }
 

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

@@ -1,10 +1,10 @@
 import chalk from 'chalk'
 import {ZodError} from 'zod'
 
-import {Logger} from '../../logger'
-import {assertFirst, assertLast, assertOrder} from './helpers'
+import type {Logger} from '../../logger'
+import {assertLast, assertOrder} from './helpers'
 import {loadPkg} from './loadPkg'
-import {PackageJSON} from './types'
+import type {PackageJSON} from './types'
 
 /** @internal */
 export async function loadPkgWithReporting(options: {
@@ -28,9 +28,11 @@ export async function loadPkgWithReporting(options: {
 
         const keys = Object.keys(exp)
 
-        if (!assertFirst('types', keys)) {
+        if (exp.types) {
           shouldError = true
-          logger.error(`exports["${expPath}"]: the \`types\` property should be the first property`)
+          logger.error(
+            `exports["${expPath}"]: the \`types\` condition shouldn't be used as dts files are generated in such a way that both CJS and ESM is supported`,
+          )
         }
 
         if (exp.module) {

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

@@ -1,7 +1,7 @@
-import {PkgExport} from '../config'
+import type {PkgExport} from '../config'
 import {isRecord} from '../isRecord'
-import {PkgExtMap} from './pkgExt'
-import {PackageJSON} from './types'
+import type {PkgExtMap} from './pkgExt'
+import type {PackageJSON} from './types'
 import {validateExports} from './validateExports'
 
 /** @internal */
@@ -15,7 +15,6 @@ export function parseExports(options: {
   const rootExport: PkgExport & {_path: string} = {
     _exported: true,
     _path: '.',
-    types: pkg.types,
     source: pkg.source || '',
     browser: pkg.browser && {
       source: pkg.source || '',
@@ -31,6 +30,16 @@ export function parseExports(options: {
 
   const errors: string[] = []
 
+  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 && 'typings' in pkg) {
+    errors.push('package.json: `typings` should be `types`')
+  }
+
   if (pkg.exports) {
     if (strict && !pkg.exports['./package.json']) {
       errors.push('package.json: `exports["./package.json"] must be declared.')
@@ -63,12 +72,6 @@ export function parseExports(options: {
             )
           }
 
-          if (exportEntry.types && rootExport.types && exportEntry.types !== rootExport.types) {
-            errors.push(
-              'package.json: mismatch between "types" and "exports.types". These must be equal.',
-            )
-          }
-
           if (exportEntry.source && rootExport.source && exportEntry.source !== rootExport.source) {
             errors.push(
               'package.json: mismatch between "source" and "exports.source". These must be equal.',

package/src/node/printExtractMessages.ts

@@ -1,8 +1,8 @@
-import {ExtractorMessage} from '@microsoft/api-extractor'
+import type {ExtractorMessage} from '@microsoft/api-extractor'
 import chalk from 'chalk'
 import path from 'path'
 
-import {BuildContext} from './core'
+import type {BuildContext} from './core'
 
 export function printExtractMessages(ctx: BuildContext, messages: ExtractorMessage[]): void {
   const {cwd, logger} = ctx

package/src/node/printPackageTree.ts

@@ -49,7 +49,6 @@ export function printPackageTree(ctx: BuildContext): void {
       .filter(([, entry]) => entry._exported)
       .map(([exportPath, entry]) => {
         const exp: Omit<PkgExport, '_exported'> = {
-          types: undefined,
           source: fileInfo(entry.source),
           browser: undefined,
           require: undefined,
@@ -58,12 +57,6 @@ export function printPackageTree(ctx: BuildContext): void {
           default: fileInfo(entry.default),
         }
 
-        if (entry.types) {
-          exp.types = fileInfo(entry.types)
-        } else {
-          delete exp.types
-        }
-
         if (entry.browser) {
           exp.browser = {source: fileInfo(entry.browser.source)}
 

package/src/node/resolveBuildTasks.ts

@@ -3,6 +3,7 @@ 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'
 
 /** @internal */
 export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
@@ -44,12 +45,48 @@ export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
   for (const exp of exports) {
     const importId = path.join(pkg.name, exp._path)
 
-    if (exp.types) {
+    if (exp.source?.endsWith('.ts')) {
       dtsTask.entries.push({
         importId,
         exportPath: exp._path,
         sourcePath: exp.source,
-        targetPath: exp.types,
+        targetPaths: getTargetPaths(pkg.type, exp),
+      })
+    }
+
+    if (exp.browser?.source?.endsWith('.ts')) {
+      dtsTask.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.browser.source,
+        targetPaths: getTargetPaths(pkg.type, exp.browser),
+      })
+    }
+
+    if (exp.node?.source?.endsWith('.ts')) {
+      dtsTask.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.node.source,
+        targetPaths: getTargetPaths(pkg.type, exp.node),
+      })
+    }
+  }
+
+  // Handle dts tasks for bundles
+  for (const bundle of bundles) {
+    if (bundle.source?.endsWith('.ts')) {
+      // importId needs to be how the bundle is used, like `@sanity/pkg-utils/dist/cli`
+      // exportPath needs to be the path to the bundle, like `./dist/cli`
+      // targetPaths is then: [./dist/cli.d.ts, ./dist/cli.d.cts]
+      const exportPath = (bundle.import || bundle.require)!.replace(/\.[mc]?js$/, '')
+      const importId = path.join(pkg.name, exportPath)
+
+      dtsTask.entries.push({
+        importId,
+        exportPath,
+        sourcePath: bundle.source,
+        targetPaths: getTargetPaths(pkg.type, bundle),
       })
     }
   }

package/src/node/resolveWatchTasks.ts

@@ -1,8 +1,9 @@
 import fs from 'fs'
 import path from 'path'
 
-import {BuildContext, PkgExport, PkgFormat, PkgRuntime} from './core'
-import {DtsWatchTask, RollupTaskEntry, RollupWatchTask, WatchTask} from './tasks'
+import type {BuildContext, PkgExport, PkgFormat, PkgRuntime} from './core'
+import type {DtsWatchTask, RollupTaskEntry, RollupWatchTask, WatchTask} from './tasks'
+import {getTargetPaths} from './tasks/dts/getTargetPaths'
 
 /** @internal */
 export function resolveWatchTasks(ctx: BuildContext): WatchTask[] {
@@ -41,12 +42,30 @@ export function resolveWatchTasks(ctx: BuildContext): WatchTask[] {
   for (const exp of exports) {
     const importId = path.join(pkg.name, exp._path)
 
-    if (exp.types) {
+    if (exp.source?.endsWith('.ts')) {
       dtsTask.entries.push({
         importId,
         exportPath: exp._path,
         sourcePath: exp.source,
-        targetPath: exp.types,
+        targetPaths: getTargetPaths(pkg.type, exp),
+      })
+    }
+
+    if (exp.browser?.source?.endsWith('.ts')) {
+      dtsTask.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.browser.source,
+        targetPaths: getTargetPaths(pkg.type, exp.browser),
+      })
+    }
+
+    if (exp.node?.source?.endsWith('.ts')) {
+      dtsTask.entries.push({
+        importId,
+        exportPath: exp._path,
+        sourcePath: exp.node.source,
+        targetPaths: getTargetPaths(pkg.type, exp.node),
       })
     }
   }

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

@@ -34,7 +34,7 @@ export async function doExtract(
   await buildTypes({cwd, logger, outDir: tmpPath, strict, tsconfig: ts.config})
   const messages: ExtractorMessage[] = []
 
-  const results: {sourcePath: string; filePath: string}[] = []
+  const results: {sourcePath: string; filePaths: string[]}[] = []
 
   for (const entry of task.entries) {
     const exportPath = entry.exportPath === '.' ? './index' : entry.exportPath
@@ -44,8 +44,8 @@ export async function doExtract(
       path.relative(rootDir, path.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, '.d.ts'),
     )
 
-    const targetPath = path.resolve(cwd, entry.targetPath)
-    const filePath = path.relative(outDir, targetPath)
+    const targetPaths = entry.targetPaths.map((targetPath) => path.resolve(cwd, targetPath))
+    const filePaths = targetPaths.map((targetPath) => path.relative(outDir, targetPath))
     const result = await extractTypes({
       bundledPackages: config?.extract?.bundledPackages || [],
       customTags: config?.extract?.customTags,
@@ -53,7 +53,7 @@ export async function doExtract(
       distPath: outDir,
       exportPath,
       files,
-      filePath: filePath,
+      filePaths,
       projectPath: cwd,
       rules: config?.extract?.rules,
       sourceTypesPath: sourceTypesPath,
@@ -71,7 +71,7 @@ export async function doExtract(
       throw new DtsError(`encountered ${errors.length} errors when extracting types`, errors)
     }
 
-    results.push({sourcePath: path.resolve(cwd, entry.sourcePath), filePath: targetPath})
+    results.push({sourcePath: path.resolve(cwd, entry.sourcePath), filePaths: targetPaths})
   }
 
   await rimraf(tmpPath)

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

@@ -13,12 +13,16 @@ export const dtsTask: TaskHandler<DtsTask, DtsResult> = {
     [
       'Build type definitions...',
       '  entries:',
-      ...task.entries.map((entry) =>
-        [
-          `    - ${chalk.cyan(entry.importId)}: `,
-          `${chalk.yellow(entry.sourcePath)} ${chalk.gray('→')} ${chalk.yellow(entry.targetPath)}`,
-        ].join(''),
-      ),
+      ...task.entries.map((entry) => {
+        return entry.targetPaths
+          .map((targetPath) => {
+            return [
+              `    - ${chalk.cyan(entry.importId)}: `,
+              `${chalk.yellow(entry.sourcePath)} ${chalk.gray('→')} ${chalk.yellow(targetPath)}`,
+            ].join('')
+          })
+          .join('\n')
+      }),
     ].join('\n'),
   exec: (ctx, task) => {
     return new Observable((observer) => {

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

@@ -2,20 +2,24 @@ import chalk from 'chalk'
 import {Observable} from 'rxjs'
 
 import {printExtractMessages} from '../../printExtractMessages'
-import {TaskHandler} from '../types'
+import type {TaskHandler} from '../types'
 import {doExtract} from './doExtract'
 import {DtsError} from './DtsError'
-import {DtsResult, DtsWatchTask} from './types'
+import type {DtsResult, DtsWatchTask} from './types'
 
 /** @internal */
 export const dtsWatchTask: TaskHandler<DtsWatchTask, DtsResult> = {
   name: (_ctx, task) =>
     [
       `build type definitions`,
-      ...task.entries.map(
-        (entry) =>
-          `       ${chalk.blue(entry.importId)}: ${entry.sourcePath} -> ${entry.targetPath}`,
-      ),
+      ...task.entries.map((entry) => {
+        return entry.targetPaths.map((targetPath) => {
+          return [
+            `    - ${chalk.cyan(entry.importId)}: `,
+            `${chalk.yellow(entry.sourcePath)} ${chalk.gray('→')} ${chalk.yellow(targetPath)}`,
+          ].join('')
+        })
+      }),
     ].join('\n'),
   exec: (ctx, task) => {
     return new Observable((observer) => {

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

@@ -8,7 +8,7 @@ import fs from 'fs/promises'
 import {mkdirp} from 'mkdirp'
 import path from 'path'
 import prettier from 'prettier'
-import ts from 'typescript'
+import type ts from 'typescript'
 
 import type {BuildFile, PkgConfigOptions} from '../../core'
 import {createApiExtractorConfig} from './createApiExtractorConfig'
@@ -22,7 +22,7 @@ export async function extractTypes(options: {
   cwd: string
   distPath: string
   exportPath: string
-  filePath: string
+  filePaths: string[]
   files: BuildFile[]
   projectPath: string
   rules?: NonNullable<PkgConfigOptions['extract']>['rules']
@@ -37,7 +37,7 @@ export async function extractTypes(options: {
     distPath,
     exportPath,
     files,
-    filePath,
+    filePaths,
     projectPath,
     rules,
     sourceTypesPath,
@@ -50,6 +50,9 @@ export async function extractTypes(options: {
     customTags: customTags || [],
   })
 
+  const filePath = filePaths[0].replace(/\.d\.[mc]ts$/, '.d.ts')
+  // If there are package.config.ts `bundles` we might not have something that should leave behind a `.d.ts` file and need to handle that
+  const shouldCleanUpDts = !filePaths.includes(filePath)
   const extractorConfig: ExtractorConfig = ExtractorConfig.prepare({
     configObject: createApiExtractorConfig({
       bundledPackages,
@@ -94,20 +97,26 @@ export async function extractTypes(options: {
   })
 
   const code = [typesBuf.toString(), ...moduleBlocks].join('\n\n')
+  const prettyCode = await prettier.format(code, {
+    ...prettierConfig,
+    filepath: typesPath,
+  })
 
-  await fs.writeFile(
-    typesPath,
-    await prettier.format(code, {
-      ...prettierConfig,
-      filepath: typesPath,
-    }),
-  )
+  for (const expFilePath of filePaths) {
+    const expTypesPath = path.resolve(distPath, expFilePath)
 
-  // Add to `files` in context
-  files.push({
-    type: 'types',
-    path: typesPath,
-  })
+    await fs.writeFile(expTypesPath, prettyCode)
+
+    // Add to `files` in context
+    files.push({
+      type: 'types',
+      path: expTypesPath,
+    })
+  }
+
+  if (shouldCleanUpDts) {
+    await fs.unlink(typesPath)
+  }
 
   return {extractorResult, messages}
 }

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

@@ -0,0 +1,64 @@
+import type {PackageJSON, PkgBundle, PkgExport} from '../../core'
+
+const fileEnding = /\.[mc]?js$/
+const dtsEnding = '.d.ts'
+const mtsEnding = '.d.mts'
+const ctsEnding = '.d.cts'
+
+/** @internal */
+export function getTargetPaths(
+  _type: PackageJSON['type'],
+  expOrBundle: PkgExport | PkgExport['browser'] | PkgExport['node'] | PkgBundle,
+): string[] {
+  const type = (_type === 'module' ? 'module' : 'commonjs') satisfies PackageJSON['type']
+
+  const set = new Set<string>()
+
+  if (expOrBundle?.import) {
+    set.add(expOrBundle.import.replace(fileEnding, type === 'module' ? dtsEnding : mtsEnding))
+  }
+
+  if (expOrBundle?.require) {
+    set.add(expOrBundle.require.replace(fileEnding, type === 'commonjs' ? dtsEnding : ctsEnding))
+  }
+
+  if (isPkgExport(expOrBundle)) {
+    if (!expOrBundle.browser?.source) {
+      if (expOrBundle.browser?.import) {
+        set.add(
+          expOrBundle.browser.import.replace(fileEnding, type === 'module' ? dtsEnding : mtsEnding),
+        )
+      }
+
+      if (expOrBundle.browser?.require) {
+        set.add(
+          expOrBundle.browser.require.replace(
+            fileEnding,
+            type === 'commonjs' ? dtsEnding : ctsEnding,
+          ),
+        )
+      }
+    }
+
+    if (!expOrBundle.node?.source) {
+      if (expOrBundle.node?.import) {
+        set.add(
+          expOrBundle.node.import.replace(fileEnding, type === 'module' ? dtsEnding : mtsEnding),
+        )
+      }
+
+      if (expOrBundle.node?.require) {
+        set.add(
+          expOrBundle.node.require.replace(fileEnding, type === 'commonjs' ? dtsEnding : ctsEnding),
+        )
+      }
+    }
+  }
+
+  return Array.from(set)
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function isPkgExport(exp: any): exp is PkgExport {
+  return exp?.browser || exp?.node || exp?.default
+}

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

@@ -1,4 +1,4 @@
-import {ExtractorMessage} from '@microsoft/api-extractor'
+import type {ExtractorMessage} from '@microsoft/api-extractor'
 
 /** @internal */
 export interface DtsWatchTask {
@@ -7,7 +7,7 @@ export interface DtsWatchTask {
     exportPath: string
     importId: string
     sourcePath: string
-    targetPath: string
+    targetPaths: string[]
   }[]
 }
 
@@ -18,7 +18,7 @@ export interface DtsTask {
     exportPath: string
     importId: string
     sourcePath: string
-    targetPath: string
+    targetPaths: string[]
   }[]
 }
 
@@ -26,5 +26,5 @@ export interface DtsTask {
 export interface DtsResult {
   type: 'dts'
   messages: ExtractorMessage[]
-  results: {sourcePath: string; filePath: string}[]
+  results: {sourcePath: string; filePaths: string[]}[]
 }

package/src/node/templates/default/template.ts

@@ -278,12 +278,6 @@ export const defaultTemplate: PkgTemplate = async ({cwd, logger, packagePath}) =
       if (features.typescript) {
         pkgJson.types = './dist/index.d.ts'
 
-        const mainExport = pkgJson.exports?.['.']
-
-        if (isRecord(mainExport)) {
-          mainExport.types = './dist/index.d.ts'
-        }
-
         pkgJson.scripts = {
           ...pkgJson.scripts,
           ['ts:check']: 'tsc --build',