@sanity/pkg-utils 1.2.0 → 1.4.0

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

@@ -2,18 +2,14 @@ import {readFile} from 'fs/promises'
 import {TSDocConfigFile} from '@microsoft/tsdoc-config'
 import {parse} from 'jsonc-parser'
 
-/**
- * @public
- */
+/** @public */
 export interface TSDocCustomTag {
   name: string
   syntaxKind: 'block' | 'modifier'
   allowMultiple?: boolean
 }
 
-/**
- * @internal
- */
+/** @internal */
 export async function _createTSDocConfig(opts: {
   customTags: TSDocCustomTag[]
 }): Promise<TSDocConfigFile | undefined> {

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

@@ -0,0 +1,46 @@
+import path from 'path'
+import {promisify} from 'util'
+import rimrafCallback from 'rimraf'
+import {_BuildContext} from '../../_core'
+import {_buildTypes} from './_buildTypes'
+import {_DtsError} from './_DtsError'
+import {_extractTypes} from './_extractTypes'
+import {_DtsResult, _DtsTask, _DtsWatchTask} from './_types'
+
+const rimraf = promisify(rimrafCallback)
+
+export async function _doExtract(
+  ctx: _BuildContext,
+  task: _DtsTask | _DtsWatchTask
+): Promise<_DtsResult> {
+  const {config, cwd, dist, files, ts} = ctx
+
+  if (!ts.config || !ts.configPath) return {type: 'dts', messages: []}
+
+  const sourcePath = task.source
+  const exportPath = task.exportPath === '.' ? './index' : task.exportPath
+  const distPath = path.resolve(cwd, dist)
+  const outDir = ts.config?.options.outDir || path.resolve(cwd, dist)
+
+  const types = await _buildTypes({cwd, outDir, sourcePath, tsconfig: ts.config})
+
+  const {messages} = await _extractTypes({
+    cwd,
+    exportPath,
+    files,
+    filePath: path.relative(distPath, path.resolve(cwd, task.output)),
+    projectPath: cwd,
+    rules: config?.extract?.rules,
+    sourcePath: types.path,
+    tsconfigPath: path.resolve(cwd, ts.configPath),
+    distPath,
+  })
+
+  await rimraf(outDir)
+
+  if (messages.some((msg) => msg.logLevel === 'error')) {
+    throw new _DtsError('encountered errors when extracting types', messages)
+  }
+
+  return {type: 'dts', messages}
+}

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

@@ -0,0 +1,38 @@
+import chalk from 'chalk'
+import {Observable} from 'rxjs'
+import {_printExtractMessages} from '../../_printExtractMessages'
+import {_TaskHandler} from '../_types'
+import {_doExtract} from './_doExtract'
+import {_DtsError} from './_DtsError'
+import {_DtsResult, _DtsTask} from './_types'
+
+/** @internal */
+export const _dtsTask: _TaskHandler<_DtsTask, _DtsResult> = {
+  name: (_ctx, task) =>
+    [
+      `build type definitions`,
+      `       ${chalk.blue(task.importId)}: ${task.source} -> ${task.output}`,
+    ].join('\n'),
+  exec: (ctx, task) => {
+    return new Observable((observer) => {
+      _doExtract(ctx, task)
+        .then((result) => {
+          observer.next(result)
+          observer.complete()
+        })
+        .catch(observer.error)
+    })
+  },
+  complete: (ctx, _task, result) => {
+    _printExtractMessages(ctx, result.messages)
+  },
+  error: (ctx, _task, err) => {
+    const {logger} = ctx
+
+    if (err instanceof _DtsError) {
+      _printExtractMessages(ctx, err.messages)
+    } else if (err instanceof Error) {
+      logger.error(err)
+    }
+  },
+}

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

@@ -0,0 +1,43 @@
+import chalk from 'chalk'
+import {Observable} from 'rxjs'
+import {_printExtractMessages} from '../../_printExtractMessages'
+import {_TaskHandler} from '../_types'
+import {_doExtract} from './_doExtract'
+import {_DtsError} from './_DtsError'
+import {_DtsResult, _DtsWatchTask} from './_types'
+
+/** @internal */
+export const _dtsWatchTask: _TaskHandler<_DtsWatchTask, _DtsResult> = {
+  name: (_ctx, task) =>
+    [
+      `build type definitions`,
+      `       ${chalk.blue(task.importId)}: ${task.source} -> ${task.output}`,
+    ].join('\n'),
+  exec: (ctx, task) => {
+    return new Observable((observer) => {
+      _doExtract(ctx, task)
+        .then((result) => {
+          observer.next(result)
+          observer.complete()
+        })
+        .catch(observer.error)
+    })
+  },
+  complete: (ctx, _task, result) => {
+    const {logger} = ctx
+
+    _printExtractMessages(ctx, result.messages)
+
+    logger.warn('watching typescript definitions is currently not supported')
+    logger.log()
+  },
+  error: (ctx, _task, err) => {
+    const {logger} = ctx
+
+    if (err instanceof _DtsError) {
+      _printExtractMessages(ctx, err.messages)
+    } else if (err instanceof Error) {
+      logger.error(err)
+    }
+  },
+}

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

@@ -0,0 +1,161 @@
+import fs from 'fs/promises'
+import path from 'path'
+import {
+  Extractor,
+  ExtractorConfig,
+  ExtractorLogLevel,
+  ExtractorMessage,
+  ExtractorResult,
+  IExtractorMessagesConfig,
+} from '@microsoft/api-extractor'
+import prettier from 'prettier'
+import {PkgRuleLevel, PkgConfigOptions, _BuildFile} from '../../_core'
+import {_createApiExtractorConfig} from './_createApiExtractorConfig'
+import {_createTSDocConfig} from './_createTSDocConfig'
+
+const _LOG_LEVELS: Record<PkgRuleLevel, ExtractorLogLevel> = {
+  error: 'error' as ExtractorLogLevel.Error,
+  info: 'info' as ExtractorLogLevel.Info,
+  off: 'none' as ExtractorLogLevel.None,
+  warn: 'warning' as ExtractorLogLevel.Warning,
+}
+
+export async function _extractTypes(options: {
+  cwd: string
+  distPath: string
+  exportPath: string
+  files: _BuildFile[]
+  filePath: string
+  projectPath: string
+  rules?: NonNullable<PkgConfigOptions['extract']>['rules']
+  sourcePath: string
+  tsconfigPath: string
+}): Promise<{extractorResult: ExtractorResult; messages: ExtractorMessage[]}> {
+  const {distPath, exportPath, files, filePath, projectPath, rules, sourcePath, tsconfigPath} =
+    options
+
+  const tsdocConfigFile = await _createTSDocConfig({
+    customTags: [],
+  })
+
+  function _ruleToLogLevel(
+    key: keyof NonNullable<NonNullable<PkgConfigOptions['extract']>['rules']>,
+    defaultLevel?: ExtractorLogLevel
+  ) {
+    const r = rules?.[key]
+
+    return (r ? _LOG_LEVELS[r] : defaultLevel || 'warning') as ExtractorLogLevel
+  }
+
+  const messagesConfig: IExtractorMessagesConfig = {
+    compilerMessageReporting: {
+      default: {
+        logLevel: 'warning' as ExtractorLogLevel,
+      },
+    },
+
+    extractorMessageReporting: {
+      default: {
+        logLevel: 'warning' as ExtractorLogLevel,
+        addToApiReportFile: false,
+      },
+
+      'ae-forgotten-export': {
+        logLevel: _ruleToLogLevel('ae-forgotten-export', 'error' as ExtractorLogLevel),
+        addToApiReportFile: false,
+      },
+
+      'ae-incompatible-release-tags': {
+        logLevel: _ruleToLogLevel('ae-incompatible-release-tags', 'error' as ExtractorLogLevel),
+        addToApiReportFile: false,
+      },
+
+      'ae-internal-missing-underscore': {
+        logLevel: _ruleToLogLevel('ae-internal-missing-underscore'),
+        addToApiReportFile: false,
+      },
+
+      'ae-missing-release-tag': {
+        logLevel: _ruleToLogLevel('ae-missing-release-tag', 'error' as ExtractorLogLevel),
+        addToApiReportFile: false,
+      },
+
+      'ae-wrong-input-file-type': {
+        logLevel: 'none' as ExtractorLogLevel,
+        addToApiReportFile: false,
+      },
+    },
+
+    tsdocMessageReporting: {
+      default: {
+        logLevel: 'warning' as ExtractorLogLevel,
+        addToApiReportFile: false,
+      },
+
+      // 'tsdoc-link-tag-unescaped-text': {
+      //   logLevel: 'warning' as ExtractorLogLevel,
+      //   addToApiReportFile: false
+      // },
+
+      // 'tsdoc-unsupported-tag': {
+      //   logLevel: 'none' as ExtractorLogLevel,
+      //   addToApiReportFile: false
+      // },
+
+      // 'tsdoc-undefined-tag': {
+      //   logLevel: 'none' as ExtractorLogLevel,
+      //   addToApiReportFile: false
+      // }
+    },
+  }
+
+  const extractorConfig: ExtractorConfig = ExtractorConfig.prepare({
+    configObject: _createApiExtractorConfig({
+      distPath,
+      exportPath,
+      filePath,
+      messages: messagesConfig,
+      projectPath,
+      sourcePath,
+      tsconfigPath,
+    }),
+    configObjectFullPath: undefined,
+    tsdocConfigFile,
+    packageJsonFullPath: path.resolve(projectPath, 'package.json'),
+  })
+
+  const messages: ExtractorMessage[] = []
+
+  // Invoke API Extractor
+  const extractorResult = Extractor.invoke(extractorConfig, {
+    // Equivalent to the "--local" command-line parameter
+    localBuild: true,
+    // Equivalent to the "--verbose" command-line parameter
+    showVerboseMessages: true,
+    // handle messages
+    messageCallback(message: ExtractorMessage) {
+      messages.push(message)
+      message.handled = true
+    },
+  })
+
+  const typesPath = path.resolve(distPath, `${exportPath}.d.ts`)
+  const typesBuf = await fs.readFile(typesPath)
+  const prettierConfig = await prettier.resolveConfig(typesPath)
+
+  await fs.writeFile(
+    typesPath,
+    prettier.format(typesBuf.toString(), {
+      ...prettierConfig,
+      filepath: typesPath,
+    })
+  )
+
+  // Add to `files` in context
+  files.push({
+    type: 'types',
+    path: typesPath,
+  })
+
+  return {extractorResult, messages}
+}

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

@@ -0,0 +1,25 @@
+import {ExtractorMessage} from '@microsoft/api-extractor'
+
+/** @internal */
+export interface _DtsWatchTask {
+  type: 'watch:dts'
+  exportPath: string
+  importId: string
+  source: string
+  output: string
+}
+
+/** @internal */
+export interface _DtsTask {
+  type: 'build:dts'
+  exportPath: string
+  importId: string
+  source: string
+  output: string
+}
+
+/** @internal */
+export interface _DtsResult {
+  type: 'dts'
+  messages: ExtractorMessage[]
+}

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

@@ -0,0 +1,3 @@
+export * from './_dtsTask'
+export * from './_dtsWatchTask'
+export * from './_types'

package/src/node/_tasks/index.ts

@@ -0,0 +1,19 @@
+import {_BuildTaskHandlers, _WatchTaskHandlers} from './_types'
+import {_dtsTask, _dtsWatchTask} from './dts'
+import {_rollupTask, _rollupWatchTask} from './rollup'
+
+export * from './_types'
+export * from './dts'
+export * from './rollup'
+
+/** @internal */
+export const _buildTaskHandlers: _BuildTaskHandlers = {
+  'build:dts': _dtsTask,
+  'build:js': _rollupTask,
+}
+
+/** @internal */
+export const _watchTaskHandlers: _WatchTaskHandlers = {
+  'watch:dts': _dtsWatchTask,
+  'watch:js': _rollupWatchTask,
+}

package/src/node/_tasks/rollup/_resolveRollupConfig.ts

@@ -0,0 +1,132 @@
+import path from 'path'
+import alias from '@rollup/plugin-alias'
+import commonjs from '@rollup/plugin-commonjs'
+import json from '@rollup/plugin-json'
+import {nodeResolve} from '@rollup/plugin-node-resolve'
+import replace from '@rollup/plugin-replace'
+import {InputOptions, OutputOptions} from 'rollup'
+import esbuild from 'rollup-plugin-esbuild'
+import {_BuildContext} from '../../_core'
+import {_RollupTask, _RollupWatchTask} from '../_types'
+
+export interface _RollupConfig {
+  inputOptions: InputOptions
+  outputOptions: OutputOptions
+}
+
+/** @internal */
+export function _resolveRollupConfig(
+  ctx: _BuildContext,
+  buildTask: _RollupTask | _RollupWatchTask
+): _RollupConfig {
+  const {format, runtime, target} = buildTask
+  const {config, cwd, external, dist: outDir, pkg, ts} = ctx
+  const outputExt = format === 'commonjs' ? '.cjs' : pkg.type === 'module' ? '.mjs' : '.js'
+
+  const pathAliases = Object.fromEntries(
+    Object.entries(ts.config?.options.paths || {}).map(([key, val]) => {
+      return [key, path.resolve(cwd, ts.config?.options.baseUrl || '.', val[0])]
+    })
+  )
+
+  const entries = buildTask.entries.map((entry) => {
+    return {
+      ...entry,
+      name: path.relative(outDir, entry.output).replace(/\.[^/.]+$/, ''),
+    }
+  }, {})
+
+  return {
+    inputOptions: {
+      context: cwd,
+
+      external: (id) => {
+        const idParts = id.split('/')
+
+        const name = idParts[0].startsWith('@') ? `${idParts[0]}/${idParts[1]}` : idParts[0]
+
+        if (name && external.includes(name)) {
+          return true
+        }
+
+        return false
+      },
+
+      input: entries.reduce<{[entryAlias: string]: string}>((acc, entry) => {
+        return {...acc, [entry.name]: entry.source}
+      }, {}),
+
+      onwarn(warning, rollupWarn) {
+        if (!warning.code || !['CIRCULAR_DEPENDENCY'].includes(warning.code)) {
+          rollupWarn(warning)
+        }
+      },
+
+      plugins: [
+        replace({
+          preventAssignment: true,
+          values: {
+            ...(pkg.name === '@sanity/pkg-utils'
+              ? {}
+              : {
+                  'process.env.PKG_FILE_PATH': (arg) => {
+                    const sourcePath = './' + path.relative(cwd, arg)
+                    const entry = entries.find((e) => e.source === sourcePath)
+
+                    if (!entry) {
+                      throw new Error(`could not find source entry: ${sourcePath}`)
+                    }
+
+                    return JSON.stringify(
+                      path.relative(cwd, path.resolve(outDir, entry.name + outputExt))
+                    )
+                  },
+                  'process.env.PKG_FORMAT': JSON.stringify(format),
+                  'process.env.PKG_RUNTIME': JSON.stringify(runtime),
+                  'process.env.PKG_VERSION': JSON.stringify(process.env.PKG_VERSION || pkg.version),
+                }),
+          },
+        }),
+        alias({
+          entries: {...pathAliases},
+        }),
+        nodeResolve({
+          // mainFields: ['module', 'jsnext', 'main'],
+          browser: runtime === 'browser',
+          // exportConditions: [runtime === 'node' ? 'node' : 'browser'],
+          extensions: ['.cjs', '.mjs', '.js', '.jsx', '.json', '.node'],
+          preferBuiltins: true, // runtime === 'node',
+        }),
+        commonjs({
+          esmExternals: false,
+          extensions: ['.js'],
+          // include: /\/node_modules\//,
+          // requireReturnsDefault: 'namespace',
+        }),
+        json(),
+        esbuild({
+          minify: config?.minify ?? true,
+          jsx: 'transform', // default, or 'preserve'
+          jsxFactory: 'React.createElement',
+          jsxFragment: 'React.Fragment',
+          target,
+          tsconfig: ctx.ts.configPath || 'tsconfig.json', // 'tsconfig.json', // default
+        }),
+      ],
+
+      treeshake: {
+        propertyReadSideEffects: false,
+      },
+    },
+    outputOptions: {
+      chunkFileNames: () => `_[name]-[hash]${outputExt}`,
+      dir: outDir,
+      entryFileNames: () => `[name]${outputExt}`,
+      format,
+      // esModule: true,
+      exports: 'auto',
+      // freeze: true,
+      sourcemap: config?.sourcemap ?? true,
+    },
+  }
+}

package/src/node/_tasks/rollup/_rollupTask.ts

@@ -0,0 +1,71 @@
+/* eslint-disable no-console */
+
+import path from 'path'
+import chalk from 'chalk'
+import {rollup} from 'rollup'
+import {Observable} from 'rxjs'
+import {_BuildContext} from '../../_core'
+import {_RollupTask, _TaskHandler} from '../_types'
+import {_resolveRollupConfig} from './_resolveRollupConfig'
+
+/** @internal */
+export const _rollupTask: _TaskHandler<_RollupTask> = {
+  name: (ctx, task) =>
+    `build javascript files (target ${task.target.join(' + ')}, format ${
+      task.format
+    })\n       ${task.entries
+      .map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`)
+      .join('\n       ')}`,
+  exec: (ctx, task) => {
+    return new Observable((observer) => {
+      _execPromise(ctx, task).then((result) => {
+        observer.next(result)
+        observer.complete()
+      }, observer.error)
+    })
+  },
+  complete: () => {
+    //
+  },
+  error: (_ctx, _task, err) => {
+    if (err instanceof Error) {
+      console.log(err)
+    }
+  },
+}
+
+async function _execPromise(ctx: _BuildContext, task: _RollupTask) {
+  const {files, dist: outDir} = ctx
+
+  const {inputOptions, outputOptions} = _resolveRollupConfig(ctx, task)
+
+  // Create bundle
+  const bundle = await rollup(inputOptions)
+
+  // an array of file names this bundle depends on
+  // console.log(bundle.watchFiles)
+
+  // 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()
+}

package/src/node/_tasks/rollup/_rollupWatchTask.ts

@@ -0,0 +1,78 @@
+import path from 'path'
+import chalk from 'chalk'
+import {RollupWatcherEvent, RollupWatchOptions, watch as rollupWatch} from 'rollup'
+import {Observable} from 'rxjs'
+import {_RollupWatchTask, _TaskHandler} from '../_types'
+import {_resolveRollupConfig} from './_resolveRollupConfig'
+
+/** @internal */
+export const _rollupWatchTask: _TaskHandler<_RollupWatchTask, RollupWatcherEvent> = {
+  name: (ctx, task) =>
+    `build javascript files (target ${task.target.join(' + ')}, format ${
+      task.format
+    })\n       ${task.entries
+      .map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`)
+      .join('\n       ')}`,
+  exec: (ctx, task) => {
+    const {inputOptions, outputOptions} = _resolveRollupConfig(ctx, task)
+
+    return new Observable((observer) => {
+      const watchOptions: RollupWatchOptions = {
+        ...inputOptions,
+        output: outputOptions,
+      }
+
+      const watcher = rollupWatch(watchOptions)
+
+      watcher.on('event', (event) => {
+        observer.next(event)
+      })
+
+      return () => {
+        watcher.close()
+      }
+    })
+  },
+  complete: (ctx, task, event) => {
+    const {logger} = ctx
+
+    if (event.code === 'BUNDLE_END') {
+      logger.success(
+        `build javascript files (target ${task.target.join(' + ')}, format ${
+          task.format
+        })\n       ${task.entries
+          .map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`)
+          .join('\n       ')}`
+      )
+      logger.log('')
+
+      return
+    }
+
+    if (event.code === 'BUNDLE_START') {
+      return
+    }
+
+    if (event.code === 'END') {
+      return
+    }
+
+    if (event.code === 'ERROR') {
+      // logger.log('')
+      logger.error(event.code, event)
+
+      return
+    }
+
+    if (event.code === 'START') {
+      return
+    }
+  },
+  error: (ctx, _task, err) => {
+    const {logger} = ctx
+
+    if (err instanceof Error) {
+      logger.log(err)
+    }
+  },
+}

package/src/node/_tasks/rollup/index.ts

@@ -0,0 +1,2 @@
+export * from './_rollupTask'
+export * from './_rollupWatchTask'