@sanity/pkg-utils 1.18.0 → 1.19.0

package/dist/index.js

@@ -3,11 +3,11 @@
 Object.defineProperty(exports, '__esModule', {
   value: true
 });
-var _resolveBuildContext = require('./_chunks/_resolveBuildContext-7ca7e64e.js');
-var build = require('./_chunks/build-f39a3550.js');
-var index = require('./_chunks/index-7a851efa.js');
-var check = require('./_chunks/check-87cbb6cc.js');
-var watch = require('./_chunks/watch-f6cf9246.js');
+var resolveBuildContext = require('./_chunks/resolveBuildContext-f2feec19.js');
+var build = require('./_chunks/build-bcb33ba5.js');
+var index = require('./_chunks/index-79fdb33f.js');
+var check = require('./_chunks/check-1ea361f5.js');
+var watch = require('./_chunks/watch-02c85f8a.js');
 require('path');
 require('esbuild-register/dist/node');
 require('pkg-up');
@@ -46,24 +46,24 @@ require('chokidar');
 function defineConfig(configOptions) {
   return configOptions;
 }
-exports._DEFAULTS = _resolveBuildContext._DEFAULTS;
-exports._MODULE_EXT = _resolveBuildContext._MODULE_EXT;
-exports._isRecord = _resolveBuildContext._isRecord;
-exports._loadConfig = _resolveBuildContext._loadConfig;
-exports._loadPkg = _resolveBuildContext._loadPkg;
-exports._loadPkgWithReporting = _resolveBuildContext._loadPkgWithReporting;
-exports._loadTSConfig = _resolveBuildContext._loadTSConfig;
-exports._parseExports = _resolveBuildContext._parseExports;
-exports._resolveConfigProperty = _resolveBuildContext._resolveConfigProperty;
-exports._resolveBuildTasks = build._resolveBuildTasks;
+exports.DEFAULT_BROWSERSLIST_QUERY = resolveBuildContext.DEFAULT_BROWSERSLIST_QUERY;
+exports.MODULE_EXT = resolveBuildContext.MODULE_EXT;
+exports.isRecord = resolveBuildContext.isRecord;
+exports.loadConfig = resolveBuildContext.loadConfig;
+exports.loadPkg = resolveBuildContext.loadPkg;
+exports.loadPkgWithReporting = resolveBuildContext.loadPkgWithReporting;
+exports.loadTSConfig = resolveBuildContext.loadTSConfig;
+exports.parseExports = resolveBuildContext.parseExports;
+exports.resolveConfigProperty = resolveBuildContext.resolveConfigProperty;
 exports.build = build.build;
-exports._buildTaskHandlers = index._buildTaskHandlers;
-exports._dtsTask = index._dtsTask;
-exports._dtsWatchTask = index._dtsWatchTask;
-exports._getExtractMessagesConfig = index._getExtractMessagesConfig;
-exports._rollupTask = index._rollupTask;
-exports._rollupWatchTask = index._rollupWatchTask;
-exports._watchTaskHandlers = index._watchTaskHandlers;
+exports.resolveBuildTasks = build.resolveBuildTasks;
+exports.buildTaskHandlers = index.buildTaskHandlers;
+exports.dtsTask = index.dtsTask;
+exports.dtsWatchTask = index.dtsWatchTask;
+exports.getExtractMessagesConfig = index.getExtractMessagesConfig;
+exports.rollupTask = index.rollupTask;
+exports.rollupWatchTask = index.rollupWatchTask;
+exports.watchTaskHandlers = index.watchTaskHandlers;
 exports.check = check.check;
 exports.watch = watch.watch;
 exports.defineConfig = defineConfig;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/node/_core/config/defineConfig.ts"],"sourcesContent":["import {PkgConfigOptions} from './types'\n\n/** @public */\nexport function defineConfig(configOptions: PkgConfigOptions): PkgConfigOptions {\n  return configOptions\n}\n"],"names":["defineConfig","configOptions"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAO,SAASA,YAAY,CAACC,aAAa,EAAE;EAC1C,OAAOA,aAAa;AACtB;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../src/node/core/config/defineConfig.ts"],"sourcesContent":["import {PkgConfigOptions} from './types'\n\n/** @public */\nexport function defineConfig(configOptions: PkgConfigOptions): PkgConfigOptions {\n  return configOptions\n}\n"],"names":["defineConfig","configOptions"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAO,SAASA,YAAY,CAACC,aAAa,EAAE;EAC1C,OAAOA,aAAa;AACtB;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/pkg-utils",
-  "version": "1.18.0",
+  "version": "1.19.0",
   "author": "Sanity.io <hello@sanity.io>",
   "license": "MIT",
   "description": "Simple utilities for modern npm packages.",
@@ -140,6 +140,11 @@
     "url": "https://github.com/sanity-io/pkg-utils/issues"
   },
   "homepage": "https://github.com/sanity-io/pkg-utils#readme",
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -148,5 +153,47 @@
     "overrides": {
       "@sanity/pkg-utils": "workspace:*"
     }
