@sanity/pkg-utils 1.2.0 → 1.4.0

package/src/node/_resolveBrowserTarget.ts

@@ -0,0 +1,35 @@
+import {_PackageTargetVersions} from './_resolveBrowserslistVersions'
+
+export function _resolveBrowserTarget(versions: _PackageTargetVersions): string[] | undefined {
+  const target: string[] = []
+
+  if (versions.chrome.length) {
+    target.push(`chrome${versions.chrome[0]}`)
+  }
+
+  if (versions.ff.length) {
+    target.push(`firefox${versions.ff[0]}`)
+  }
+
+  if (versions.edge.length) {
+    target.push(`edge${versions.edge[0]}`)
+  }
+
+  if (versions.iosSaf.length) {
+    target.push(`ios${versions.iosSaf[0]}`)
+  }
+
+  if (versions.saf.length) {
+    target.push(`safari${versions.saf[0]}`)
+  }
+
+  if (versions.opera.length) {
+    target.push(`opera${versions.opera[0]}`)
+  }
+
+  if (target.length === 0) {
+    return undefined
+  }
+
+  return target
+}

package/src/node/_resolveBrowserslistVersions.ts

@@ -0,0 +1,60 @@
+import browserslist from 'browserslist'
+
+export interface _PackageTargetVersions {
+  chrome: string[]
+  ff: string[]
+  edge: string[]
+  iosSaf: string[]
+  saf: string[]
+  opera: string[]
+  node: string[]
+}
+
+function _sortAsNumber(a: string, b: string) {
+  const aVersion = Number(a)
+  const bVersion = Number(b)
+
+  return aVersion - bVersion
+}
+
+export function _resolveBrowserslistVersions(query: string[]): _PackageTargetVersions {
+  const result = browserslist(query)
+
+  const entries = result.map((key) => {
+    const [name, version] = key.split(' ')
+
+    return {name, version: version.split('-')[0].split('.')[0]}
+  })
+
+  const andChr = entries.filter((b) => b.name === 'and_chr')
+  const andFf = entries.filter((b) => b.name === 'and_ff')
+  const chrome = entries.filter((b) => b.name === 'chrome')
+  const edge = entries.filter((b) => b.name === 'edge')
+  const ff = entries.filter((b) => b.name === 'firefox')
+  const iosSaf = entries.filter((b) => b.name === 'ios_saf')
+  const saf = entries.filter((b) => b.name === 'safari')
+  const opera = entries.filter((b) => b.name === 'opera')
+  const node = entries.filter((b) => b.name === 'node')
+
+  // versions
+  const versions: _PackageTargetVersions = {
+    chrome: andChr.concat(chrome).map((b) => b.version),
+    ff: andFf.concat(ff).map((b) => b.version),
+    edge: edge.map((b) => b.version),
+    iosSaf: iosSaf.map((b) => b.version),
+    saf: saf.map((b) => b.version),
+    opera: opera.map((b) => b.version),
+    node: node.map((b) => b.version),
+  }
+
+  // sort
+  versions.chrome.sort(_sortAsNumber)
+  versions.ff.sort(_sortAsNumber)
+  versions.edge.sort(_sortAsNumber)
+  versions.iosSaf.sort(_sortAsNumber)
+  versions.saf.sort(_sortAsNumber)
+  versions.opera.sort(_sortAsNumber)
+  versions.node.sort(_sortAsNumber)
+
+  return versions
+}

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,
+          source: exp.source,
+          output: 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/_resolveNodeTarget.ts

@@ -0,0 +1,15 @@
+import {_PackageTargetVersions} from './_resolveBrowserslistVersions'
+
+export function _resolveNodeTarget(versions: _PackageTargetVersions): string[] | undefined {
+  const target: string[] = []
+
+  if (versions.node.length) {
+    target.push(`node${versions.node[0]}`)
+  }
+
+  if (target.length === 0) {
+    return undefined
+  }
+
+  return target
+}

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,
+          source: exp.source,
+          output: 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,43 @@ 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 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 +61,7 @@ export async function _buildTypes(options: {
     }
   }
 
-  return {
-    path: path.resolve(outDir, sourcePath.replace(/\.ts$/, '.d.ts')),
-  }
+  const typesPath = path.resolve(outDir, sourcePath.replace(/\.ts$/, '.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,
+  }
+}