@sanity/pkg-utils 2.0.0-beta.1 → 2.0.0-beta.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@sanity/pkg-utils",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.3",
   "author": "Sanity.io <hello@sanity.io>",
   "license": "MIT",
   "description": "Simple utilities for modern npm packages.",
@@ -40,8 +40,8 @@
   ],
   "scripts": {
     "build": "run-s clean build:pkg check:pkg",
-    "build:pkg": "node --experimental-loader ./scripts/_experimental-loader.js -r esbuild-register scripts/build",
-    "check:pkg": "node --experimental-loader ./scripts/_experimental-loader.js -r esbuild-register scripts/check",
+    "build:pkg": "node --loader esbuild-register/loader -r esbuild-register scripts/build",
+    "check:pkg": "node --loader esbuild-register/loader -r esbuild-register scripts/check",
     "check:types": "tsc --build",
     "clean": "rimraf dist test/env/__tmp__",
     "commit": "cz",
@@ -51,7 +51,7 @@
     "prepublishOnly": "pnpm run build",
     "release": "semantic-release",
     "test": "vitest run",
-    "watch": "node --experimental-loader ./scripts/_experimental-loader.js -r esbuild-register scripts/watch"
+    "watch": "node --loader esbuild-register/loader -r esbuild-register scripts/watch"
   },
   "dependencies": {
     "@babel/core": "^7.20.5",

package/src/node/build.ts

@@ -1,4 +1,5 @@
-import {loadConfig, loadPkgWithReporting} from './core'
+import {getPkgExtMap, loadConfig, loadPkgWithReporting} from './core'
+import {createLogger} from './logger'
 import {resolveBuildContext} from './resolveBuildContext'
 import {resolveBuildTasks} from './resolveBuildTasks'
 import {createSpinner} from './spinner'
@@ -30,11 +31,23 @@ export async function build(options: {
   tsconfig?: string
 }): Promise<void> {
   const {cwd, emitDeclarationOnly, strict = false, tsconfig: tsconfigOption} = options
+  const logger = createLogger()
 
-  const pkg = await loadPkgWithReporting({cwd})
+  const pkg = await loadPkgWithReporting({cwd, logger})
   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, pkg, strict, tsconfig})
+
+  const ctx = await resolveBuildContext({
+    config,
+    cwd,
+    emitDeclarationOnly,
+    extMap,
+    logger,
+    pkg,
+    strict,
+    tsconfig,
+  })
 
   const buildTasks = resolveBuildTasks(ctx)
 

package/src/node/check.ts

@@ -1,6 +1,7 @@
 import path from 'path'
 import esbuild, {BuildFailure} from 'esbuild'
-import {loadConfig, loadPkgWithReporting} from './core'
+import {getPkgExtMap, loadConfig, loadPkgWithReporting} from './core'
+import {createLogger} from './logger'
 import {fileExists, printPackageTree} from './printPackageTree'
 import {resolveBuildContext} from './resolveBuildContext'
 
@@ -11,12 +12,13 @@ export async function check(options: {
   tsconfig?: string
 }): Promise<void> {
   const {cwd, strict = false, tsconfig: tsconfigOption} = options
+  const logger = createLogger()
 
-  const pkg = await loadPkgWithReporting({cwd})
+  const pkg = await loadPkgWithReporting({cwd, logger})
   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, pkg, strict, tsconfig})
-  const {logger} = ctx
+  const ctx = await resolveBuildContext({config, cwd, extMap, logger, pkg, strict, tsconfig})
 
   printPackageTree(ctx)
 

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

@@ -1,6 +1,7 @@
 import ts from 'typescript'
+import {Logger} from '../../logger'
 import {PkgExports, PkgRuntime, PkgConfigOptions} from '../config'