+  },
+  "prettier": {
+    "bracketSpacing": false,
+    "printWidth": 100,
+    "semi": false,
+    "singleQuote": true,
+    "tabWidth": 2,
+    "overrides": [
+      {
+        "files": [
+          "*.json5"
+        ],
+        "options": {
+          "singleQuote": false,
+          "quoteProps": "preserve"
+        }
+      },
+      {
+        "files": [
+          "*.yml"
+        ],
+        "options": {
+          "singleQuote": false
+        }
+      }
+    ]
+  },
+  "release": {
+    "extends": "@sanity/semantic-release-preset",
+    "branches": [
+      "+([0-9])?(.{+([0-9]),x}).x",
+      "main",
+      "next",
+      {
+        "name": "beta",
+        "prerelease": true
+      },
+      {
+        "name": "alpha",
+        "prerelease": true
+      }
+    ]
   }
 }

package/src/cli/buildAction.ts

@@ -1,5 +1,5 @@
 import {build} from '../node/build'
-import {_handleError} from './_handleError'
+import {handleError} from './handleError'
 
 export async function buildAction(options: {
   emitDeclarationOnly?: boolean
@@ -14,6 +14,6 @@ export async function buildAction(options: {
       tsconfig: options.tsconfig,
     })
   } catch (err) {
-    _handleError(err)
+    handleError(err)
   }
 }

package/src/cli/checkAction.ts

@@ -1,5 +1,5 @@
 import {check} from '../node/check'
-import {_handleError} from './_handleError'
+import {handleError} from './handleError'
 
 export async function checkAction(options: {strict?: boolean; tsconfig?: string}): Promise<void> {
   try {
@@ -9,6 +9,6 @@ export async function checkAction(options: {strict?: boolean; tsconfig?: string}
       tsconfig: options.tsconfig,
     })
   } catch (err) {
-    _handleError(err)
+    handleError(err)
   }
 }

package/src/cli/{_handleError.ts → handleError.ts}

@@ -2,7 +2,7 @@
 
 import chalk from 'chalk'
 
