@sanity/pkg-utils 1.18.0 → 1.19.0

package/src/node/{_printExtractMessages.ts → printExtractMessages.ts}

@@ -1,9 +1,9 @@
 import path from 'path'
 import {ExtractorMessage} from '@microsoft/api-extractor'
 import chalk from 'chalk'
-import {_BuildContext} from './_core'
+import {BuildContext} from './core'
 
-export function _printExtractMessages(ctx: _BuildContext, messages: ExtractorMessage[]): void {
+export function printExtractMessages(ctx: BuildContext, messages: ExtractorMessage[]): void {
   const {cwd, logger} = ctx
 
   const warnings = messages.filter((msg) => msg.logLevel === 'warning')

package/src/node/{_printPackageTree.ts → printPackageTree.ts}

@@ -2,10 +2,10 @@ 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'
+import {PkgExport, BuildContext} from './core'
+import {getFilesize} from './getFilesize'
 
-export function _fileExists(file: string): boolean {
+export function fileExists(file: string): boolean {
   try {
     fs.accessSync(file)
 
@@ -15,15 +15,15 @@ export function _fileExists(file: string): boolean {
   }
 }
 
-function _getFileInfo(cwd: string, filePath: string) {
+function getFileInfo(cwd: string, filePath: string) {
   const p = path.resolve(cwd, filePath)
-  const exists = _fileExists(p)
-  const size = exists ? _getFilesize(p) : undefined
+  const exists = fileExists(p)
+  const size = exists ? getFilesize(p) : undefined
 
   return {exists, size}
 }
 
-export function _printPackageTree(ctx: _BuildContext): void {
+export function printPackageTree(ctx: BuildContext): void {
   const {cwd, exports, logger, pkg} = ctx
 
   if (!exports) return
@@ -37,8 +37,8 @@ export function _printPackageTree(ctx: _BuildContext): void {
     tree.bin = pkg.bin
   }
 
-  function _fileInfo(file: string) {
-    const info = _getFileInfo(cwd, file)
+  function fileInfo(file: string) {
+    const info = getFileInfo(cwd, file)
 
     if (!info.size) {
       return `${chalk.gray(file)} ${chalk.red('does not exist')}`
@@ -62,7 +62,7 @@ export function _printPackageTree(ctx: _BuildContext): void {
         }
 
         if (entry.types) {
-          exp.types = _fileInfo(entry.types)
+          exp.types = fileInfo(entry.types)
         } else {
           delete exp.types
         }
@@ -70,8 +70,8 @@ export function _printPackageTree(ctx: _BuildContext): void {
         if (entry.browser) {
           exp.browser = {source: 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)
+          if (entry.browser.import) exp.browser.import = fileInfo(entry.browser.import)
+          if (entry.browser.require) exp.browser.require = fileInfo(entry.browser.require)
         } else {
           delete exp.browser
         }
@@ -79,25 +79,25 @@ export function _printPackageTree(ctx: _BuildContext): void {
         if (entry.node) {
           exp.node = {source: 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)
+          if (entry.node.import) exp.node.import = fileInfo(entry.node.import)
+          if (entry.node.require) exp.node.require = fileInfo(entry.node.require)
         } else {
           delete exp.node
         }
 
         if (entry.import) {
-          exp.import = _fileInfo(entry.import)
+          exp.import = fileInfo(entry.import)
         } else {
           delete exp.import
         }
 
         if (entry.require) {
-          exp.require = _fileInfo(entry.require)
+          exp.require = fileInfo(entry.require)
         } else {
           delete exp.require
         }
 
-        exp.default = _fileInfo(entry.default)
+        exp.default = fileInfo(entry.default)
 
         return [chalk.green(path.join(pkg.name, exportPath)), exp]
       })

package/src/node/{_resolveBrowserTarget.ts → resolveBrowserTarget.ts}

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

package/src/node/{_resolveBrowserslistVersions.ts → resolveBrowserslistVersions.ts}

@@ -1,6 +1,6 @@
 import browserslist from 'browserslist'
 
-export interface _PackageTargetVersions {
+export interface PackageTargetVersions {
   chrome: string[]
   ff: string[]
   edge: string[]
@@ -10,14 +10,14 @@ export interface _PackageTargetVersions {
   node: string[]
 }
 
-function _sortAsNumber(a: string, b: string) {
+function sortAsNumber(a: string, b: string) {
   const aVersion = Number(a)
   const bVersion = Number(b)
 
   return aVersion - bVersion
 }
 
-export function _resolveBrowserslistVersions(query: string[]): _PackageTargetVersions {
+export function resolveBrowserslistVersions(query: string[]): PackageTargetVersions {
   const result = browserslist(query)
 
   const entries = result.map((key) => {
@@ -37,7 +37,7 @@ export function _resolveBrowserslistVersions(query: string[]): _PackageTargetVer
   const node = entries.filter((b) => b.name === 'node')
 
   // versions
-  const versions: _PackageTargetVersions = {
+  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),
@@ -48,13 +48,13 @@ export function _resolveBrowserslistVersions(query: string[]): _PackageTargetVer
   }
 
   // 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)
+  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 → resolveBuildContext.ts}

@@ -4,19 +4,19 @@ import {
   PkgConfigOptions,
   PkgExports,
   PkgRuntime,
-  _BuildContext,
-  _DEFAULTS,
-  _loadTSConfig,
-  _PackageJSON,
-  _parseExports,
-  _resolveConfigProperty,
-} from './_core'
-import {_findCommonDirPath, _pathContains} from './_core/_findCommonPath'
-import {_resolveBrowserslistVersions} from './_resolveBrowserslistVersions'
-import {_resolveBrowserTarget} from './_resolveBrowserTarget'
-import {_resolveNodeTarget} from './_resolveNodeTarget'
-
-function _createLogger(): _BuildContext['logger'] {
+  BuildContext,
+  DEFAULT_BROWSERSLIST_QUERY,
+  loadTSConfig,
+  PackageJSON,
+  parseExports,
+  resolveConfigProperty,
+} from './core'
+import {findCommonDirPath, pathContains} from './core/findCommonPath'
+import {resolveBrowserslistVersions} from './resolveBrowserslistVersions'
+import {resolveBrowserTarget} from './resolveBrowserTarget'
+import {resolveNodeTarget} from './resolveNodeTarget'
+
+function createLogger(): BuildContext['logger'] {
   return {
     /* eslint-disable no-console */
     log: (...args) => {
@@ -38,20 +38,20 @@ function _createLogger(): _BuildContext['logger'] {
   }
 }
 
-export async function _resolveBuildContext(options: {
+export async function resolveBuildContext(options: {
   config?: PkgConfigOptions
   cwd: string
   emitDeclarationOnly?: boolean
-  pkg: _PackageJSON
+  pkg: PackageJSON
   strict: boolean
   tsconfig: string
-}): Promise<_BuildContext> {
+}): Promise<BuildContext> {
   const {config, cwd, emitDeclarationOnly = false, pkg, strict, tsconfig: tsconfigPath} = options
-  const logger = _createLogger()
-  const tsconfig = await _loadTSConfig({cwd, tsconfigPath})
-  const targetVersions = _resolveBrowserslistVersions(pkg.browserslist || _DEFAULTS.browserslist)
-  const nodeTarget = _resolveNodeTarget(targetVersions)
-  const webTarget = _resolveBrowserTarget(targetVersions)
+  const logger = createLogger()
+  const tsconfig = await loadTSConfig({cwd, tsconfigPath})
+  const targetVersions = resolveBrowserslistVersions(pkg.browserslist || DEFAULT_BROWSERSLIST_QUERY)
+  const nodeTarget = resolveNodeTarget(targetVersions)
+  const webTarget = resolveBrowserTarget(targetVersions)
 
   if (!nodeTarget) {
     throw new Error('no matching `node` target')
@@ -67,13 +67,13 @@ export async function _resolveBuildContext(options: {
     node: nodeTarget,
   }
 
-  const parsedExports = _parseExports({pkg, strict}).reduce<PkgExports>((acc, x) => {
+  const parsedExports = parseExports({pkg, strict}).reduce<PkgExports>((acc, x) => {
     const {_path: exportPath, ...exportEntry} = x
 
     return {...acc, [exportPath]: exportEntry}
   }, {})
 
-  const exports = _resolveConfigProperty(config?.exports, parsedExports)
+  const exports = resolveConfigProperty(config?.exports, parsedExports)
 
   const parsedExternal = [
     ...(pkg.dependencies ? Object.keys(pkg.dependencies) : []),
@@ -84,7 +84,7 @@ export async function _resolveBuildContext(options: {
   const external =
     config && Array.isArray(config.external)
       ? [...parsedExternal, ...config.external]
-      : _resolveConfigProperty(config?.external, parsedExternal)
+      : resolveConfigProperty(config?.external, parsedExternal)
 
   const outputPaths = Object.values(exports)
     .flatMap((exportEntry) => {
@@ -99,7 +99,7 @@ export async function _resolveBuildContext(options: {
     })
     .map((p) => path.resolve(cwd, p))
 
-  const commonDistPath = _findCommonDirPath(outputPaths)
+  const commonDistPath = findCommonDirPath(outputPaths)
 
   if (commonDistPath === cwd) {
     throw new Error(
@@ -107,7 +107,7 @@ export async function _resolveBuildContext(options: {
     )
   }
 
-  if (commonDistPath && !_pathContains(cwd, commonDistPath)) {
+  if (commonDistPath && !pathContains(cwd, commonDistPath)) {
     throw new Error('all output files must be located within the package')
   }
 
@@ -117,7 +117,7 @@ export async function _resolveBuildContext(options: {
     configDistPath &&
     commonDistPath &&
     configDistPath !== commonDistPath &&
-    !_pathContains(configDistPath, commonDistPath)
+    !pathContains(configDistPath, commonDistPath)
   ) {
     logger.log(`did you mean to configure \`dist: './${path.relative(cwd, commonDistPath)}'\`?`)
 
@@ -130,7 +130,7 @@ export async function _resolveBuildContext(options: {
     throw new Error('could not detect `dist` path')
   }
 
-  const ctx: _BuildContext = {
+  const ctx: BuildContext = {
     config,
     cwd,
     distPath,

package/src/node/{_resolveBuildTasks.ts → resolveBuildTasks.ts}

@@ -1,28 +1,28 @@
 import fs from 'fs'
 import path from 'path'
-import {PkgExport, PkgFormat, PkgRuntime, _BuildContext} from './_core'
-import {_BuildTask, _DtsTask, _RollupTask, _RollupTaskEntry} from './_tasks'
+import {PkgExport, PkgFormat, PkgRuntime, BuildContext} from './core'
+import {BuildTask, DtsTask, RollupTask, RollupTaskEntry} from './tasks'
 
 /** @internal */
-export function _resolveBuildTasks(ctx: _BuildContext): _BuildTask[] {
+export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
   const {config, cwd, pkg, target} = ctx
 
   const bundles = config?.bundles || []
 
-  const tasks: _BuildTask[] = []
+  const tasks: BuildTask[] = []
 
   const exports = Object.entries(ctx.exports || {}).map(
     ([_path, exp]) => ({_path, ...exp} as PkgExport & {_path: string})
   )
 
-  const dtsTask: _DtsTask = {
+  const dtsTask: DtsTask = {
     type: 'build:dts',
     entries: [],
   }
 
-  const rollupTasks: Record<string, _RollupTask> = {}
+  const rollupTasks: Record<string, RollupTask> = {}
 
-  function _addRollupTaskEntry(format: PkgFormat, runtime: PkgRuntime, entry: _RollupTaskEntry) {
+  function addRollupTaskEntry(format: PkgFormat, runtime: PkgRuntime, entry: RollupTaskEntry) {
     const buildId = `${format}:${runtime}`
 
     if (rollupTasks[buildId]) {
@@ -65,7 +65,7 @@ export function _resolveBuildTasks(ctx: _BuildContext): _BuildTask[] {
 
       if (!output) continue
 
-      _addRollupTaskEntry('commonjs', ctx.runtime, {
+      addRollupTaskEntry('commonjs', ctx.runtime, {
         path: exp._path,
         source: exp.source,
         output,
@@ -78,7 +78,7 @@ export function _resolveBuildTasks(ctx: _BuildContext): _BuildTask[] {
 
       if (!output) continue
 
-      _addRollupTaskEntry('esm', ctx.runtime, {
+      addRollupTaskEntry('esm', ctx.runtime, {
         path: exp._path,
         source: exp.source,
         output,
@@ -91,7 +91,7 @@ export function _resolveBuildTasks(ctx: _BuildContext): _BuildTask[] {
 
       if (!output) continue
 
-      _addRollupTaskEntry('commonjs', 'browser', {
+      addRollupTaskEntry('commonjs', 'browser', {
         path: exp._path,
         source: exp.browser?.source || exp.source,
         output,
@@ -104,7 +104,7 @@ export function _resolveBuildTasks(ctx: _BuildContext): _BuildTask[] {
 
       if (!output) continue
 
-      _addRollupTaskEntry('esm', 'browser', {
+      addRollupTaskEntry('esm', 'browser', {
         path: exp._path,
         source: exp.browser?.source || exp.source,
         output,
@@ -113,7 +113,7 @@ export function _resolveBuildTasks(ctx: _BuildContext): _BuildTask[] {
 
     for (const bundle of bundles) {
       if (bundle.require) {
-        _addRollupTaskEntry('commonjs', bundle.runtime || ctx.runtime, {
+        addRollupTaskEntry('commonjs', bundle.runtime || ctx.runtime, {
           path: '__bundle__',
           source: bundle.source,
           output: bundle.require,
@@ -121,7 +121,7 @@ export function _resolveBuildTasks(ctx: _BuildContext): _BuildTask[] {
       }
 
       if (bundle.import) {
-        _addRollupTaskEntry('commonjs', bundle.runtime || ctx.runtime, {
+        addRollupTaskEntry('commonjs', bundle.runtime || ctx.runtime, {
           path: '__bundle__',
           source: bundle.source,
           output: bundle.import,

package/src/node/{_resolveNodeTarget.ts → resolveNodeTarget.ts}

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

package/src/node/{_resolveWatchTasks.ts → resolveWatchTasks.ts}

@@ -1,25 +1,25 @@
 import fs from 'fs'
 import path from 'path'
-import {PkgExport, PkgFormat, PkgRuntime, _BuildContext} from './_core'
-import {_WatchTask, _DtsWatchTask, _RollupWatchTask, _RollupTaskEntry} from './_tasks'
+import {PkgExport, PkgFormat, PkgRuntime, BuildContext} from './core'
+import {WatchTask, DtsWatchTask, RollupWatchTask, RollupTaskEntry} from './tasks'
 
 /** @internal */
-export function _resolveWatchTasks(ctx: _BuildContext): _WatchTask[] {
+export function resolveWatchTasks(ctx: BuildContext): WatchTask[] {
   const {config, cwd, pkg, target} = ctx
-  const tasks: _WatchTask[] = []
+  const tasks: WatchTask[] = []
 
   const exports = Object.entries(ctx.exports || {}).map(
     ([_path, exp]) => ({_path, ...exp} as PkgExport & {_path: string})
   )
 
-  const dtsTask: _DtsWatchTask = {
+  const dtsTask: DtsWatchTask = {
     type: 'watch:dts',
     entries: [],
   }
 
-  const rollupTasks: Record<string, _RollupWatchTask> = {}
+  const rollupTasks: Record<string, RollupWatchTask> = {}
 
-  function _addRollupTaskEntry(format: PkgFormat, runtime: PkgRuntime, entry: _RollupTaskEntry) {
+  function addRollupTaskEntry(format: PkgFormat, runtime: PkgRuntime, entry: RollupTaskEntry) {
     const buildId = `${format}:${runtime}`
 
     if (rollupTasks[buildId]) {
@@ -56,7 +56,7 @@ export function _resolveWatchTasks(ctx: _BuildContext): _WatchTask[] {
 
     if (!output) continue
 
-    _addRollupTaskEntry('commonjs', ctx.runtime, {
+    addRollupTaskEntry('commonjs', ctx.runtime, {
       path: exp._path,
       source: exp.source,
       output,
@@ -69,7 +69,7 @@ export function _resolveWatchTasks(ctx: _BuildContext): _WatchTask[] {
 
     if (!output) continue
 
-    _addRollupTaskEntry('commonjs', 'browser', {
+    addRollupTaskEntry('commonjs', 'browser', {
       path: exp._path,
       source: exp.browser?.source || exp.source,
       output,
@@ -82,7 +82,7 @@ export function _resolveWatchTasks(ctx: _BuildContext): _WatchTask[] {
 
     if (!output) continue
 
-    _addRollupTaskEntry('esm', ctx.runtime, {
+    addRollupTaskEntry('esm', ctx.runtime, {
       path: exp._path,
       source: exp.source,
       output,
@@ -95,7 +95,7 @@ export function _resolveWatchTasks(ctx: _BuildContext): _WatchTask[] {
 
     if (!output) continue
 
-    _addRollupTaskEntry('esm', 'browser', {
+    addRollupTaskEntry('esm', 'browser', {
       path: exp._path,
       source: exp.browser?.source || exp.source,
       output,

package/src/node/{_spinner.ts → spinner.ts}

@@ -2,7 +2,7 @@
 
 import chalk from 'chalk'
 
-export function _spinner(msg: string): {complete: () => void; error: () => void} {
+export function createSpinner(msg: string): {complete: () => void; error: () => void} {
   const startTime = Date.now()
 
   console.log(`${chalk.yellow('run   ')} ${msg}`)

package/src/node/{_tasks/dts/_DtsError.ts → tasks/dts/DtsError.ts}

@@ -1,7 +1,7 @@
 import {ExtractorMessage} from '@microsoft/api-extractor'
 
 /** @internal */
-export class _DtsError extends Error {
+export class DtsError extends Error {
   messages: ExtractorMessage[]
 
   constructor(message: string, messages: ExtractorMessage[]) {

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

@@ -9,7 +9,7 @@ export const formatHost: ts.FormatDiagnosticsHost = {
 }
 
 /** @internal */
-export async function _buildTypes(options: {
+export async function buildTypes(options: {
   cwd: string
   outDir: string
   tsconfig: ts.ParsedCommandLine

package/src/node/{_tasks/dts/_createApiExtractorConfig.ts → tasks/dts/createApiExtractorConfig.ts}

@@ -1,7 +1,7 @@
 import path from 'path'
 import {IConfigFile, IExtractorMessagesConfig} from '@microsoft/api-extractor'
 
-export function _createApiExtractorConfig(options: {
+export function createApiExtractorConfig(options: {
   distPath: string
   exportPath: string
   filePath: string

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

@@ -10,7 +10,7 @@ export interface TSDocCustomTag {
 }
 
 /** @internal */
-export async function _createTSDocConfig(opts: {
+export async function createTSDocConfig(opts: {
   customTags: TSDocCustomTag[]
 }): Promise<TSDocConfigFile | undefined> {
   const {customTags} = opts

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

@@ -2,11 +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 {_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)
 
@@ -15,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) {
@@ -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, outDir: tmpPath, strict, tsconfig: ts.config})
   const messages: ExtractorMessage[] = []
 
   const results: {sourcePath: string; filePath: string}[] = []
@@ -48,7 +48,7 @@ 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,
@@ -67,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)
     }