-import {PackageJSON} from '../pkg'
+import {PackageJSON, PkgExtMap} from '../pkg'
 
 /** @internal */
 export interface BuildFile {
@@ -15,15 +16,10 @@ export interface BuildContext {
   distPath: string
   emitDeclarationOnly: boolean
   exports: PkgExports | undefined
+  extMap: PkgExtMap
   external: string[]
   files: BuildFile[]
-  logger: {
-    log: (...args: unknown[]) => void
-    info: (...args: unknown[]) => void
-    warn: (...args: unknown[]) => void
-    error: (...args: unknown[]) => void
-    success: (...args: unknown[]) => void
-  }
+  logger: Logger
   pkg: PackageJSON
   runtime: PkgRuntime
   strict: boolean

package/src/node/core/index.ts

@@ -1,4 +1,3 @@
-export * from './constants'
 export * from './defaults'
 export * from './isRecord'
 export * from './config'

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

@@ -1,4 +1,5 @@
 export * from './loadPkg'
 export * from './loadPkgWithReporting'
 export * from './parseExports'
+export * from './pkgExt'
 export * from './types'

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

@@ -1,34 +1,25 @@
-/* eslint-disable no-console */
-
 import chalk from 'chalk'
 import {ZodError} from 'zod'
+import {Logger} from '../../logger'
 import {loadPkg} from './loadPkg'
 import {PackageJSON} from './types'
 
 /** @internal */
-export async function loadPkgWithReporting(options: {cwd: string}): Promise<PackageJSON> {
-  try {
-    const pkg = await loadPkg(options)
+export async function loadPkgWithReporting(options: {
+  cwd: string
+  logger: Logger
+}): Promise<PackageJSON> {
+  const {cwd, logger} = options
 
-    if (pkg.type === 'commonjs') {
-      console.warn(
-        [
-          `${chalk.yellow('warn')}   `,
-          'Packages with `"type": "commonjs"` may not be compatible with popular bundlers like ',
-          'webpack and rollup, and projects such as Astro and SvelteKit. Please consider using ',
-          '`"type": "module"` instead.',
-        ].join('')
-      )
-    }
-
-    return pkg
+  try {
+    return await loadPkg({cwd})
   } catch (err) {
     if (err instanceof ZodError) {
       for (const issue of err.issues) {
         if (issue.code === 'invalid_type') {
-          console.error(
+          logger.error(
             [
-              `${chalk.red('fail')}   \`${formatPath(issue.path)}\` `,
+              `\`${formatPath(issue.path)}\` `,
               `in \`./package.json\` must be of type ${chalk.magenta(issue.expected)} `,
               `(received ${chalk.magenta(issue.received)})`,
             ].join('')
@@ -36,7 +27,7 @@ export async function loadPkgWithReporting(options: {cwd: string}): Promise<Pack
         }
       }
     } else {
-      console.error(err)
+      logger.error(err)
     }
 
     process.exit(1)

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

@@ -1,14 +1,16 @@
 import {PkgExport} from '../config'
 import {isRecord} from '../isRecord'
+import {PkgExtMap} from './pkgExt'
 import {PackageJSON} from './types'
 import {validateExports} from './validateExports'
 
 /** @internal */
 export function parseExports(options: {
+  extMap: PkgExtMap
   pkg: PackageJSON
   strict: boolean
 }): (PkgExport & {_path: string})[] {
-  const {pkg, strict} = options
+  const {extMap, pkg, strict} = options
 
   const rootExport: PkgExport & {_path: string} = {
     _exported: true,
@@ -89,7 +91,7 @@ export function parseExports(options: {
 
   const _exports = [rootExport, ...extraExports]
 
-  errors.push(...validateExports(_exports, {pkg}))
+  errors.push(...validateExports(_exports, {extMap, pkg}))
 
   if (errors.length) {
     throw new Error('\n- ' + errors.join('\n- '))

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

@@ -0,0 +1,38 @@
+/** @internal */
+export interface PkgExtMap {
+  commonjs: {commonjs: string; esm: string}
+  module: {commonjs: string; esm: string}
+}
+
+/** @internal */
+export const DEFAULT_PKG_EXT_MAP: PkgExtMap = {
+  // pkg.type: "commonjs"
+  commonjs: {
+    commonjs: '.js',
+    esm: '.mjs',
+  },
+
+  // pkg.type: "module"
+  module: {
+    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/src/node/core/pkg/validateExports.ts

@@ -1,13 +1,13 @@
 import {PkgExport} from '../config'
-import {MODULE_EXT} from '../constants'
+import {PkgExtMap} from './pkgExt'
 import {PackageJSON} from './types'
 
 export function validateExports(
   _exports: (PkgExport & {_path: string})[],
-  options: {pkg: PackageJSON}
+  options: {extMap: PkgExtMap; pkg: PackageJSON}
 ): string[] {
-  const {pkg} = options
-  const ext = MODULE_EXT[pkg.type]
+  const {extMap, pkg} = options
+  const ext = extMap[pkg.type]
 
   const errors: string[] = []
 

package/src/node/index.ts

@@ -1,6 +1,7 @@
+export * from './build'
+export * from './check'
 export * from './core'
+export * from './logger'
 export * from './resolveBuildTasks'
 export * from './tasks'
-export * from './build'
-export * from './check'
 export * from './watch'

package/src/node/logger.ts

@@ -0,0 +1,33 @@
+import chalk from 'chalk'
+
+/** @internal */
+export interface Logger {
+  log: (...args: unknown[]) => void
+  info: (...args: unknown[]) => void
+  warn: (...args: unknown[]) => void
+  error: (...args: unknown[]) => void
+  success: (...args: unknown[]) => void
+}
+
+/** @internal */
+export function createLogger(): Logger {
+  return {
+    /* eslint-disable no-console */
+    log: (...args) => {
+      console.log(...args)
+    },
+    info: (...args) => {
+      console.log(chalk.blue('[info]'), ...args)
+    },
+    warn: (...args) => {
+      console.log(chalk.yellow('[warning]'), ...args)
+    },
+    error: (...args) => {
+      console.log(chalk.red('[error]'), ...args)
+    },
+    success: (...args) => {
+      console.log(chalk.green('[success]'), ...args)
+    },
+    /* eslint-enable no-console */
+  }
+}

package/src/node/printPackageTree.ts

@@ -31,10 +31,12 @@ export function printPackageTree(ctx: BuildContext): void {
   logger.log(`${chalk.blue(pkg.name)}@${chalk.green(pkg.version)}`)
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const tree: Record<string, any> = {}
+  const tree: Record<string, unknown> = {type: chalk.yellow(pkg.type)}
 
   if (pkg.bin) {
-    tree.bin = pkg.bin
+    tree.bin = Object.fromEntries(
+      Object.entries(pkg.bin).map(([name, file]) => [chalk.cyan(name), fileInfo(file)])
+    )
   }
 
   function fileInfo(file: string) {
@@ -44,7 +46,7 @@ export function printPackageTree(ctx: BuildContext): void {
       return `${chalk.gray(file)} ${chalk.red('does not exist')}`
     }
 
-    return `${file} ${chalk.gray(info.size)}`
+    return `${chalk.yellow(file)} ${chalk.gray(info.size)}`
   }
 
   tree.exports = Object.fromEntries(
@@ -52,13 +54,13 @@ export function printPackageTree(ctx: BuildContext): void {
       .filter(([, entry]) => entry._exported)
       .map(([exportPath, entry]) => {
         const exp: Omit<PkgExport, '_exported'> = {
-          source: entry.source,
           types: undefined,
+          source: fileInfo(entry.source),
           browser: undefined,
           node: undefined,
           import: undefined,
           require: undefined,
-          default: entry.default,
+          default: fileInfo(entry.default),
         }
 
         if (entry.types) {
@@ -68,7 +70,7 @@ export function printPackageTree(ctx: BuildContext): void {
         }
 
         if (entry.browser) {
-          exp.browser = {source: entry.browser.source}
+          exp.browser = {source: fileInfo(entry.browser.source)}
 
           if (entry.browser.import) exp.browser.import = fileInfo(entry.browser.import)
           if (entry.browser.require) exp.browser.require = fileInfo(entry.browser.require)
@@ -77,7 +79,7 @@ export function printPackageTree(ctx: BuildContext): void {
         }
 
         if (entry.node) {
-          exp.node = {source: entry.node.source}
+          exp.node = {source: fileInfo(entry.node.source)}
 
           if (entry.node.import) exp.node.import = fileInfo(entry.node.import)
           if (entry.node.require) exp.node.require = fileInfo(entry.node.require)
@@ -97,11 +99,9 @@ export function printPackageTree(ctx: BuildContext): void {
           delete exp.require
         }
 
-        exp.default = fileInfo(entry.default)
-
-        return [chalk.green(path.join(pkg.name, exportPath)), exp]
+        return [chalk.cyan(path.join(pkg.name, exportPath)), exp]
       })
   )
 
-  logger.log(treeify.asTree(tree, true, true))
+  logger.log(treeify.asTree(tree as Record<string, any>, true, true))
 }

package/src/node/resolveBuildContext.ts

@@ -1,5 +1,4 @@
 import path from 'path'
-import chalk from 'chalk'
 import {
   PkgConfigOptions,
   PkgExports,
@@ -10,44 +9,34 @@ import {
   PackageJSON,
   parseExports,
   resolveConfigProperty,
+  PkgExtMap,
 } from './core'
 import {findCommonDirPath, pathContains} from './core/findCommonPath'
+import {Logger} from './logger'
 import {resolveBrowserslistVersions} from './resolveBrowserslistVersions'
 import {resolveBrowserTarget} from './resolveBrowserTarget'
 import {resolveNodeTarget} from './resolveNodeTarget'
 
-function createLogger(): BuildContext['logger'] {
-  return {
-    /* eslint-disable no-console */
-    log: (...args) => {
-      console.log(...args)
-    },
-    info: (...args) => {
-      console.log(chalk.blue('  info'), ...args)
-    },
-    warn: (...args) => {
-      console.log(chalk.yellow('  warn'), ...args)
-    },
-    error: (...args) => {
-      console.log(chalk.red('  fail'), ...args)
-    },
-    success: (...args) => {
-      console.log(chalk.green('  ok  '), ...args)
-    },
-    /* eslint-enable no-console */
-  }
-}
-
 export async function resolveBuildContext(options: {
   config?: PkgConfigOptions
   cwd: string
   emitDeclarationOnly?: boolean
+  extMap: PkgExtMap
+  logger: Logger
   pkg: PackageJSON
   strict: boolean
   tsconfig: string
 }): Promise<BuildContext> {
-  const {config, cwd, emitDeclarationOnly = false, pkg, strict, tsconfig: tsconfigPath} = options
-  const logger = createLogger()
+  const {
+    config,
+    cwd,
+    emitDeclarationOnly = false,
+    extMap,
+    logger,
+    pkg,
+    strict,
+    tsconfig: tsconfigPath,
+  } = options
   const tsconfig = await loadTSConfig({cwd, tsconfigPath})
   const targetVersions = resolveBrowserslistVersions(pkg.browserslist || DEFAULT_BROWSERSLIST_QUERY)
   const nodeTarget = resolveNodeTarget(targetVersions)
@@ -67,7 +56,7 @@ export async function resolveBuildContext(options: {
     node: nodeTarget,
   }
 
-  const parsedExports = parseExports({pkg, strict}).reduce<PkgExports>((acc, x) => {
+  const parsedExports = parseExports({extMap, pkg, strict}).reduce<PkgExports>((acc, x) => {
     const {_path: exportPath, ...exportEntry} = x
 
     return {...acc, [exportPath]: exportEntry}
@@ -137,6 +126,7 @@ export async function resolveBuildContext(options: {
     emitDeclarationOnly,
     exports,
     external,
+    extMap,
     files: [],
     logger,
     pkg,

package/src/node/spinner.ts

@@ -5,14 +5,14 @@ import chalk from 'chalk'
 export function createSpinner(msg: string): {complete: () => void; error: () => void} {
   const startTime = Date.now()
 
-  console.log(`       ${msg}`)
+  console.log(msg)
 
   return {
     complete: () => {
-      console.log(`${chalk.green('ok    ')} ${chalk.gray(`${Date.now() - startTime}ms`)}`)
+      console.log(`${chalk.green('[success]')} ${chalk.gray(`${Date.now() - startTime}ms`)}`)
     },
     error: () => {
-      console.log(`${chalk.red(`failed`)} ${chalk.gray(`${Date.now() - startTime}ms`)}`)
+      console.log(`${chalk.red(`[error]`)} ${chalk.gray(`${Date.now() - startTime}ms`)}`)
     },
   }
 }

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

@@ -1,21 +1,16 @@
-/* eslint-disable no-console */
-
 import ts from 'typescript'
-
-export const formatHost: ts.FormatDiagnosticsHost = {
-  getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
-  getNewLine: () => ts.sys.newLine,
-  getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase(),
-}
+import {Logger} from '../../logger'
+import {printDiagnostic} from './printDiagnostic'
 
 /** @internal */
 export async function buildTypes(options: {
   cwd: string
+  logger: Logger
   outDir: string
   tsconfig: ts.ParsedCommandLine
   strict: boolean
 }): Promise<void> {
-  const {outDir, tsconfig, strict = false} = options
+  const {cwd, logger, outDir, tsconfig, strict = false} = options
 
   const compilerOptions: ts.CompilerOptions = {
     ...tsconfig.options,
@@ -32,24 +27,14 @@ export async function buildTypes(options: {
 
   const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics)
 
-  // TODO: improve logging
-  allDiagnostics.forEach((diagnostic) => {
-    if (diagnostic.file && diagnostic.start) {
-      const {line, character} = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start)
-      const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n')
-
-      console.log(`${diagnostic.file.fileName} ${line + 1}:${character + 1}\n${message}`)
-    } else {
-      console.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'))
-    }
-  })
+  for (const diagnostic of allDiagnostics) {
+    printDiagnostic({cwd, logger, diagnostic})
+  }
 
   if (emitResult.emitSkipped) {
     const errors = allDiagnostics.filter((diag) => diag.category === ts.DiagnosticCategory.Error)
 
     if (errors.length) {
-      console.error(ts.formatDiagnostics(errors, formatHost))
-
       if (strict) {
         throw new Error('failed to compile TypeScript definitions')
       }

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

@@ -19,7 +19,7 @@ export async function doExtract(
   ctx: BuildContext,
   task: DtsTask | DtsWatchTask
 ): Promise<DtsResult> {
-  const {config, cwd, files, strict, ts} = ctx
+  const {config, cwd, files, logger, strict, ts} = ctx
 
   if (!ts.config || !ts.configPath) {
     return {type: 'dts', messages: [], results: []}
@@ -33,7 +33,7 @@ export async function doExtract(
 
   const tmpPath = path.resolve(outDir, '__tmp__')
 
-  await buildTypes({cwd, outDir: tmpPath, strict, tsconfig: ts.config})
+  await buildTypes({cwd, logger, outDir: tmpPath, strict, tsconfig: ts.config})
   const messages: ExtractorMessage[] = []
 
   const results: {sourcePath: string; filePath: string}[] = []

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

@@ -10,10 +10,13 @@ import {DtsResult, DtsTask} from './types'
 export const dtsTask: TaskHandler<DtsTask, DtsResult> = {
   name: (_ctx, task) =>
     [
-      `build type definitions`,
-      ...task.entries.map(
-        (entry) =>
-          `       ${chalk.blue(entry.importId)}: ${entry.sourcePath} -> ${entry.targetPath}`
+      `Build type definitions...`,
+      `  entries:`,
+      ...task.entries.map((entry) =>
+        [
+          `    - ${chalk.cyan(entry.importId)}: `,
+          `${chalk.yellow(entry.sourcePath)} ${chalk.gray('→')} ${chalk.yellow(entry.targetPath)}`,
+        ].join('')
       ),
     ].join('\n'),
   exec: (ctx, task) => {

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

@@ -0,0 +1,42 @@
+import path from 'path'
+import chalk from 'chalk'
+import ts from 'typescript'
+import {Logger} from '../../logger'
+
+export function printDiagnostic(options: {
+  cwd: string
+  logger: Logger
+  diagnostic: ts.Diagnostic
+}): void {
+  const {cwd, logger, diagnostic} = options
+
+  if (diagnostic.file && diagnostic.start) {
+    const {line, character} = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start)
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n')
+
+    const file = path.relative(cwd, diagnostic.file.fileName)
+
+    const output = [
+      `${chalk.yellow(file)}:${chalk.blue(line + 1)}:${chalk.blue(character + 1)} - `,
+      `${chalk.gray(`TS${diagnostic.code}:`)} ${message}`,
+    ].join('')
+
+    if (diagnostic.category === ts.DiagnosticCategory.Error) {
+      logger.error(output)
+    }
+
+    if (diagnostic.category === ts.DiagnosticCategory.Warning) {
+      logger.warn(output)
+    }
+
+    if (diagnostic.category === ts.DiagnosticCategory.Message) {
+      logger.log(output)
+    }
+
+    if (diagnostic.category === ts.DiagnosticCategory.Suggestion) {
+      logger.log(output)
+    }
+  } else {
+    logger.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'))
+  }
+}

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

@@ -0,0 +1,41 @@
+/* eslint-disable no-console */
+
+export interface ConsoleSpyMsg {
+  type: 'log' | 'warn' | 'error'
+  code?: string
+  args: unknown[]
+}
+
+export interface ConsoleSpy {
+  messages: ConsoleSpyMsg[]
+  restore: () => void
+}
+
+export function createConsoleSpy(options: {
+  onRestored: (messages: ConsoleSpyMsg[]) => void
+}): ConsoleSpy {
+  const {onRestored} = options
+
+  const original = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+  }
+
+  const messages: ConsoleSpyMsg[] = []
+
+  console.log = (...args: unknown[]) => messages.push({type: 'log', args})
+  console.warn = (...args: unknown[]) => messages.push({type: 'warn', args})
+  console.error = (...args: unknown[]) => messages.push({type: 'error', args})
+
+  return {
+    messages,
+    restore: () => {
+      console.log = original.log
+      console.warn = original.warn
+      console.error = original.error
+
+      onRestored(messages)
+    },
+  }
+}