@sanity/pkg-utils 1.3.1 → 1.5.0

package/src/node/_printPackageTree.ts

@@ -0,0 +1,72 @@
+import fs from 'fs'
+import path from 'path'
+import chalk from 'chalk'
+import treeify from 'treeify'
+import {PkgExport, _BuildContext} from './_core'
+import {_getFilesize} from './_getFilesize'
+
+export function _fileExists(file: string): boolean {
+  try {
+    fs.accessSync(file)
+
+    return true
+  } catch (_) {
+    return false
+  }
+}
+
+function _getFileInfo(cwd: string, filePath: string) {
+  const p = path.resolve(cwd, filePath)
+  const exists = _fileExists(p)
+  const size = exists ? _getFilesize(p) : undefined
+
+  return {exists, size}
+}
+
+export function _printPackageTree(ctx: _BuildContext): void {
+  const {cwd, exports, logger, pkg} = ctx
+
+  if (!exports) return
+
+  logger.log(`${chalk.blue(pkg.name)}@${chalk.green(pkg.version)}`)
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const tree: Record<string, any> = {}
+
+  if (pkg.bin) {
+    tree.bin = pkg.bin
+  }
+
+  function _fileInfo(file: string) {
+    const info = _getFileInfo(cwd, file)
+
+    if (!info.size) {
+      return `${chalk.gray(file)} ${chalk.red('does not exist')}`
+    }
+
+    return `${file} ${chalk.gray(info.size)}`
+  }
+
+  tree.exports = Object.fromEntries(
+    Object.entries(exports)
+      .filter(([, entry]) => entry._exported)
+      .map(([exportPath, entry]) => {
+        const exp: Omit<PkgExport, '_exported'> = {source: entry.source}
+
+        if (entry.browser) {
+          exp.browser = {}
+
+          if (entry.browser.import) exp.browser.import = _fileInfo(entry.browser.import)
+          if (entry.browser.require) exp.browser.import = _fileInfo(entry.browser.require)
+        }
+
+        if (entry.import) exp.import = _fileInfo(entry.import)
+        if (entry.require) exp.require = _fileInfo(entry.require)
+        if (entry.types) exp.types = _fileInfo(entry.types)
+
+        return [chalk.green(path.join(pkg.name, exportPath)), exp]
+      })
+  )
+
+  logger.log(treeify.asTree(tree, true, true))
+}

package/src/{build/_parseWebTarget.ts → node/_resolveBrowserTarget.ts}

@@ -1,6 +1,6 @@
-import {_PackageTargetVersions} from './_parseBrowserslistVersions'
+import {_PackageTargetVersions} from './_resolveBrowserslistVersions'
 
