@sanity/pkg-utils 1.17.3 → 1.19.0

package/src/node/{_tasks/dts/_doExtract.ts → tasks/dts/doExtract.ts}

@@ -2,12 +2,11 @@ import path from 'path'
 import {promisify} from 'util'
 import {ExtractorMessage} from '@microsoft/api-extractor'
 import rimrafCallback from 'rimraf'
-import {_BuildContext} from '../../_core'
-import {_buildTypes} from './_buildTypes'
-import {_appendModuleBlocks} from './_declareModuleFix'
-import {_DtsError} from './_DtsError'
-import {_extractTypes} from './_extractTypes'
-import {_DtsResult, _DtsTask, _DtsWatchTask} from './_types'
+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)
 
@@ -16,10 +15,10 @@ const rimraf = promisify(rimrafCallback)
  * - Create a type definition bundle for each export entry.
  * - When done, remove the temporary directory.
  */
-export async function _doExtract(
-  ctx: _BuildContext,
-  task: _DtsTask | _DtsWatchTask
-): Promise<_DtsResult> {
+export async function doExtract(
+  ctx: BuildContext,
+  task: DtsTask | DtsWatchTask
+): Promise<DtsResult> {
   const {config, cwd, files, strict, ts} = ctx
 
   if (!ts.config || !ts.configPath) {
@@ -34,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, outDir: tmpPath, strict, tsconfig: ts.config})
   const messages: ExtractorMessage[] = []
 
   const results: {sourcePath: string; filePath: string}[] = []
@@ -49,23 +48,18 @@ export async function _doExtract(
 
     const targetPath = path.resolve(cwd, entry.targetPath)
     const filePath = path.relative(outDir, targetPath)
-    const result = await _extractTypes({
+    const result = await extractTypes({
       customTags: config?.extract?.customTags,
       cwd,
+      distPath: outDir,
       exportPath,
       files,
       filePath: filePath,
       projectPath: cwd,
       rules: config?.extract?.rules,
       sourceTypesPath: sourceTypesPath,
+      tmpPath,
       tsconfigPath: path.resolve(cwd, ts.configPath || 'tsconfig.json'),
-      distPath: outDir,
-    })
-
-    await _appendModuleBlocks({
-      tsOutDir: tmpPath,
-      extractResult: result.extractorResult,
-      extractTypesOutFile: path.resolve(outDir, targetPath),
     })
 
     messages.push(...result.messages)
@@ -73,7 +67,7 @@ export async function _doExtract(
     if (result.messages.some((msg) => msg.logLevel === 'error')) {
       await rimraf(tmpPath)
 
-      throw new _DtsError('encountered errors when extracting types', result.messages)
+      throw new DtsError('encountered errors when extracting types', result.messages)
     }
 
     results.push({sourcePath: path.resolve(cwd, entry.sourcePath), filePath: targetPath})

package/src/node/{_tasks/dts/_dtsTask.ts → tasks/dts/dtsTask.ts}

@@ -1,13 +1,13 @@
 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'
+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> = {
+export const dtsTask: TaskHandler<DtsTask, DtsResult> = {
   name: (_ctx, task) =>
     [
       `build type definitions`,
@@ -18,7 +18,7 @@ export const _dtsTask: _TaskHandler<_DtsTask, _DtsResult> = {
     ].join('\n'),
   exec: (ctx, task) => {
     return new Observable((observer) => {
-      _doExtract(ctx, task)
+      doExtract(ctx, task)
         .then((result) => {
           observer.next(result)
           observer.complete()
@@ -29,13 +29,13 @@ export const _dtsTask: _TaskHandler<_DtsTask, _DtsResult> = {
     })
   },
   complete: (ctx, _task, result) => {
-    _printExtractMessages(ctx, result.messages)
+    printExtractMessages(ctx, result.messages)
   },
   error: (ctx, _task, err) => {
     const {logger} = ctx
 
-    if (err instanceof _DtsError) {
-      _printExtractMessages(ctx, err.messages)
+    if (err instanceof DtsError) {
+      printExtractMessages(ctx, err.messages)
     } else if (err instanceof Error) {
       logger.error(err)
     }

package/src/node/{_tasks/dts/_dtsWatchTask.ts → tasks/dts/dtsWatchTask.ts}

@@ -1,13 +1,13 @@
 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'
+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> = {
+export const dtsWatchTask: TaskHandler<DtsWatchTask, DtsResult> = {
   name: (_ctx, task) =>
     [
       `build type definitions`,
@@ -18,7 +18,7 @@ export const _dtsWatchTask: _TaskHandler<_DtsWatchTask, _DtsResult> = {
     ].join('\n'),
   exec: (ctx, task) => {
     return new Observable((observer) => {
-      _doExtract(ctx, task)
+      doExtract(ctx, task)
         .then((result) => {
           observer.next(result)
           observer.complete()
@@ -29,7 +29,7 @@ export const _dtsWatchTask: _TaskHandler<_DtsWatchTask, _DtsResult> = {
   complete: (ctx, _task, result) => {
     const {logger} = ctx
 
-    _printExtractMessages(ctx, result.messages)
+    printExtractMessages(ctx, result.messages)
 
     logger.warn('watching typescript definitions is currently not supported')
     logger.log()
@@ -37,8 +37,8 @@ export const _dtsWatchTask: _TaskHandler<_DtsWatchTask, _DtsResult> = {
   error: (ctx, _task, err) => {
     const {logger} = ctx
 
-    if (err instanceof _DtsError) {
-      _printExtractMessages(ctx, err.messages)
+    if (err instanceof DtsError) {
+      printExtractMessages(ctx, err.messages)
     } else if (err instanceof Error) {
       logger.error(err)
     }

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

@@ -0,0 +1,45 @@
+import type {File} from '@babel/types'
+import {ExtractorResult} from '@microsoft/api-extractor'
+import {parse, print} from 'recast'
+import typeScriptParser from 'recast/parsers/typescript'
+import {Program} from 'typescript'
+
+/**
+ * A workaround to find all module blocks in extract TS files.
+ * @internal
+ * */
+export async function extractModuleBlocksFromTypes({
+  tsOutDir,
+  extractResult,
+}: {
+  tsOutDir: string
+  extractResult: ExtractorResult
+}): Promise<string[]> {
+  const program = extractResult.compilerState.program as Program
+  const moduleBlocks: string[] = []
+
+  // all program files, including node_modules
+  const allProgramFiles = [...program.getSourceFiles()]
+
+  // just our compiled files used in the program
+  const sourceFiles = allProgramFiles.filter((sourceFile) => sourceFile.fileName.includes(tsOutDir))
+
+  for (const sourceFile of sourceFiles) {
+    if (sourceFile.text.includes('declare module')) {
+      moduleBlocks.push(...extractModuleBlocks(sourceFile.text))
+    }
+  }
+
+  return moduleBlocks
+}
+
+/** @internal */
+export function extractModuleBlocks(fileContent: string): string[] {
+  const ast = parse(fileContent, {
+    parser: typeScriptParser,
+  }) as File
+
+  return ast.program.body
+    .filter((node) => node.type === 'TSModuleDeclaration')
+    .map((node) => print(node).code)
+}

package/src/node/{_tasks/dts/_extractTypes.ts → tasks/dts/extractTypes.ts}

@@ -8,21 +8,23 @@ import {
 } from '@microsoft/api-extractor'
 import mkdirp from 'mkdirp'
 import prettier from 'prettier'
-import {PkgConfigOptions, _BuildFile} from '../../_core'
-import {_createApiExtractorConfig} from './_createApiExtractorConfig'
-import {_createTSDocConfig} from './_createTSDocConfig'
-import {_getExtractMessagesConfig} from './_getExtractMessagesConfig'
+import {PkgConfigOptions, BuildFile} from '../../core'
+import {createApiExtractorConfig} from './createApiExtractorConfig'
+import {createTSDocConfig} from './createTSDocConfig'
+import {extractModuleBlocksFromTypes} from './extractModuleBlocks'
+import {getExtractMessagesConfig} from './getExtractMessagesConfig'
 
-export async function _extractTypes(options: {
+export async function extractTypes(options: {
   customTags: NonNullable<PkgConfigOptions['extract']>['customTags']
   cwd: string
   distPath: string
   exportPath: string
   filePath: string
-  files: _BuildFile[]
+  files: BuildFile[]
   projectPath: string
   rules?: NonNullable<PkgConfigOptions['extract']>['rules']
   sourceTypesPath: string
+  tmpPath: string
   tsconfigPath: string
 }): Promise<{extractorResult: ExtractorResult; messages: ExtractorMessage[]}> {
   const {
@@ -34,19 +36,20 @@ export async function _extractTypes(options: {
     projectPath,
     rules,
     sourceTypesPath,
+    tmpPath,
     tsconfigPath,
   } = options
 
-  const tsdocConfigFile = await _createTSDocConfig({
+  const tsdocConfigFile = await createTSDocConfig({
     customTags: customTags || [],
   })
 
   const extractorConfig: ExtractorConfig = ExtractorConfig.prepare({
-    configObject: _createApiExtractorConfig({
+    configObject: createApiExtractorConfig({
       distPath,
       exportPath,
       filePath,
-      messages: _getExtractMessagesConfig({rules}),
+      messages: getExtractMessagesConfig({rules}),
       projectFolder: projectPath,
       mainEntryPointFilePath: sourceTypesPath,
       tsconfigPath,
@@ -77,9 +80,16 @@ export async function _extractTypes(options: {
 
   await mkdirp(path.dirname(typesPath))
 
+  const moduleBlocks = await extractModuleBlocksFromTypes({
+    extractResult: extractorResult,
+    tsOutDir: tmpPath,
+  })
+
+  const code = [typesBuf.toString(), ...moduleBlocks].join('\n\n')
+
   await fs.writeFile(
     typesPath,
-    prettier.format(typesBuf.toString(), {
+    prettier.format(code, {
       ...prettierConfig,
       filepath: typesPath,
     })

package/src/node/{_tasks/dts/_getExtractMessagesConfig.ts → tasks/dts/getExtractMessagesConfig.ts}

@@ -1,7 +1,7 @@
 import {ExtractorLogLevel, IExtractorMessagesConfig} from '@microsoft/api-extractor'
-import {PkgRuleLevel, PkgConfigOptions} from '../../_core'
+import {PkgRuleLevel, PkgConfigOptions} from '../../core'
 
-const _LOG_LEVELS: Record<PkgRuleLevel, ExtractorLogLevel> = {
+const LOG_LEVELS: Record<PkgRuleLevel, ExtractorLogLevel> = {
   error: 'error' as ExtractorLogLevel.Error,
   info: 'info' as ExtractorLogLevel.Info,
   off: 'none' as ExtractorLogLevel.None,
@@ -9,18 +9,18 @@ const _LOG_LEVELS: Record<PkgRuleLevel, ExtractorLogLevel> = {
 }
 
 /** @internal */
-export function _getExtractMessagesConfig(options: {
+export function getExtractMessagesConfig(options: {
   rules: NonNullable<PkgConfigOptions['extract']>['rules']
 }): IExtractorMessagesConfig {
   const {rules} = options
 
-  function _ruleToLogLevel(
+  function ruleToLogLevel(
     key: keyof NonNullable<NonNullable<PkgConfigOptions['extract']>['rules']>,
     defaultLevel?: ExtractorLogLevel
   ) {
     const r = rules?.[key]
 
-    return (r ? _LOG_LEVELS[r] : defaultLevel || 'warning') as ExtractorLogLevel
+    return (r ? LOG_LEVELS[r] : defaultLevel || 'warning') as ExtractorLogLevel
   }
 
   return {
@@ -37,22 +37,22 @@ export function _getExtractMessagesConfig(options: {
       },
 
       'ae-forgotten-export': {
-        logLevel: _ruleToLogLevel('ae-forgotten-export', 'error' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('ae-forgotten-export', 'error' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
 
       'ae-incompatible-release-tags': {
-        logLevel: _ruleToLogLevel('ae-incompatible-release-tags', 'error' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('ae-incompatible-release-tags', 'error' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
 
       'ae-internal-missing-underscore': {
-        logLevel: _ruleToLogLevel('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),
+        logLevel: ruleToLogLevel('ae-missing-release-tag', 'error' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
 
@@ -69,17 +69,17 @@ export function _getExtractMessagesConfig(options: {
       },
 
       'tsdoc-link-tag-unescaped-text': {
-        logLevel: _ruleToLogLevel('tsdoc-link-tag-unescaped-text', 'warning' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('tsdoc-link-tag-unescaped-text', 'warning' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
 
       'tsdoc-undefined-tag': {
-        logLevel: _ruleToLogLevel('tsdoc-undefined-tag', 'error' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('tsdoc-undefined-tag', 'error' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
 
       'tsdoc-unsupported-tag': {
-        logLevel: _ruleToLogLevel('tsdoc-unsupported-tag', 'none' as ExtractorLogLevel),
+        logLevel: ruleToLogLevel('tsdoc-unsupported-tag', 'none' as ExtractorLogLevel),
         addToApiReportFile: false,
       },
     },

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

@@ -0,0 +1,4 @@
+export * from './dtsTask'
+export * from './dtsWatchTask'
+export * from './getExtractMessagesConfig'
+export * from './types'

package/src/node/{_tasks/dts/_types.ts → tasks/dts/types.ts}

@@ -1,7 +1,7 @@
 import {ExtractorMessage} from '@microsoft/api-extractor'
 
 /** @internal */
-export interface _DtsWatchTask {
+export interface DtsWatchTask {
   type: 'watch:dts'
   entries: {
     exportPath: string
@@ -12,7 +12,7 @@ export interface _DtsWatchTask {
 }
 
 /** @internal */
-export interface _DtsTask {
+export interface DtsTask {
   type: 'build:dts'
   entries: {
     exportPath: string
@@ -23,7 +23,7 @@ export interface _DtsTask {
 }
 
 /** @internal */
-export interface _DtsResult {
+export interface DtsResult {
   type: 'dts'
   messages: ExtractorMessage[]
   results: {sourcePath: string; filePath: string}[]

package/src/node/tasks/index.ts

@@ -0,0 +1,19 @@
+import {dtsTask, dtsWatchTask} from './dts'
+import {rollupTask, rollupWatchTask} from './rollup'
+import {BuildTaskHandlers, WatchTaskHandlers} from './types'
+
+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/index.ts

@@ -0,0 +1,2 @@
+export * from './rollupTask'
+export * from './rollupWatchTask'

package/src/node/{_tasks/rollup/_resolveRollupConfig.ts → tasks/rollup/resolveRollupConfig.ts}

@@ -8,22 +8,27 @@ import replace from '@rollup/plugin-replace'
 import {InputOptions, OutputOptions, Plugin} from 'rollup'
 import esbuild from 'rollup-plugin-esbuild'
 import {terser} from 'rollup-plugin-terser'
-import {_BuildContext, _DEFAULTS, _MODULE_EXT, _resolveConfigProperty} from '../../_core'
-import {_RollupTask, _RollupWatchTask} from '../_types'
-
-export interface _RollupConfig {
+import {
+  BuildContext,
+  DEFAULT_BROWSERSLIST_QUERY,
+  MODULE_EXT,
+  resolveConfigProperty,
+} from '../../core'
+import {RollupTask, RollupWatchTask} from '../types'
+
+export interface RollupConfig {
   inputOptions: InputOptions
   outputOptions: OutputOptions
 }
 
 /** @internal */
-export function _resolveRollupConfig(
-  ctx: _BuildContext,
-  buildTask: _RollupTask | _RollupWatchTask
-): _RollupConfig {
+export function resolveRollupConfig(
+  ctx: BuildContext,
+  buildTask: RollupTask | RollupWatchTask
+): RollupConfig {
   const {format, runtime, target} = buildTask
   const {config, cwd, exports: _exports, external, distPath, logger, pkg, ts} = ctx
-  const outputExt = _MODULE_EXT[pkg.type][format]
+  const outputExt = MODULE_EXT[pkg.type][format]
   const minify = config?.minify ?? true
   const outDir = path.relative(cwd, distPath)
 
@@ -106,7 +111,7 @@ export function _resolveRollupConfig(
     getBabelOutputPlugin({
       babelrc: false,
       plugins: ['@babel/plugin-proposal-object-rest-spread'],
-      presets: [['@babel/preset-env', {targets: pkg.browserslist || _DEFAULTS.browserslist}]],
+      presets: [['@babel/preset-env', {targets: pkg.browserslist || DEFAULT_BROWSERSLIST_QUERY}]],
     }),
     minify &&
       terser({
@@ -131,7 +136,7 @@ export function _resolveRollupConfig(
 
   const plugins = Array.isArray(userPlugins)
     ? defaultPlugins.concat(userPlugins)
-    : _resolveConfigProperty(config?.rollup?.plugins, defaultPlugins)
+    : resolveConfigProperty(config?.rollup?.plugins, defaultPlugins)
 
   return {
     inputOptions: {

package/src/node/{_tasks/rollup/_rollupTask.ts → tasks/rollup/rollupTask.ts}

@@ -4,12 +4,12 @@ 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'
+import {BuildContext} from '../../core'
+import {RollupTask, TaskHandler} from '../types'
+import {resolveRollupConfig} from './resolveRollupConfig'
 
 /** @internal */
-export const _rollupTask: _TaskHandler<_RollupTask> = {
+export const rollupTask: TaskHandler<RollupTask> = {
   name: (ctx, task) =>
     `build javascript files (target ${task.target.join(' + ')}, format ${
       task.format
@@ -18,7 +18,7 @@ export const _rollupTask: _TaskHandler<_RollupTask> = {
       .join('\n       ')}`,
   exec: (ctx, task) => {
     return new Observable((observer) => {
-      _execPromise(ctx, task)
+      execPromise(ctx, task)
         .then((result) => {
           observer.next(result)
           observer.complete()
@@ -36,11 +36,11 @@ export const _rollupTask: _TaskHandler<_RollupTask> = {
   },
 }
 
-async function _execPromise(ctx: _BuildContext, task: _RollupTask) {
+async function execPromise(ctx: BuildContext, task: RollupTask) {
   const {files, distPath} = ctx
   const outDir = path.relative(ctx.cwd, distPath)
 
-  const {inputOptions, outputOptions} = _resolveRollupConfig(ctx, task)
+  const {inputOptions, outputOptions} = resolveRollupConfig(ctx, task)
 
   // Create bundle
   const bundle = await rollup(inputOptions)

package/src/node/{_tasks/rollup/_rollupWatchTask.ts → tasks/rollup/rollupWatchTask.ts}

@@ -2,11 +2,11 @@ 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'
+import {RollupWatchTask, TaskHandler} from '../types'
+import {resolveRollupConfig} from './resolveRollupConfig'
 
 /** @internal */
-export const _rollupWatchTask: _TaskHandler<_RollupWatchTask, RollupWatcherEvent> = {
+export const rollupWatchTask: TaskHandler<RollupWatchTask, RollupWatcherEvent> = {
   name: (ctx, task) =>
     `build javascript files (target ${task.target.join(' + ')}, format ${
       task.format
@@ -14,7 +14,7 @@ export const _rollupWatchTask: _TaskHandler<_RollupWatchTask, RollupWatcherEvent
       .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)
+    const {inputOptions, outputOptions} = resolveRollupConfig(ctx, task)
 
     return new Observable((observer) => {
       const watchOptions: RollupWatchOptions = {

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/watch.ts

@@ -1,10 +1,10 @@
 import path from 'path'
 import {switchMap} from 'rxjs'
-import {_loadConfig, _loadPkgWithReporting} from './_core'
-import {_resolveBuildContext} from './_resolveBuildContext'
-import {_resolveWatchTasks} from './_resolveWatchTasks'
-import {_WatchTask, _TaskHandler, _watchTaskHandlers} from './_tasks'
-import {_watchConfigFiles} from './_watchConfigFiles'
+import {loadConfig, loadPkgWithReporting} from './core'
+import {resolveBuildContext} from './resolveBuildContext'
+import {resolveWatchTasks} from './resolveWatchTasks'
+import {WatchTask, TaskHandler, watchTaskHandlers} from './tasks'
+import {watchConfigFiles} from './watchConfigFiles'
 
 /** @public */
 export async function watch(options: {
@@ -14,31 +14,31 @@ export async function watch(options: {
 }): Promise<void> {
   const {cwd, strict = false, tsconfig: tsconfigOption} = options
 
-  const configFiles$ = await _watchConfigFiles({cwd})
+  const configFiles$ = await watchConfigFiles({cwd})
 
   const ctx$ = configFiles$.pipe(
     switchMap(async (configFiles) => {
-      const _files = configFiles.map((f) => path.relative(cwd, f))
+      const files = configFiles.map((f) => path.relative(cwd, f))
 
-      const packageJsonPath = _files.find((f) => f === 'package.json')
+      const packageJsonPath = files.find((f) => f === 'package.json')
 
       if (!packageJsonPath) {
         throw new Error('missing package.json')
       }
 
-      const pkg = await _loadPkgWithReporting({cwd})
-      const config = await _loadConfig({cwd})
+      const pkg = await loadPkgWithReporting({cwd})
+      const config = await loadConfig({cwd})
       const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'
 
-      return _resolveBuildContext({config, cwd, pkg, strict, tsconfig})
+      return resolveBuildContext({config, cwd, pkg, strict, tsconfig})
     })
   )
 
   ctx$.subscribe(async (ctx) => {
-    const watchTasks = _resolveWatchTasks(ctx)
+    const watchTasks = resolveWatchTasks(ctx)
 
     for (const task of watchTasks) {
-      const handler = _watchTaskHandlers[task.type] as _TaskHandler<_WatchTask, unknown>
+      const handler = watchTaskHandlers[task.type] as TaskHandler<WatchTask, unknown>
       const result$ = handler.exec(ctx, task)
 
       result$.subscribe({