@sanity/pkg-utils 7.2.10-canary.0 → 7.2.10-canary.2

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

@@ -1,165 +0,0 @@
-import path from 'node:path'
-import type {ExtractorMessage} from '@microsoft/api-extractor'
-import chalk from 'chalk'
-import * as rimraf from 'rimraf'
-import {Observable} from 'rxjs'
-import ts from 'typescript'
-import {printExtractMessages} from '../../printExtractMessages'
-import type {TaskHandler} from '../types'
-import {buildTypes} from './buildTypes'
-import {DtsError} from './DtsError'
-import {extractTypes} from './extractTypes'
-import type {DtsResult, DtsWatchTask} from './types'
-
-/** @internal */
-export const dtsWatchTask: TaskHandler<DtsWatchTask, DtsResult> = {
-  name: (_ctx, task) =>
-    [
-      'build type definitions',
-      ...task.entries.map((entry) => {
-        return entry.targetPaths.map((targetPath) => {
-          return [
-            `    - ${chalk.cyan(entry.importId)}: `,
-            `${chalk.yellow(entry.sourcePath)} ${chalk.gray('→')} ${chalk.yellow(targetPath)}`,
-          ].join('')
-        })
-      }),
-    ].join('\n'),
-  exec: (ctx, task) => {
-    const {config, cwd, files, logger, strict, ts: tsContext, bundledPackages} = ctx
-
-    return new Observable((observer) => {
-      if (!tsContext.config || !tsContext.configPath) {
-        observer.next({type: 'dts', messages: [], results: []})
-        observer.complete()
-
-        return
-      }
-
-      const {outDir, rootDir = cwd} = tsContext.config.options
-
-      if (!outDir) {
-        observer.error(new Error('tsconfig.json is missing `compilerOptions.outDir`'))
-
-        return
-      }
-
-      const tmpPath = path.resolve(outDir, '__tmp__')
-
-      buildTypes({
-        cwd,
-        logger,
-        outDir: tmpPath,
-        tsconfig: tsContext.config,
-        strict,
-      }).catch((err) => {
-        observer.error(err)
-      })
-
-      const host = ts.createWatchCompilerHost(
-        tsContext.configPath,
-        {
-          ...tsContext.config.options,
-          declaration: true,
-          declarationDir: tmpPath,
-          emitDeclarationOnly: true,
-          noEmit: false,
-          noEmitOnError: strict ? true : (tsContext.config.options.noEmitOnError ?? true),
-          outDir: tmpPath,
-        },
-        ts.sys,
-        ts.createEmitAndSemanticDiagnosticsBuilderProgram,
-        (diagnostic) => {
-          logger.error(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'))
-        },
-        (diagnostic) => {
-          logger.info(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'))
-        },
-      )
-
-      const origPostProgramCreate = host.afterProgramCreate
-
-      host.afterProgramCreate = async (program) => {
-        origPostProgramCreate?.(program)
-
-        const messages: ExtractorMessage[] = []
-        const results: {sourcePath: string; filePaths: string[]}[] = []
-
-        for (const entry of task.entries) {
-          const exportPath = entry.exportPath === '.' ? './index' : entry.exportPath
-
-          const sourceTypesPath = path.resolve(
-            tmpPath,
-            path.relative(rootDir, path.resolve(cwd, entry.sourcePath)).replace(/\.ts$/, '.d.ts'),
-          )
-
-          const targetPaths = entry.targetPaths.map((targetPath) => path.resolve(cwd, targetPath))
-          const filePaths = targetPaths.map((targetPath) => path.relative(outDir, targetPath))
-
-          try {
-            const result = await extractTypes({
-              bundledPackages: bundledPackages || [],
-              customTags: config?.extract?.customTags,
-              cwd,
-              distPath: outDir,
-              exportPath,
-              files,
-              filePaths,
-              projectPath: cwd,
-              rules: config?.extract?.rules,
-              sourceTypesPath: sourceTypesPath,
-              tsconfig: tsContext.config!,
-              tmpPath,
-              tsconfigPath: path.resolve(cwd, tsContext.configPath || 'tsconfig.json'),
-              extractorDisabled: config?.extract?.enabled === false,
-            })
-
-            messages.push(...result.messages)
-            results.push({sourcePath: path.resolve(cwd, entry.sourcePath), filePaths: targetPaths})
-          } catch (err) {
-            if (err instanceof DtsError) {
-              messages.push(...err.messages)
-            } else {
-              observer.error(err)
-
-              return
-            }
-          }
-        }
-
-        observer.next({type: 'dts', messages, results})
-      }
-
-      const watchProgram = ts.createWatchProgram(host)
-
-      return () => {
-        watchProgram.close()
-        rimraf.sync(tmpPath)
-      }
-    })
-  },
-  complete: (ctx, task, result) => {
-    const {logger} = ctx
-
-    printExtractMessages(ctx, result.messages)
-
-    logger.success(
-      `build type definitions\n       ${task.entries
-        .map(
-          (entry) =>
-            `    - ${chalk.cyan(entry.importId)}: ${chalk.yellow(entry.sourcePath)} ${chalk.gray('→')} ${chalk.yellow(entry.targetPaths.join(', '))}`,
-        )
-        .join('\n       ')}`,
-    )
-    logger.log('')
-  },
-  error: (ctx, _task, err) => {
-    const {logger} = ctx
-
-    if (err instanceof DtsError) {
-      printExtractMessages(ctx, err.messages)
-    } else if (err instanceof Error) {
-      logger.error(err)
-    }
-  },
-}

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

@@ -1,45 +0,0 @@
-import type {File} from '@babel/types'
-import type {ExtractorResult} from '@microsoft/api-extractor'
-import {parse, print} from 'recast'
-import typeScriptParser from 'recast/parsers/typescript.js'
-import type {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

@@ -1,128 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import {
-  Extractor,
-  ExtractorConfig,
-  type ExtractorMessage,
-  type ExtractorResult,
-} from '@microsoft/api-extractor'
-import {mkdirp} from 'mkdirp'
-import * as prettier from 'prettier'
-import type ts from 'typescript'
-import type {PkgConfigOptions} from '../../core/config/types'
-import type {BuildFile} from '../../core/contexts/buildContext'
-import {createApiExtractorConfig} from './createApiExtractorConfig'
-import {createTSDocConfig} from './createTSDocConfig'
-import {extractModuleBlocksFromTypes} from './extractModuleBlocks'
-import {getExtractMessagesConfig} from './getExtractMessagesConfig'
-
-export async function extractTypes(options: {
-  bundledPackages?: string[]
-  customTags: NonNullable<PkgConfigOptions['extract']>['customTags']
-  cwd: string
-  distPath: string
-  exportPath: string
-  filePaths: string[]
-  files: BuildFile[]
-  projectPath: string
-  rules?: NonNullable<PkgConfigOptions['extract']>['rules']
-  sourceTypesPath: string
-  tmpPath: string
-  tsconfig: ts.ParsedCommandLine
-  tsconfigPath: string
-  /**
-   * If the extractor is disabled then it means API Extractor is only used to bundle dts, and not check tsdoc release tags.
-   */
-  extractorDisabled: boolean
-}): Promise<{extractorResult: ExtractorResult; messages: ExtractorMessage[]}> {
-  const {
-    bundledPackages,
-    customTags,
-    distPath,
-    exportPath,
-    files,
-    filePaths,
-    projectPath,
-    rules,
-    sourceTypesPath,
-    tmpPath,
-    tsconfig,
-    tsconfigPath,
-    extractorDisabled,
-  } = options
-
-  const tsdocConfigFile = await createTSDocConfig({
-    customTags: customTags || [],
-  })
-
-  const filePath = filePaths[0].replace(/\.d\.[mc]ts$/, '.d.ts')
-  // If there are package.config.ts `bundles` we might not have something that should leave behind a `.d.ts` file and need to handle that
-  const shouldCleanUpDts = !filePaths.includes(filePath)
-  const extractorConfig: ExtractorConfig = ExtractorConfig.prepare({
-    configObject: createApiExtractorConfig({
-      bundledPackages,
-      distPath,
-      exportPath,
-      filePath,
-      messages: getExtractMessagesConfig({rules, disabled: extractorDisabled}),
-      projectFolder: projectPath,
-      mainEntryPointFilePath: sourceTypesPath,
-      tsconfig,
-      tsconfigPath,
-      dtsRollupEnabled: true,
-    }),
-    configObjectFullPath: undefined,
-    tsdocConfigFile,
-    packageJsonFullPath: path.resolve(projectPath, 'package.json'),
-  })
-
-  const messages: ExtractorMessage[] = []
-
-  // Invoke API Extractor
-  const extractorResult = Extractor.invoke(extractorConfig, {
-    // Equivalent to the "--local" command-line parameter
-    localBuild: true,
-    // Equivalent to the "--verbose" command-line parameter
-    showVerboseMessages: true,
-    // handle messages
-    messageCallback(message: ExtractorMessage) {
-      messages.push(message)
-      message.handled = true
-    },
-  })
-
-  const typesPath = path.resolve(distPath, filePath)
-  const typesBuf = await fs.readFile(typesPath)
-  const prettierConfig = await prettier.resolveConfig(typesPath)
-
-  await mkdirp(path.dirname(typesPath))
-
-  const moduleBlocks = await extractModuleBlocksFromTypes({
-    extractResult: extractorResult,
-    tsOutDir: tmpPath,
-  })
-
-  const code = [typesBuf.toString(), ...moduleBlocks].join('\n\n')
-  const prettyCode = await prettier.format(code, {
-    ...prettierConfig,
-    filepath: typesPath,
-  })
-
-  for (const expFilePath of filePaths) {
-    const expTypesPath = path.resolve(distPath, expFilePath)
-
-    await fs.writeFile(expTypesPath, prettyCode)
-
-    // Add to `files` in context
-    files.push({
-      type: 'types',
-      path: expTypesPath,
-    })
-  }
-
-  if (shouldCleanUpDts) {
-    await fs.unlink(typesPath)
-  }
-
-  return {extractorResult, messages}
-}

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

@@ -1,109 +0,0 @@
-import type {ExtractorLogLevel, IExtractorMessagesConfig} from '@microsoft/api-extractor'
-import type {PkgConfigOptions, PkgRuleLevel} from '../../core/config/types'
-
-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,
-}
-
-/** @alpha */
-export function getExtractMessagesConfig(options: {
-  rules: NonNullable<PkgConfigOptions['extract']>['rules']
-  disabled?: boolean
-}): IExtractorMessagesConfig {
-  const {rules, disabled = false} = 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: (disabled ? 'none' : 'warning') as ExtractorLogLevel,
-      },
-    },
-
-    extractorMessageReporting: disabled
-      ? {
-          default: {
-            logLevel: 'none' as ExtractorLogLevel,
-            addToApiReportFile: false,
-          },
-        }
-      : {
-          'default': {
-            logLevel: 'warning' as ExtractorLogLevel,
-            addToApiReportFile: false,
-          },
-
-          'ae-forgotten-export': {
-            /**
-             * This is hardcoded to `none` as it's no longer needed since TypeScript 5.5 https://github.com/microsoft/TypeScript/issues/42873
-             * It's hardcoded to `none` since supported by API Extractor when using `module: 'Preserve'` doesn't support it well since `@microsoft/api-extractor` v7.49.0, which upgraded from TS 5.4 to 5.7 internally
-             */
-            logLevel: 'none' 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: disabled
-      ? {
-          default: {
-            logLevel: 'none' as ExtractorLogLevel,
-            addToApiReportFile: false,
-          },
-        }
-      : {
-          '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/getTargetPaths.ts

@@ -1,72 +0,0 @@
-import type {PkgBundle, PkgExport} from '../../core/config/types'
-import type {PackageJSON} from '../../core/pkg/types'
-
-/** @internal */
-export const fileEnding = /\.[mc]?js$/
-/** @internal */
-export const dtsEnding = '.d.ts' as const
-/** @internal */
-export const defaultEnding = '.js' as const
-/** @internal */
-export const mjsEnding = '.mjs' as const
-/** @internal */
-export const cjsEnding = '.cjs' as const
-const mtsEnding = '.d.mts' as const
-const ctsEnding = '.d.cts' as const
-
-/** @internal */
-export function getTargetPaths(
-  _type: PackageJSON['type'],
-  expOrBundle: PkgExport | PkgExport['browser'] | PkgExport['node'] | PkgBundle,
-): string[] {
-  const type = (_type === 'module' ? 'module' : 'commonjs') satisfies PackageJSON['type']
-
-  const set = new Set<string>()
-
-  if (expOrBundle?.import) {
-    set.add(expOrBundle.import.replace(fileEnding, type === 'module' ? dtsEnding : mtsEnding))
-  }
-
-  if (expOrBundle?.require) {
-    set.add(expOrBundle.require.replace(fileEnding, type === 'commonjs' ? dtsEnding : ctsEnding))
-  }
-
-  if (isPkgExport(expOrBundle)) {
-    if (!expOrBundle.browser?.source) {
-      if (expOrBundle.browser?.import) {
-        set.add(
-          expOrBundle.browser.import.replace(fileEnding, type === 'module' ? dtsEnding : mtsEnding),
-        )
-      }
-
-      if (expOrBundle.browser?.require) {
-        set.add(
-          expOrBundle.browser.require.replace(
-            fileEnding,
-            type === 'commonjs' ? dtsEnding : ctsEnding,
-          ),
-        )
-      }
-    }
-
-    if (!expOrBundle.node?.source) {
-      if (expOrBundle.node?.import) {
-        set.add(
-          expOrBundle.node.import.replace(fileEnding, type === 'module' ? dtsEnding : mtsEnding),
-        )
-      }
-
-      if (expOrBundle.node?.require) {
-        set.add(
-          expOrBundle.node.require.replace(fileEnding, type === 'commonjs' ? dtsEnding : ctsEnding),
-        )
-      }
-    }
-  }
-
-  return Array.from(set)
-}
-
-function isPkgExport(exp: any): exp is PkgExport {
-  return exp?.browser || exp?.node || exp?.default
-}

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

@@ -1,42 +0,0 @@
-import path from 'node:path'
-import chalk from 'chalk'
-import ts from 'typescript'
-import type {Logger} from '../../logger'
-
-export function printDiagnostic(options: {
-  cwd: string
-  logger: Logger
-  diagnostic: ts.Diagnostic
-}): void {
-  const {cwd, logger, diagnostic} = options
-
-  if (diagnostic.file && diagnostic.start) {
-    const {line, character} = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start)
-    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n')
-
-    const file = path.relative(cwd, diagnostic.file.fileName)
-
-    const output = [
-      `${chalk.yellow(file)}:${chalk.blue(line + 1)}:${chalk.blue(character + 1)} - `,
-      `${chalk.gray(`TS${diagnostic.code}:`)} ${message}`,
-    ].join('')
-
-    if (diagnostic.category === ts.DiagnosticCategory.Error) {
-      logger.error(output)
-    }
-
-    if (diagnostic.category === ts.DiagnosticCategory.Warning) {
-      logger.warn(output)
-    }
-
-    if (diagnostic.category === ts.DiagnosticCategory.Message) {
-      logger.log(output)
-    }
-
-    if (diagnostic.category === ts.DiagnosticCategory.Suggestion) {
-      logger.log(output)
-    }
-  } else {
-    logger.log(ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n'))
-  }
-}

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

@@ -1,30 +0,0 @@
-import type {ExtractorMessage} from '@microsoft/api-extractor'
-
-/** @internal */
-export interface DtsWatchTask {
-  type: 'watch:dts'
-  entries: {
-    exportPath: string
-    importId: string
-    sourcePath: string
-    targetPaths: string[]
-  }[]
-}
-
-/** @internal */
-export interface DtsTask {
-  type: 'build:dts'
-  entries: {
-    exportPath: string
-    importId: string
-    sourcePath: string
-    targetPaths: string[]
-  }[]
-}
-
-/** @internal */
-export interface DtsResult {
-  type: 'dts'
-  messages: ExtractorMessage[]
-  results: {sourcePath: string; filePaths: string[]}[]
-}

package/src/node/tasks/index.ts

@@ -1,19 +0,0 @@
-import {dtsTask} from './dts/dtsTask'
-import {dtsWatchTask} from './dts/dtsWatchTask'
-import {rolldownDtsTask} from './rolldown/rolldownDtsTask'
-import {rollupTask} from './rollup/rollupTask'
-import {rollupWatchTask} from './rollup/rollupWatchTask'
-import type {BuildTaskHandlers, WatchTaskHandlers} from './types'
-
-/** @internal */
-export const buildTaskHandlers: BuildTaskHandlers = {
-  'build:dts': dtsTask,
-  'build:js': rollupTask,
-  'rolldown:dts': rolldownDtsTask,
-}
-
-/** @internal */
-export const watchTaskHandlers: WatchTaskHandlers = {
-  'watch:dts': dtsWatchTask,
-  'watch:js': rollupWatchTask,
-}