-export function _parseWebTarget(versions: _PackageTargetVersions): string[] | undefined {
+export function _resolveBrowserTarget(versions: _PackageTargetVersions): string[] | undefined {
   const target: string[] = []
 
   if (versions.chrome.length) {

package/src/{build/_parseBrowserslistVersions.ts → node/_resolveBrowserslistVersions.ts}

@@ -17,7 +17,7 @@ function _sortAsNumber(a: string, b: string) {
   return aVersion - bVersion
 }
 
-export function _parseBrowserslistVersions(query: string[]): _PackageTargetVersions {
+export function _resolveBrowserslistVersions(query: string[]): _PackageTargetVersions {
   const result = browserslist(query)
 
   const entries = result.map((key) => {

package/src/node/_resolveBuildContext.ts

@@ -0,0 +1,104 @@
+import path from 'path'
+import chalk from 'chalk'
+import {
+  PkgConfigOptions,
+  PkgExports,
+  PkgRuntime,
+  _BuildContext,
+  _DEFAULTS,
+  // _loadConfig,
+  // _loadPkgWithReporting,
+  _loadTSConfig,
+  _PackageJSON,
+  _parseExports,
+  _resolveConfigProperty,
+} from './_core'
+import {_resolveBrowserslistVersions} from './_resolveBrowserslistVersions'
+import {_resolveBrowserTarget} from './_resolveBrowserTarget'
+import {_resolveNodeTarget} from './_resolveNodeTarget'
+
+export async function _resolveBuildContext(options: {
+  config?: PkgConfigOptions
+  cwd: string
+  pkg: _PackageJSON
+  tsconfig: string
+}): Promise<_BuildContext> {
+  const {config, cwd, pkg, tsconfig: tsconfigPath} = options
+
+  const tsconfig = await _loadTSConfig({cwd, tsconfigPath})
+
+  const targetVersions = _resolveBrowserslistVersions(pkg.browserslist || _DEFAULTS.browserslist)
+
+  const srcPath = path.resolve(cwd, config?.src || 'src')
+  const distPath = path.resolve(cwd, config?.dist || 'dist')
+
+  const nodeTarget = _resolveNodeTarget(targetVersions)
+  const webTarget = _resolveBrowserTarget(targetVersions)
+
+  if (!nodeTarget) {
+    throw new Error('no matching `node` target')
+  }
+
+  if (!webTarget) {
+    throw new Error('no matching `web` target')
+  }
+
+  const target: Record<PkgRuntime, string[]> = {
+    '*': webTarget.concat(nodeTarget),
+    browser: webTarget,
+    node: nodeTarget,
+  }
+
+  const parsedExports = _parseExports({pkg}).reduce<PkgExports>((acc, x) => {
+    const {_path: exportPath, ...exportEntry} = x
+
+    return {...acc, [exportPath]: exportEntry}
+  }, {})
+
+  const exports = _resolveConfigProperty(config?.exports, parsedExports)
+
+  const parsedExternal = [
+    ...(pkg.dependencies ? Object.keys(pkg.dependencies) : []),
+    ...(pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : []),
+  ]
+
+  const external = _resolveConfigProperty(config?.external, parsedExternal)
+
+  const ctx: _BuildContext = {
+    config,
+    cwd,
+    dist: path.relative(cwd, distPath),
+    exports,
+    external,
+    files: [],
+    logger: {
+      /* 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 */
+    },
+    pkg,
+    src: path.relative(cwd, srcPath),
+    runtime: config?.runtime ?? '*',
+    target,
+    ts: {
+      config: tsconfig,
+      configPath: tsconfigPath,
+    },
+  }
+
+  return ctx
+}

package/src/node/_resolveBuildTasks.ts

@@ -0,0 +1,129 @@
+import fs from 'fs'
+import path from 'path'
+import {PkgExport, PkgFormat, PkgRuntime, _BuildContext} from './_core'
+import {_BuildTask, _DtsTask, _RollupTask, _RollupTaskEntry} from './_tasks'
+
+/** @internal */
+export function _resolveBuildTasks(ctx: _BuildContext): _BuildTask[] {
+  const {cwd, pkg, target} = ctx
+
+  const tasks: _BuildTask[] = []
+
+  const exports = Object.entries(ctx.exports || {}).map(
+    ([_path, exp]) => ({_path, ...exp} as PkgExport & {_path: string})
+  )
+
+  const dtsTasks: Record<string, _DtsTask> = {}
+  const rollupTasks: Record<string, _RollupTask> = {}
+
+  function _addRollupTaskEntry(format: PkgFormat, runtime: PkgRuntime, entry: _RollupTaskEntry) {
+    const buildId = `${format}:${runtime}`
+
+    if (!rollupTasks[buildId]) {
+      rollupTasks[buildId] = {
+        type: 'build:js',
+        buildId,
+        entries: [entry],
+        runtime,
+        format,
+        target: target[runtime],
+      }
+    } else {
+      rollupTasks[buildId].entries.push(entry)
+    }
+  }
+
+  // Parse `dts` tasks
+  for (const exp of exports) {
+    const importId = path.join(pkg.name, exp._path)
+
+    if (exp.types) {
+      if (!dtsTasks[importId]) {
+        dtsTasks[importId] = {
+          type: 'build:dts',
+          importId,
+          exportPath: exp._path,
+          sourcePath: exp.source,
+          targetPath: exp.types,
+        }
+      }
+    }
+  }
+
+  // Parse rollup:commonjs:* tasks
+  for (const exp of exports) {
+    const output = exp.require
+
+    if (!output) continue
+
+    _addRollupTaskEntry('commonjs', ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output,
+    })
+  }
+
+  // Parse rollup:commonjs:browser tasks
+  for (const exp of exports) {
+    const output = exp.browser?.require
+
+    if (!output) continue
+
+    _addRollupTaskEntry('commonjs', 'browser', {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output,
+    })
+  }
+
+  // Parse rollup:esm:* tasks
+  for (const exp of exports) {
+    const output = exp.import
+
+    if (!output) continue
+
+    _addRollupTaskEntry('esm', ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output,
+    })
+  }
+
+  // Parse rollup:esm:browser tasks
+  for (const exp of exports) {
+    const output = exp.browser?.import
+
+    if (!output) continue
+
+    _addRollupTaskEntry('esm', 'browser', {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output,
+    })
+  }
+
+  tasks.push(...Object.values(dtsTasks))
+  tasks.push(...Object.values(rollupTasks))
+
+  // Parse rollup:esm:browser tasks
+  for (const exp of exports) {
+    if (exp._exported && exp._path !== '.') {
+      const relativeTargetPath = (exp.browser?.import || exp.import || '').replace(/\.[^/.]+$/, '')
+
+      if (relativeTargetPath) {
+        fs.writeFileSync(
+          path.resolve(cwd, `${exp._path}.js`),
+          [
+            `// AUTO-GENERATED – DO NOT EDIT`,
+            ``,
+            // `export {default} from '${relativeTargetPath}'`,
+            `export * from '${relativeTargetPath}'`,
+            ``,
+          ].join('\n')
+        )
+      }
+    }
+  }
+
+  return tasks
+}

package/src/{build/_parseNodeTarget.ts → node/_resolveNodeTarget.ts}

@@ -1,6 +1,6 @@
-import {_PackageTargetVersions} from './_parseBrowserslistVersions'
+import {_PackageTargetVersions} from './_resolveBrowserslistVersions'
 
-export function _parseNodeTarget(versions: _PackageTargetVersions): string[] | undefined {
+export function _resolveNodeTarget(versions: _PackageTargetVersions): string[] | undefined {
   const target: string[] = []
 
   if (versions.node.length) {

package/src/node/_resolveWatchTasks.ts

@@ -0,0 +1,129 @@
+import fs from 'fs'
+import path from 'path'
+import {PkgExport, PkgFormat, PkgRuntime, _BuildContext} from './_core'
+import {_WatchTask, _DtsWatchTask, _RollupWatchTask, _RollupTaskEntry} from './_tasks'
+
+/** @internal */
+export function _resolveWatchTasks(ctx: _BuildContext): _WatchTask[] {
+  const {cwd, pkg, target} = ctx
+
+  const tasks: _WatchTask[] = []
+
+  const exports = Object.entries(ctx.exports || {}).map(
+    ([_path, exp]) => ({_path, ...exp} as PkgExport & {_path: string})
+  )
+
+  const dtsTasks: Record<string, _DtsWatchTask> = {}
+  const rollupTasks: Record<string, _RollupWatchTask> = {}
+
+  function _addRollupTaskEntry(format: PkgFormat, runtime: PkgRuntime, entry: _RollupTaskEntry) {
+    const buildId = `${format}:${runtime}`
+
+    if (!rollupTasks[buildId]) {
+      rollupTasks[buildId] = {
+        type: 'watch:js',
+        buildId,
+        entries: [entry],
+        runtime,
+        format,
+        target: target[runtime],
+      }
+    } else {
+      rollupTasks[buildId].entries.push(entry)
+    }
+  }
+
+  // Parse `dts` tasks
+  for (const exp of exports) {
+    const importId = path.join(pkg.name, exp._path)
+
+    if (exp.types) {
+      if (!dtsTasks[importId]) {
+        dtsTasks[importId] = {
+          type: 'watch:dts',
+          importId,
+          exportPath: exp._path,
+          sourcePath: exp.source,
+          targetPath: exp.types,
+        }
+      }
+    }
+  }
+
+  // Parse rollup:commonjs:* tasks
+  for (const exp of exports) {
+    const output = exp.require
+
+    if (!output) continue
+
+    _addRollupTaskEntry('commonjs', ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output,
+    })
+  }
+
+  // Parse rollup:commonjs:browser tasks
+  for (const exp of exports) {
+    const output = exp.browser?.require
+
+    if (!output) continue
+
+    _addRollupTaskEntry('commonjs', 'browser', {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output,
+    })
+  }
+
+  // Parse rollup:esm:* tasks
+  for (const exp of exports) {
+    const output = exp.import
+
+    if (!output) continue
+
+    _addRollupTaskEntry('esm', ctx.runtime, {
+      path: exp._path,
+      source: exp.source,
+      output,
+    })
+  }
+
+  // Parse rollup:esm:browser tasks
+  for (const exp of exports) {
+    const output = exp.browser?.import
+
+    if (!output) continue
+
+    _addRollupTaskEntry('esm', 'browser', {
+      path: exp._path,
+      source: exp.browser?.source || exp.source,
+      output,
+    })
+  }
+
+  tasks.push(...Object.values(dtsTasks))
+  tasks.push(...Object.values(rollupTasks))
+
+  // Parse rollup:esm:browser tasks
+  for (const exp of exports) {
+    if (exp._exported && exp._path !== '.') {
+      const relativeTargetPath = (exp.browser?.import || exp.import || '').replace(/\.[^/.]+$/, '')
+
+      if (relativeTargetPath) {
+        fs.writeFileSync(
+          path.resolve(cwd, `${exp._path}.js`),
+          [
+            `// AUTO-GENERATED – DO NOT EDIT`,
+            ``,
+            // `export {default} from '${relativeTargetPath}'`,
+            `export * from '${relativeTargetPath}'`,
+            ``,
+          ].join('\n')
+        )
+      }
+    }
+  }
+
+  return tasks
+}

package/src/node/_spinner.ts

@@ -0,0 +1,26 @@
+import chalk from 'chalk'
+import ora from 'ora'
+
+export function _spinner(msg: string): {complete: () => void; error: () => void} {
+  const startTime = Date.now()
+
+  const spinner = ora({
+    spinner: 'dots',
+    text: `${chalk.yellow('run ')} ${msg}`,
+  })
+
+  spinner.color = 'yellow'
+
+  spinner.start()
+
+  return {
+    complete: () => {
+      spinner.color = 'green'
+      spinner.succeed(`${chalk.green('ok  ')} ${msg} ${chalk.gray(`${Date.now() - startTime}ms`)}`)
+    },
+    error: () => {
+      spinner.color = 'red'
+      spinner.fail(chalk.red(`${msg} failed ${chalk.gray(`${Date.now() - startTime}ms`)}`))
+    },
+  }
+}

package/src/node/_tasks/_types.ts

@@ -0,0 +1,57 @@
+import {RollupWatcherEvent} from 'rollup'
+import {Observable} from 'rxjs'
+import {PkgRuntime, _BuildContext} from '../_core'
+import {_DtsResult, _DtsTask, _DtsWatchTask} from './dts'
+
+/** @internal */
+export interface _RollupTaskEntry {
+  path: string
+  source: string
+  output: string
+}
+
+/** @internal */
+export interface _RollupTask {
+  type: 'build:js'
+  buildId: string
+  entries: _RollupTaskEntry[]
+  runtime: PkgRuntime
+  format: 'commonjs' | 'esm'
+  target: string[]
+}
+
+/** @internal */
+export interface _RollupWatchTask {
+  type: 'watch:js'
+  buildId: string
+  entries: _RollupTaskEntry[]
+  runtime: PkgRuntime
+  format: 'commonjs' | 'esm'
+  target: string[]
+}
+
+/** @internal */
+export type _BuildTask = _DtsTask | _RollupTask
+
+/** @internal */
+export type _WatchTask = _DtsWatchTask | _RollupWatchTask
+
+/** @internal */
+export type _TaskHandler<Task, Result = void> = {
+  name: (ctx: _BuildContext, task: Task) => string
+  exec: (ctx: _BuildContext, task: Task) => Observable<Result>
+  complete: (ctx: _BuildContext, task: Task, result: Result) => void
+  error: (ctx: _BuildContext, task: Task, error: unknown) => void
+}
+
+/** @internal */
+export interface _BuildTaskHandlers {
+  'build:dts': _TaskHandler<_DtsTask, _DtsResult>
+  'build:js': _TaskHandler<_RollupTask>
+}
+
+/** @internal */
+export interface _WatchTaskHandlers {
+  'watch:dts': _TaskHandler<_DtsWatchTask, _DtsResult>
+  'watch:js': _TaskHandler<_RollupWatchTask, RollupWatcherEvent>
+}

package/src/node/_tasks/dts/_DtsError.ts

@@ -0,0 +1,11 @@
+import {ExtractorMessage} from '@microsoft/api-extractor'
+
+/** @internal */
+export class _DtsError extends Error {
+  messages: ExtractorMessage[]
+
+  constructor(message: string, messages: ExtractorMessage[]) {
+    super(message)
+    this.messages = messages
+  }
+}

package/src/{build/tasks → node/_tasks}/dts/_buildTypes.ts

@@ -2,7 +2,6 @@
 
 import path from 'path'
 import ts from 'typescript'
-import {_loadTSConfig} from './_loadTSConfig'
 
 export const formatHost: ts.FormatDiagnosticsHost = {
   getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
@@ -10,38 +9,51 @@ export const formatHost: ts.FormatDiagnosticsHost = {
   getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase(),
 }
 
-/**
- * @internal
- */
+/** @internal */
 export async function _buildTypes(options: {
   cwd: string
   outDir: string
   sourcePath: string
-  tsconfigPath: string
+  tsconfig: ts.ParsedCommandLine
 }): Promise<{path: string}> {
-  const {cwd, outDir, sourcePath, tsconfigPath} = options
-
-  const config = await _loadTSConfig({cwd, tsconfigPath})
+  const {cwd, outDir, sourcePath, tsconfig} = options
 
   const compilerOptions: ts.CompilerOptions = {
-    ...config.options,
+    ...tsconfig.options,
     declaration: true,
+    declarationDir: outDir,
     emitDeclarationOnly: true,
+    noEmit: false,
     outDir,
   }
 
-  const program = ts.createProgram([path.resolve(cwd, sourcePath)], compilerOptions)
+  const rootDir =
+    path.relative(
+      cwd,
+      compilerOptions.rootDir
+        ? path.resolve(cwd, compilerOptions.rootDir)
+        : path.dirname(path.resolve(cwd, sourcePath))
+    ) || '.'
+
+  const program = ts.createProgram(tsconfig.fileNames, compilerOptions)
+
+  const sourceFiles = program.getSourceFiles()
+  const sourceFile = sourceFiles.find((f) => f.fileName === path.resolve(cwd, sourcePath))
+
+  if (!sourceFile) {
+    throw new Error(`source file not found: ${sourcePath}`)
+  }
 
   const emitResult = program.emit()
 
   const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics)
 
   allDiagnostics.forEach((diagnostic) => {
-    if (diagnostic.file) {
-      const {line, character} = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start!)
+    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}): ${message}`)
+      console.log(`${diagnostic.file.fileName} ${line + 1}:${character + 1}\n${message}`)
     } else {
       console.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'))
     }
@@ -57,7 +69,9 @@ export async function _buildTypes(options: {
     }
   }
 
-  return {
-    path: path.resolve(outDir, sourcePath.replace(/\.ts$/, '.d.ts')),
-  }
+  const typesPath = path
+    .resolve(outDir, path.relative(rootDir, path.resolve(cwd, sourcePath)))
+    .replace(/\.[jt]sx?$/, '.d.ts')
+
+  return {path: typesPath}
 }

package/src/node/_tasks/dts/_createApiExtractorConfig.ts

@@ -0,0 +1,41 @@
+import path from 'path'
+import {IConfigFile, IExtractorMessagesConfig} from '@microsoft/api-extractor'
+
+export function _createApiExtractorConfig(options: {
+  distPath: string
+  exportPath: string
+  filePath: string
+  messages: IExtractorMessagesConfig
+  projectPath: string
+  sourcePath: string
+  tsconfigPath: string
+}): IConfigFile {
+  const {distPath, exportPath, filePath, messages, projectPath, sourcePath, tsconfigPath} = options
+
+  return {
+    apiReport: {
+      enabled: false,
+      reportFileName: '<unscopedPackageName>.api.md',
+    },
+    // bundledPackages: [],
+    compiler: {
+      tsconfigFilePath: tsconfigPath,
+    },
+    docModel: {
+      enabled: false,
+      apiJsonFilePath: path.resolve(distPath, `${exportPath}.api.json`),
+    },
+    dtsRollup: {
+      enabled: true,
+      untrimmedFilePath: path.resolve(distPath, filePath),
+      // betaTrimmedFilePath: path.resolve(distPath, filePath.replace('.d.ts', '-beta.d.ts')),
+      // publicTrimmedFilePath: path.resolve(distPath, filePath.replace('.d.ts', '-public.d.ts')),
+    },
+    tsdocMetadata: {
+      enabled: false,
+    },
+    messages,
+    mainEntryPointFilePath: sourcePath,
+    projectFolder: projectPath,
+  }
+}