@sanity/pkg-utils 1.13.0 → 1.15.0

package/dist/index.js

@@ -4,15 +4,15 @@ Object.defineProperty(exports, '__esModule', {
   value: true
 });
 
-var _resolveBuildContext = require('./_chunks/_resolveBuildContext-ef196a3e.js');
+var _resolveBuildContext = require('./_chunks/_resolveBuildContext-0e601cff.js');
 
-var build = require('./_chunks/build-36a16057.js');
+var build = require('./_chunks/build-3762711f.js');
 
-var index = require('./_chunks/index-340fbb6a.js');
+var index = require('./_chunks/index-00a76fd5.js');
 
-var check = require('./_chunks/check-7d728336.js');
+var check = require('./_chunks/check-e60e8979.js');
 
-var watch = require('./_chunks/watch-41c2ea71.js');
+var watch = require('./_chunks/watch-69b1e41c.js');
 
 require('path');
 
@@ -98,6 +98,7 @@ 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;

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,YAAT,CAAsBC,aAAtB,EAAqC;EAC1C,OAAOA,aAAP;AACF;;;;;;;;;;;;;;;;;;;;;"}
+{"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,YAAT,CAAsBC,aAAtB,EAAqC;EAC1C,OAAOA,aAAP;AACF;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/pkg-utils",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "author": "Sanity.io <hello@sanity.io>",
   "license": "MIT",
   "description": "Simple utilities for modern npm packages.",

package/src/cli/buildAction.ts

@@ -1,10 +1,11 @@
 import {build} from '../node/build'
 import {_handleError} from './_handleError'
 
-export async function buildAction(options: {tsconfig?: string}): Promise<void> {
+export async function buildAction(options: {strict?: boolean; tsconfig?: string}): Promise<void> {
   try {
     await build({
       cwd: process.cwd(),
+      strict: options.strict,
       tsconfig: options.tsconfig,
     })
   } catch (err) {

package/src/cli/index.ts

@@ -16,6 +16,7 @@ cli
 
 cli
   .command('build', 'Build package')
+  .option('--strict', 'Strict mode')
   .option('--tsconfig [tsconfig]', '[string] tsconfig.json')
   .action(async (options) => {
     const {buildAction} = await import('./buildAction')
@@ -25,6 +26,7 @@ cli
 
 cli
   .command('watch', 'Watch package')
+  .option('--strict', 'Strict mode')
   .option('--tsconfig [tsconfig]', '[string] tsconfig.json')
   .action(async (options) => {
     const {watchAction} = await import('./watchAction')

package/src/cli/watchAction.ts

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

package/src/node/_core/config/types.ts

@@ -56,15 +56,25 @@ export interface PkgExports {
 /** @public */
 export type PkgRuleLevel = 'error' | 'warn' | 'info' | 'off'
 
+/** @public */
+export interface TSDocCustomTag {
+  name: string
+  syntaxKind: 'block' | 'modifier'
+  allowMultiple?: boolean
+}
+
 /** @public */
 export interface PkgConfigOptions {
   bundles?: PkgBundle[]
+  /** @alpha */
+  define?: Record<string, string | number | boolean | undefined | null>
   /**
    * Directory of distributed & bundled files.
    */
   dist?: string
   exports?: PkgConfigProperty<PkgExports>
   extract?: {
+    customTags?: TSDocCustomTag[]
     rules?: {
       'ae-forgotten-export'?: PkgRuleLevel
       'ae-incompatible-release-tags'?: PkgRuleLevel
@@ -102,7 +112,7 @@ export interface PkgConfigOptions {
   minify?: boolean
   /** @alpha */
   rollup?: {
-    plugins?: RollupPlugin[]
+    plugins?: PkgConfigProperty<RollupPlugin[]>
   }
   /**
    * Default runtime of package exports
@@ -113,4 +123,5 @@ export interface PkgConfigOptions {
    * Directory of source files.
    */
   src?: string
+  tsconfig?: string
 }

package/src/node/_core/contexts/buildContext.ts

@@ -25,6 +25,7 @@ export interface _BuildContext {
   }
   pkg: _PackageJSON
   runtime: PkgRuntime
+  strict: boolean
   target: Record<PkgRuntime, string[]>
   ts: {
     config?: ts.ParsedCommandLine

package/src/node/_resolveBuildContext.ts

@@ -42,9 +42,10 @@ export async function _resolveBuildContext(options: {
   config?: PkgConfigOptions
   cwd: string
   pkg: _PackageJSON
+  strict: boolean
   tsconfig: string
 }): Promise<_BuildContext> {
-  const {config, cwd, pkg, tsconfig: tsconfigPath} = options
+  const {config, cwd, pkg, strict, tsconfig: tsconfigPath} = options
   const logger = _createLogger()
   const tsconfig = await _loadTSConfig({cwd, tsconfigPath})
   const targetVersions = _resolveBrowserslistVersions(pkg.browserslist || _DEFAULTS.browserslist)
@@ -134,6 +135,7 @@ export async function _resolveBuildContext(options: {
     logger,
     pkg,
     runtime: config?.runtime ?? '*',
+    strict,
     target,
     ts: {
       config: tsconfig,

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

@@ -13,8 +13,9 @@ export async function _buildTypes(options: {
   cwd: string
   outDir: string
   tsconfig: ts.ParsedCommandLine
+  strict: boolean
 }): Promise<void> {
-  const {outDir, tsconfig} = options
+  const {outDir, tsconfig, strict = false} = options
 
   const compilerOptions: ts.CompilerOptions = {
     ...tsconfig.options,
@@ -49,7 +50,9 @@ export async function _buildTypes(options: {
     if (errors.length) {
       console.error(ts.formatDiagnostics(errors, formatHost))
 
-      throw new Error('failed to compile')
+      if (strict) {
+        throw new Error('failed to compile TypeScript definitions')
+      }
     }
   }
 }

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

@@ -19,7 +19,7 @@ export async function _doExtract(
   ctx: _BuildContext,
   task: _DtsTask | _DtsWatchTask
 ): Promise<_DtsResult> {
-  const {config, cwd, files, ts} = ctx
+  const {config, cwd, files, strict, ts} = ctx
 
   if (!ts.config || !ts.configPath) {
     return {type: 'dts', messages: [], results: []}
@@ -33,7 +33,7 @@ export async function _doExtract(
 
   const tmpPath = path.resolve(outDir, '__tmp__')
 
-  await _buildTypes({cwd, outDir: tmpPath, tsconfig: ts.config})
+  await _buildTypes({cwd, outDir: tmpPath, strict, tsconfig: ts.config})
 
   const messages: ExtractorMessage[] = []
 
@@ -50,6 +50,7 @@ export async function _doExtract(
     const targetPath = path.resolve(cwd, entry.targetPath)
 
     const result = await _extractTypes({
+      customTags: config?.extract?.customTags,
       cwd,
       exportPath,
       files,

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

@@ -3,25 +3,18 @@ import path from 'path'
 import {
   Extractor,
   ExtractorConfig,
-  ExtractorLogLevel,
   ExtractorMessage,
   ExtractorResult,
-  IExtractorMessagesConfig,
 } from '@microsoft/api-extractor'
 import mkdirp from 'mkdirp'
 import prettier from 'prettier'
-import {PkgRuleLevel, PkgConfigOptions, _BuildFile} from '../../_core'
+import {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,
-}
+import {_getExtractMessagesConfig} from './_getExtractMessagesConfig'
 
 export async function _extractTypes(options: {
+  customTags: NonNullable<PkgConfigOptions['extract']>['customTags']
   cwd: string
   distPath: string
   exportPath: string
@@ -32,90 +25,28 @@ export async function _extractTypes(options: {
   sourceTypesPath: string
   tsconfigPath: string
 }): Promise<{extractorResult: ExtractorResult; messages: ExtractorMessage[]}> {
-  const {distPath, exportPath, files, filePath, projectPath, rules, sourceTypesPath, tsconfigPath} =
-    options
+  const {
+    customTags,
+    distPath,
+    exportPath,
+    files,
+    filePath,
+    projectPath,
+    rules,
+    sourceTypesPath,
+    tsconfigPath,
+  } = options
 
   const tsdocConfigFile = await _createTSDocConfig({
-    customTags: [],
+    customTags: 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: _ruleToLogLevel('tsdoc-link-tag-unescaped-text', 'warning' as ExtractorLogLevel),
-        addToApiReportFile: false,
-      },
-
-      'tsdoc-undefined-tag': {
-        logLevel: _ruleToLogLevel('tsdoc-undefined-tag', 'error' as ExtractorLogLevel),
-        addToApiReportFile: false,
-      },
-
-      'tsdoc-unsupported-tag': {
-        logLevel: _ruleToLogLevel('tsdoc-unsupported-tag', 'none' as ExtractorLogLevel),
-        addToApiReportFile: false,
-      },
-    },
-  }
-
   const extractorConfig: ExtractorConfig = ExtractorConfig.prepare({
     configObject: _createApiExtractorConfig({
       distPath,
       exportPath,
       filePath,
-      messages: messagesConfig,
+      messages: _getExtractMessagesConfig({rules}),
       projectFolder: projectPath,
       mainEntryPointFilePath: sourceTypesPath,
       tsconfigPath,

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

@@ -0,0 +1,87 @@
+import {ExtractorLogLevel, IExtractorMessagesConfig} from '@microsoft/api-extractor'
+import {PkgRuleLevel, PkgConfigOptions} from '../../_core'
+
+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,
+}
+
+/** @internal */
+export function _getExtractMessagesConfig(options: {
+  rules: NonNullable<PkgConfigOptions['extract']>['rules']
+}): IExtractorMessagesConfig {
+  const {rules} = options
+
+  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 {
+    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: _ruleToLogLevel('tsdoc-link-tag-unescaped-text', 'warning' as ExtractorLogLevel),
+        addToApiReportFile: false,
+      },
+
+      'tsdoc-undefined-tag': {
+        logLevel: _ruleToLogLevel('tsdoc-undefined-tag', 'error' as ExtractorLogLevel),
+        addToApiReportFile: false,
+      },
+
+      'tsdoc-unsupported-tag': {
+        logLevel: _ruleToLogLevel('tsdoc-unsupported-tag', 'none' as ExtractorLogLevel),
+        addToApiReportFile: false,
+      },
+    },
+  }
+}

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

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

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

@@ -5,10 +5,10 @@ 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 {InputOptions, OutputOptions, Plugin} from 'rollup'
 import esbuild from 'rollup-plugin-esbuild'
 import {terser} from 'rollup-plugin-terser'
-import {_BuildContext, _DEFAULTS, _MODULE_EXT} from '../../_core'
+import {_BuildContext, _DEFAULTS, _MODULE_EXT, _resolveConfigProperty} from '../../_core'
 import {_RollupTask, _RollupWatchTask} from '../_types'
 
 export interface _RollupConfig {
@@ -45,6 +45,94 @@ export function _resolveRollupConfig(
 
   const sourcePaths = _exports && Object.values(_exports).map((e) => path.resolve(cwd, e.source))
 
+  const replacements = Object.fromEntries(
+    Object.entries(config?.define || {}).map(([key, val]) => [key, JSON.stringify(val)])
+  )
+
+  const defaultPlugins = [
+    replace({
+      preventAssignment: true,
+      values: {
+        ...(pkg.name === '@sanity/pkg-utils'
+          ? {...replacements}
+          : {
+              'process.env.PKG_FILE_PATH': (arg) => {
+                const sourcePath = './' + path.relative(cwd, arg)
+                const entry = entries.find((e) => e.source === sourcePath)
+
+                if (!entry) {
+                  // eslint-disable-next-line no-console
+                  console.error(`could not find source entry: ${sourcePath}`)
+
+                  return 'null'
+                }
+
+                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),
+              ...replacements,
+            }),
+      },
+    }),
+    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({
+      jsx: config?.jsx ?? 'automatic',
+      jsxFactory: config?.jsxFactory ?? 'createElement',
+      jsxFragment: config?.jsxFragment ?? 'Fragment',
+      jsxImportSource: config?.jsxImportSource ?? 'react',
+      target,
+      tsconfig: ctx.ts.configPath || 'tsconfig.json',
+    }),
+    getBabelOutputPlugin({
+      babelrc: false,
+      plugins: ['@babel/plugin-proposal-object-rest-spread'],
+      presets: [['@babel/preset-env', {targets: pkg.browserslist || _DEFAULTS.browserslist}]],
+    }),
+    minify &&
+      terser({
+        output: {
+          comments: (_node, comment) => {
+            const text = comment.value
+            const type = comment.type
+
+            // Check if this is a multiline comment
+            if (type == 'comment2') {
+              // Keep licensing comments
+              return /@preserve|@license|@cc_on/i.test(text)
+            }
+
+            return false
+          },
+        },
+      }),
+  ].filter(Boolean) as Plugin[]
+
+  const userPlugins = config?.rollup?.plugins
+
+  const plugins = Array.isArray(userPlugins)
+    ? defaultPlugins.concat(userPlugins)
+    : _resolveConfigProperty(config?.rollup?.plugins, defaultPlugins)
+
   return {
     inputOptions: {
       context: cwd,
@@ -92,81 +180,7 @@ export function _resolveRollupConfig(
         }
       },
 
-      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({
-          jsx: config?.jsx ?? 'automatic',
-          jsxFactory: config?.jsxFactory ?? 'createElement',
-          jsxFragment: config?.jsxFragment ?? 'Fragment',
-          jsxImportSource: config?.jsxImportSource ?? 'react',
-          target,
-          tsconfig: ctx.ts.configPath || 'tsconfig.json',
-        }),
-        getBabelOutputPlugin({
-          babelrc: false,
-          plugins: ['@babel/plugin-proposal-object-rest-spread'],
-          presets: [['@babel/preset-env', {targets: pkg.browserslist || _DEFAULTS.browserslist}]],
-        }),
-        minify &&
-          terser({
-            output: {
-              comments: (_node, comment) => {
-                const text = comment.value
-                const type = comment.type
-
-                // Check if this is a multiline comment
-                if (type == 'comment2') {
-                  // Keep licensing comments
-                  return /@preserve|@license|@cc_on/i.test(text)
-                }
-
-                return false
-              },
-            },
-          }),
-
-        ...(config?.rollup?.plugins || []),
-      ].filter(Boolean),
+      plugins,
 
       treeshake: {
         propertyReadSideEffects: false,

package/src/node/build.ts

@@ -4,14 +4,36 @@ import {_resolveBuildTasks} from './_resolveBuildTasks'
 import {_spinner} from './_spinner'
 import {_BuildTask, _TaskHandler, _buildTaskHandlers} from './_tasks'
 
-/** @public */
-export async function build(options: {cwd: string; tsconfig?: string}): Promise<void> {
-  const {cwd, tsconfig = 'tsconfig.json'} = options
+/**
+ * Build the distribution files of a npm package.
+ *
+ * @example
+ * ```ts
+ * import {build} from '@sanity/pkg-utils'
+ *
+ * build({
+ *   cwd: process.cwd(),
+ *   tsconfig: 'tsconfig.dist.json,
+ * }).then(() => {
+ *   console.log('successfully built')
+ * }).catch((err) => {
+ *   console.log(`build error: ${err.message}`)
+ * })
+ * ```
+ *
+ * @public
+ */
+export async function build(options: {
+  cwd: string
+  strict?: boolean
+  tsconfig?: string
+}): Promise<void> {
+  const {cwd, strict = false, tsconfig: tsconfigOption} = options
 
   const pkg = await _loadPkgWithReporting({cwd})
   const config = await _loadConfig({cwd})
-
-  const ctx = await _resolveBuildContext({config, cwd, pkg, tsconfig})
+  const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'
+  const ctx = await _resolveBuildContext({config, cwd, pkg, strict, tsconfig})
 
   const buildTasks = _resolveBuildTasks(ctx)
 

package/src/node/check.ts

@@ -10,11 +10,12 @@ export async function check(options: {
   strict?: boolean
   tsconfig?: string
 }): Promise<void> {
-  const {cwd, strict, tsconfig = 'tsconfig.json'} = options
+  const {cwd, strict = false, tsconfig: tsconfigOption} = options
 
   const pkg = await _loadPkgWithReporting({cwd})
   const config = await _loadConfig({cwd})
-  const ctx = await _resolveBuildContext({config, cwd, pkg, tsconfig})
+  const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'
+  const ctx = await _resolveBuildContext({config, cwd, pkg, strict, tsconfig})
   const {logger} = ctx
 
   _printPackageTree(ctx)