-export function _handleError(err: unknown): void {
+export function handleError(err: unknown): void {
   if (err instanceof Error) {
     console.error(chalk.red('error'), err.message)
   }

package/src/cli/watchAction.ts

@@ -1,5 +1,5 @@
 import {watch} from '../node/watch'
-import {_handleError} from './_handleError'
+import {handleError} from './handleError'
 
 export async function watchAction(options: {strict?: boolean; tsconfig?: string}): Promise<void> {
   try {
@@ -9,6 +9,6 @@ export async function watchAction(options: {strict?: boolean; tsconfig?: string}
       tsconfig: options.tsconfig,
     })
   } catch (err) {
-    _handleError(err)
+    handleError(err)
   }
 }

package/src/node/build.ts

@@ -1,8 +1,8 @@
-import {_loadConfig, _loadPkgWithReporting} from './_core'
-import {_resolveBuildContext} from './_resolveBuildContext'
-import {_resolveBuildTasks} from './_resolveBuildTasks'
-import {_spinner} from './_spinner'
-import {_BuildTask, _TaskHandler, _buildTaskHandlers} from './_tasks'
+import {loadConfig, loadPkgWithReporting} from './core'
+import {resolveBuildContext} from './resolveBuildContext'
+import {resolveBuildTasks} from './resolveBuildTasks'
+import {createSpinner} from './spinner'
+import {BuildTask, TaskHandler, buildTaskHandlers} from './tasks'
 
 /**
  * Build the distribution files of a npm package.
@@ -31,18 +31,18 @@ export async function build(options: {
 }): Promise<void> {
   const {cwd, emitDeclarationOnly, strict = false, tsconfig: tsconfigOption} = options
 
-  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'
-  const ctx = await _resolveBuildContext({config, cwd, emitDeclarationOnly, pkg, strict, tsconfig})
+  const ctx = await resolveBuildContext({config, cwd, emitDeclarationOnly, pkg, strict, tsconfig})
 
-  const buildTasks = _resolveBuildTasks(ctx)
+  const buildTasks = resolveBuildTasks(ctx)
 
   for (const task of buildTasks) {
-    const handler = _buildTaskHandlers[task.type] as _TaskHandler<_BuildTask>
+    const handler = buildTaskHandlers[task.type] as TaskHandler<BuildTask>
     const taskName = handler.name(ctx, task)
 
-    const spinner = _spinner(taskName)
+    const spinner = createSpinner(taskName)
 
     try {
       const result = await handler.exec(ctx, task).toPromise()

package/src/node/check.ts

@@ -1,8 +1,8 @@
 import path from 'path'
 import esbuild, {BuildFailure} from 'esbuild'
-import {_loadConfig, _loadPkgWithReporting} from './_core'
-import {_fileExists, _printPackageTree} from './_printPackageTree'
-import {_resolveBuildContext} from './_resolveBuildContext'
+import {loadConfig, loadPkgWithReporting} from './core'
+import {fileExists, printPackageTree} from './printPackageTree'
+import {resolveBuildContext} from './resolveBuildContext'
 
 /** @public */
 export async function check(options: {
@@ -12,32 +12,32 @@ export async function check(options: {
 }): Promise<void> {
   const {cwd, strict = false, tsconfig: tsconfigOption} = options
 
-  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'
-  const ctx = await _resolveBuildContext({config, cwd, pkg, strict, tsconfig})
+  const ctx = await resolveBuildContext({config, cwd, pkg, strict, tsconfig})
   const {logger} = ctx
 
-  _printPackageTree(ctx)
+  printPackageTree(ctx)
 
   if (strict) {
     const missingFiles: string[] = []
 
     // Check if there are missing files
     for (const [, exp] of Object.entries(ctx.exports || {})) {
-      if (exp.source && !_fileExists(path.resolve(cwd, exp.source))) {
+      if (exp.source && !fileExists(path.resolve(cwd, exp.source))) {
         missingFiles.push(exp.source)
       }
 
-      if (exp.require && !_fileExists(path.resolve(cwd, exp.require))) {
+      if (exp.require && !fileExists(path.resolve(cwd, exp.require))) {
         missingFiles.push(exp.require)
       }
 
-      if (exp.import && !_fileExists(path.resolve(cwd, exp.import))) {
+      if (exp.import && !fileExists(path.resolve(cwd, exp.import))) {
         missingFiles.push(exp.import)
       }
 
-      if (exp.types && !_fileExists(path.resolve(cwd, exp.types))) {
+      if (exp.types && !fileExists(path.resolve(cwd, exp.types))) {
         missingFiles.push(exp.types)
       }
     }

package/src/node/{_core/config/_findConfigFile.ts → core/config/findConfigFile.ts}

@@ -9,7 +9,7 @@ const CONFIG_FILE_NAMES = [
   'package.config.mjs',
 ]
 
-export async function _findConfigFile(cwd: string): Promise<string | undefined> {
+export async function findConfigFile(cwd: string): Promise<string | undefined> {
   const pkgJsonPath = findConfig('package.json', {cwd})
 
   if (!pkgJsonPath) return undefined
@@ -19,7 +19,7 @@ export async function _findConfigFile(cwd: string): Promise<string | undefined>
   for (const fileName of CONFIG_FILE_NAMES) {
     const configPath = path.resolve(pkgPath, fileName)
 
-    const exists = await _fileExists(configPath)
+    const exists = await fileExists(configPath)
 
     if (exists) {
       return configPath
@@ -29,7 +29,7 @@ export async function _findConfigFile(cwd: string): Promise<string | undefined>
   return undefined
 }
 
-async function _fileExists(filePath: string) {
+async function fileExists(filePath: string) {
   try {
     await stat(filePath)
 

package/src/node/core/config/index.ts

@@ -0,0 +1,4 @@
+export * from './loadConfig'
+export * from './resolveConfigProperty'
+export * from './defineConfig'
+export * from './types'

package/src/node/{_core/config/_loadConfig.ts → core/config/loadConfig.ts}

@@ -1,11 +1,11 @@
 import path from 'path'
 import {register} from 'esbuild-register/dist/node'
 import pkgUp from 'pkg-up'
-import {_findConfigFile} from './_findConfigFile'
+import {findConfigFile} from './findConfigFile'
 import {PkgConfigOptions} from './types'
 
 /** @internal */
-export async function _loadConfig(options: {cwd: string}): Promise<PkgConfigOptions | undefined> {
+export async function loadConfig(options: {cwd: string}): Promise<PkgConfigOptions | undefined> {
   const {cwd} = options
 
   const pkgPath = await pkgUp({cwd})
@@ -14,7 +14,7 @@ export async function _loadConfig(options: {cwd: string}): Promise<PkgConfigOpti
 
   const root = path.dirname(pkgPath)
 
-  const configFile = await _findConfigFile(root)
+  const configFile = await findConfigFile(root)
 
   if (!configFile) {
     return undefined

package/src/node/{_core/config/_resolveConfigProperty.ts → core/config/resolveConfigProperty.ts}

@@ -1,7 +1,7 @@
 import {PkgConfigProperty, PkgConfigPropertyResolver} from './types'
 
 /** @internal */
-export function _resolveConfigProperty<T>(
+export function resolveConfigProperty<T>(
   prop: PkgConfigProperty<T> | undefined,
   initialValue: T
 ): T {

package/src/node/{_core/_constants.ts → core/constants.ts}

@@ -1,5 +1,5 @@
 /** @internal */
-export const _MODULE_EXT: Record<'commonjs' | 'module', {commonjs: string; esm: string}> = {
+export const MODULE_EXT: Record<'commonjs' | 'module', {commonjs: string; esm: string}> = {
   // pkg.type: "commonjs"
   commonjs: {
     commonjs: '.js',

package/src/node/{_core → core}/contexts/buildContext.ts

@@ -1,22 +1,22 @@
 import ts from 'typescript'
 import {PkgExports, PkgRuntime, PkgConfigOptions} from '../config'
-import {_PackageJSON} from '../pkg'
+import {PackageJSON} from '../pkg'
 
 /** @internal */
-export interface _BuildFile {
+export interface BuildFile {
   type: 'asset' | 'chunk' | 'types'
   path: string
 }
 
 /** @internal */
-export interface _BuildContext {
+export interface BuildContext {
   config?: PkgConfigOptions
   cwd: string
   distPath: string
   emitDeclarationOnly: boolean
   exports: PkgExports | undefined
   external: string[]
-  files: _BuildFile[]
+  files: BuildFile[]
   logger: {
     log: (...args: unknown[]) => void
     info: (...args: unknown[]) => void
@@ -24,7 +24,7 @@ export interface _BuildContext {
     error: (...args: unknown[]) => void
     success: (...args: unknown[]) => void
   }
-  pkg: _PackageJSON
+  pkg: PackageJSON
   runtime: PkgRuntime
   strict: boolean
   target: Record<PkgRuntime, string[]>

package/src/node/core/defaults.ts

@@ -0,0 +1,7 @@
+/** @public */
+export const DEFAULT_BROWSERSLIST_QUERY = [
+  '> 0.2% and supports es6-module and supports es6-module-dynamic-import',
+  'not dead',
+  'not IE 11',
+  'maintained node versions',
+]

package/src/node/core/findCommonPath.test.ts

@@ -0,0 +1,9 @@
+import {expect, test} from 'vitest'
+import {findCommonDirPath} from './findCommonPath'
+
+test('should find common parent directory of paths', () => {
+  expect(findCommonDirPath(['test/a', 'test/b/a'])).toBe('test')
+  expect(findCommonDirPath(['/test/a', '/test/b/a'])).toBe('/test')
+  expect(findCommonDirPath(['/test/a/b', '/test/a/b/c'])).toBe('/test/a')
+  expect(findCommonDirPath(['test/a/b', 'test/a/b', 'test/b/c', 'test/b/a'])).toBe('test')
+})

package/src/node/{_core/_findCommonPath.ts → core/findCommonPath.ts}

@@ -1,10 +1,10 @@
 import path from 'path'
 
-export function _pathContains(containerPath: string, itemPath: string): boolean {
+export function pathContains(containerPath: string, itemPath: string): boolean {
   return !path.relative(containerPath, itemPath).startsWith('..')
 }
 
-export function _findCommonDirPath(filePaths: string[]): string | undefined {
+export function findCommonDirPath(filePaths: string[]): string | undefined {
   let ret: string | undefined = undefined
 
   for (const filePath of filePaths) {
@@ -22,7 +22,7 @@ export function _findCommonDirPath(filePaths: string[]): string | undefined {
         break
       }
 
-      if (_pathContains(dirPath, ret)) {
+      if (pathContains(dirPath, ret)) {
         ret = dirPath
         break
       }

package/src/node/{_core → core}/index.ts

@@ -1,6 +1,6 @@
-export * from './_constants'
-export * from './_defaults'
-export * from './_isRecord'
+export * from './constants'
+export * from './defaults'
+export * from './isRecord'
 export * from './config'
 export * from './contexts'
 export * from './pkg'

package/src/node/{_core/_isRecord.ts → core/isRecord.ts}

@@ -1,4 +1,4 @@
 /** @internal */
-export function _isRecord(value: unknown): value is Record<string, unknown> {
+export function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && !Array.isArray(value) && typeof value === 'object'
 }

package/src/node/core/pkg/index.ts

@@ -0,0 +1,4 @@
+export * from './loadPkg'
+export * from './loadPkgWithReporting'
+export * from './parseExports'
+export * from './types'

package/src/node/{_core/pkg/_loadPkg.ts → core/pkg/loadPkg.ts}

@@ -1,10 +1,10 @@
 import fs from 'fs/promises'
 import pkgUp from 'pkg-up'
-import {_PackageJSON} from './_types'
-import {_validatePkg} from './_validatePkg'
+import {PackageJSON} from './types'
+import {validatePkg} from './validatePkg'
 
 /** @internal */
-export async function _loadPkg(options: {cwd: string}): Promise<_PackageJSON> {
+export async function loadPkg(options: {cwd: string}): Promise<PackageJSON> {
   const {cwd} = options
 
   const pkgPath = await pkgUp({cwd})
@@ -13,5 +13,5 @@ export async function _loadPkg(options: {cwd: string}): Promise<_PackageJSON> {
 
   const buf = await fs.readFile(pkgPath)
 
-  return _validatePkg(JSON.parse(buf.toString()))
+  return validatePkg(JSON.parse(buf.toString()))
 }

package/src/node/{_core/pkg/_loadPkgWithReporting.ts → core/pkg/loadPkgWithReporting.ts}

@@ -2,20 +2,20 @@
 
 import chalk from 'chalk'
 import {ZodError} from 'zod'
-import {_loadPkg} from './_loadPkg'
-import {_PackageJSON} from './_types'
+import {loadPkg} from './loadPkg'
+import {PackageJSON} from './types'
 
 /** @internal */
-export async function _loadPkgWithReporting(options: {cwd: string}): Promise<_PackageJSON> {
+export async function loadPkgWithReporting(options: {cwd: string}): Promise<PackageJSON> {
   try {
-    return await _loadPkg(options)
+    return await loadPkg(options)
   } catch (err) {
     if (err instanceof ZodError) {
       for (const issue of err.issues) {
         if (issue.code === 'invalid_type') {
           console.log(
             [
-              `${chalk.red('fail')}   \`${_formatPath(issue.path)}\` `,
+              `${chalk.red('fail')}   \`${formatPath(issue.path)}\` `,
               `in ./package.json must be of type ${chalk.magenta(issue.expected)} `,
               `(received ${chalk.magenta(issue.received)})`,
             ].join('')
@@ -30,7 +30,7 @@ export async function _loadPkgWithReporting(options: {cwd: string}): Promise<_Pa
   }
 }
 
-function _formatPath(segments: Array<string | number>) {
+function formatPath(segments: Array<string | number>) {
   return segments
     .map((s, idx) => {
       if (idx === 0) return s

package/src/node/{_core/pkg/_parseExports.ts → core/pkg/parseExports.ts}

@@ -1,11 +1,11 @@
-import {_isRecord} from '../_isRecord'
 import {PkgExport} from '../config'
-import {_PackageJSON} from './_types'
-import {_validateExports} from './_validateExports'
+import {isRecord} from '../isRecord'
+import {PackageJSON} from './types'
+import {validateExports} from './validateExports'
 
 /** @internal */
-export function _parseExports(options: {
-  pkg: _PackageJSON
+export function parseExports(options: {
+  pkg: PackageJSON
   strict: boolean
 }): (PkgExport & {_path: string})[] {
   const {pkg, strict} = options
@@ -41,7 +41,7 @@ export function _parseExports(options: {
             errors.push('package.json: `exports["./package.json"] must be "./package.json".')
           }
         }
-      } else if (_isRecord(exportEntry)) {
+      } else if (isRecord(exportEntry)) {
         if (exportPath === '.') {
           if (
             exportEntry.require &&
@@ -89,7 +89,7 @@ export function _parseExports(options: {
 
   const _exports = [rootExport, ...extraExports]
 
-  errors.push(..._validateExports(_exports, {pkg}))
+  errors.push(...validateExports(_exports, {pkg}))
 
   if (errors.length) {
     throw new Error('\n- ' + errors.join('\n- '))

package/src/node/{_core/pkg/_types.ts → core/pkg/types.ts}

@@ -1,5 +1,5 @@
 /** @internal */
-export interface _PackageJSON {
+export interface PackageJSON {
   type: 'commonjs' | 'module'
   version: string
   private?: boolean

package/src/node/{_core/pkg/_validateExports.ts → core/pkg/validateExports.ts}

@@ -1,13 +1,13 @@
-import {_MODULE_EXT} from '../_constants'
 import {PkgExport} from '../config'
-import {_PackageJSON} from './_types'
+import {MODULE_EXT} from '../constants'
+import {PackageJSON} from './types'
 
-export function _validateExports(
+export function validateExports(
   _exports: (PkgExport & {_path: string})[],
-  options: {pkg: _PackageJSON}
+  options: {pkg: PackageJSON}
 ): string[] {
   const {pkg} = options
-  const ext = _MODULE_EXT[pkg.type]
+  const ext = MODULE_EXT[pkg.type]
 
   const errors: string[] = []
 

package/src/node/{_core/pkg/_validatePkg.ts → core/pkg/validatePkg.ts}

@@ -1,5 +1,5 @@
 import {z} from 'zod'
-import {_PackageJSON} from './_types'
+import {PackageJSON} from './types'
 
 const pkgSchema = z.object({
   type: z.optional(z.enum(['commonjs', 'module'])),
@@ -46,7 +46,7 @@ const pkgSchema = z.object({
   browserslist: z.optional(z.array(z.string())),
 })
 
-export function _validatePkg(input: unknown): _PackageJSON {
+export function validatePkg(input: unknown): PackageJSON {
   const pkg = pkgSchema.parse(input)
 
   return {...pkg, type: pkg.type || 'commonjs'}

package/src/node/core/ts/index.ts

@@ -0,0 +1 @@
+export * from './loadTSConfig'

package/src/node/{_core/ts/_loadTSConfig.ts → core/ts/loadTSConfig.ts}

@@ -1,7 +1,7 @@
 import ts from 'typescript'
 
 /** @internal */
-export async function _loadTSConfig(options: {
+export async function loadTSConfig(options: {
   cwd: string
   tsconfigPath: string
 }): Promise<ts.ParsedCommandLine> {

package/src/node/{_getFilesize.ts → getFilesize.ts}

@@ -1,7 +1,7 @@
 import {statSync} from 'fs'
 import prettyBytes from 'pretty-bytes'
 
-export function _getFilesize(file: string): string {
+export function getFilesize(file: string): string {
   const stats = statSync(file)
 
   return prettyBytes(stats.size)

package/src/node/globFiles.ts

@@ -0,0 +1,5 @@
+import globby from 'globby'
+
+export function globFiles(patterns: string[]): Promise<string[]> {
+  return globby(patterns)
+}

package/src/node/index.ts

@@ -1,6 +1,6 @@
-export * from './_core'
-export * from './_resolveBuildTasks'
-export * from './_tasks'
+export * from './core'
+export * from './resolveBuildTasks'
+export * from './tasks'
 export * from './build'
 export * from './check'
 export * from './watch'