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

package/src/node/init.ts

@@ -1,54 +0,0 @@
-import {lstat} from 'node:fs/promises'
-import {resolve} from 'node:path'
-import {mkdirp} from 'mkdirp'
-import {createFromTemplate} from './core/template'
-import {fileExists} from './fileExists'
-import {isEmptyDirectory} from './isEmptyDirectory'
-import {createLogger} from './logger'
-import {defaultTemplate} from './templates/default/template'
-
-/** @public */
-export async function init(options: {cwd: string; path: string}): Promise<void> {
-  if (!options.cwd) {
-    throw new Error('Missing required option: cwd')
-  }
-
-  if (!options.path) {
-    throw new Error('Missing required option: path')
-  }
-
-  const logger = createLogger()
-
-  const packagePath = resolve(options.cwd, options.path)
-
-  await ensurePackagePath(packagePath)
-
-  await createFromTemplate({
-    cwd: options.cwd,
-    logger,
-    template: defaultTemplate,
-    packagePath,
-  })
-}
-
-async function ensurePackagePath(packagePath: string): Promise<void> {
-  const exists = fileExists(packagePath)
-
-  if (!exists) {
-    await mkdirp(packagePath)
-
-    return
-  }
-
-  const dir = (await lstat(packagePath)).isDirectory()
-
-  if (!dir) {
-    throw new Error('the package path is a file, not a directory')
-  }
-
-  const empty = await isEmptyDirectory(packagePath)
-
-  if (!empty) {
-    throw new Error('the package directory is not empty')
-  }
-}

package/src/node/isEmptyDirectory.ts

@@ -1,5 +0,0 @@
-import {readdir} from 'node:fs/promises'
-
-export async function isEmptyDirectory(dirPath: string): Promise<boolean> {
-  return (await readdir(dirPath)).length === 0
-}

package/src/node/logger.ts

@@ -1,32 +0,0 @@
-// oxlint-disable no-console
-import chalk from 'chalk'
-
-/** @alpha */
-export interface Logger {
-  log: (...args: unknown[]) => void
-  info: (...args: unknown[]) => void
-  warn: (...args: unknown[]) => void
-  error: (...args: unknown[]) => void
-  success: (...args: unknown[]) => void
-}
-
-/** @alpha */
-export function createLogger(): Logger {
-  return {
-    log: (...args) => {
-      console.log(...args)
-    },
-    info: (...args) => {
-      console.log(chalk.blue('[info]'), ...args)
-    },
-    warn: (...args) => {
-      console.log(chalk.yellow('[warning]'), ...args)
-    },
-    error: (...args) => {
-      console.log(chalk.red('[error]'), ...args)
-    },
-    success: (...args) => {
-      console.log(chalk.green('[success]'), ...args)
-    },
-  }
-}

package/src/node/printExtractMessages.ts

@@ -1,59 +0,0 @@
-import path from 'node:path'
-import type {ExtractorMessage} from '@microsoft/api-extractor'
-import chalk from 'chalk'
-import type {BuildContext} from './core/contexts/buildContext'
-
-export function printExtractMessages(ctx: BuildContext, messages: ExtractorMessage[]): void {
-  const {cwd, logger} = ctx
-
-  const warnings = messages.filter((msg) => msg.logLevel === 'warning')
-
-  if (warnings.length) {
-    logger.log()
-  }
-
-  for (const msg of warnings) {
-    const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath)
-
-    if (msg.messageId === 'TS6307') {
-      // Ignore this warning:
-      // > TS6307: <filename> is not in project file list.
-      // > Projects must list all files or use an 'include' pattern.
-      continue
-    }
-
-    logger.log(
-      [
-        `${chalk.cyan(sourceFilePath || '?')}`,
-        `:${chalk.yellow(msg.sourceFileLine)}:${chalk.yellow(msg.sourceFileColumn)}`,
-        ` - ${chalk.yellow('warning')} ${chalk.gray(msg.messageId)}\n`,
-        msg.text,
-        '\n',
-      ].join(''),
-    )
-  }
-
-  const errors: ExtractorMessage[] = messages.filter((msg) => msg.logLevel === 'error')
-
-  if (!warnings.length && errors.length) {
-    logger.log('')
-  }
-
-  for (const msg of errors) {
-    const sourceFilePath = msg.sourceFilePath && path.relative(cwd, msg.sourceFilePath)
-
-    logger.log(
-      [
-        `${chalk.cyan(sourceFilePath || '?')}`,
-        `:${chalk.yellow(msg.sourceFileLine)}:${chalk.yellow(msg.sourceFileColumn)}`,
-        ` - ${chalk.red('error')} ${chalk.gray(msg.messageId)}\n`,
-        msg.text,
-        '\n',
-      ].join(''),
-    )
-  }
-
-  if (errors.length) {
-    process.exit(1)
-  }
-}

package/src/node/printPackageTree.ts

@@ -1,95 +0,0 @@
-import path from 'node:path'
-import chalk from 'chalk'
-import treeify from 'treeify'
-import type {PkgExport} from './core/config/types'
-import type {BuildContext} from './core/contexts/buildContext'
-import {fileExists} from './fileExists'
-import {getFilesize} from './getFilesize'
-
-function getFileInfo(cwd: string, filePath: string) {
-  const p = path.resolve(cwd, filePath)
-  const exists = fileExists(p)
-  const size = exists ? getFilesize(p) : undefined
-
-  return {exists, size}
-}
-
-export function printPackageTree(ctx: BuildContext): void {
-  const {cwd, exports, logger, pkg} = ctx
-
-  if (!exports) return
-
-  logger.log(`${chalk.blue(pkg.name)}@${chalk.green(pkg.version)}`)
-
-  const tree: Record<string, unknown> = {}
-
-  if (pkg.type) {
-    tree['type'] = chalk.yellow(pkg.type)
-  }
-
-  if (pkg.bin) {
-    tree['bin'] = Object.fromEntries(
-      Object.entries(pkg.bin).map(([name, file]) => [chalk.cyan(name), fileInfo(file)]),
-    )
-  }
-
-  function fileInfo(file: string) {
-    const info = getFileInfo(cwd, file)
-
-    if (!info.size) {
-      return `${chalk.gray(file)} ${chalk.red('does not exist')}`
-    }
-
-    return `${chalk.yellow(file)} ${chalk.gray(info.size)}`
-  }
-
-  tree['exports'] = Object.fromEntries(
-    Object.entries(exports)
-      .filter(([, entry]) => entry._exported)
-      .map(([exportPath, entry]) => {
-        const exp: Omit<PkgExport, '_exported'> = {
-          source: fileInfo(entry.source),
-          browser: undefined,
-          require: undefined,
-          node: undefined,
-          import: undefined,
-          default: fileInfo(entry.default),
-        }
-
-        if (entry.browser) {
-          exp.browser = {source: fileInfo(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)
-        } else {
-          delete exp.browser
-        }
-
-        if (entry.require) {
-          exp.require = fileInfo(entry.require)
-        } else {
-          delete exp.require
-        }
-
-        if (entry.node) {
-          exp.node = {}
-
-          if (entry.node.source) exp.node.source = fileInfo(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)
-        } else {
-          delete exp.node
-        }
-
-        if (entry.import) {
-          exp.import = fileInfo(entry.import)
-        } else {
-          delete exp.import
-        }
-
-        return [chalk.cyan(path.join(pkg.name, exportPath)), exp]
-      }),
-  )
-
-  logger.log(treeify.asTree(tree as Record<string, any>, true, true))
-}

package/src/node/resolveBrowserTarget.ts

@@ -1,17 +0,0 @@
-export function resolveBrowserTarget(versions: string[]): string[] | undefined {
-  const target: string[] = versions.filter(
-    (version) =>
-      version.startsWith('chrome') ||
-      version.startsWith('edge') ||
-      version.startsWith('firefox') ||
-      version.startsWith('ios') ||
-      version.startsWith('safari') ||
-      version.startsWith('opera'),
-  )
-
-  if (target.length === 0) {
-    return undefined
-  }
-
-  return target
-}

package/src/node/resolveBuildContext.ts

@@ -1,202 +0,0 @@
-import path from 'node:path'
-import browserslistToEsbuild from 'browserslist-to-esbuild'
-import {resolveConfigProperty} from './core/config/resolveConfigProperty'
-import {type PkgConfigOptions, type PkgExports, type PkgRuntime} from './core/config/types'
-import type {BuildContext} from './core/contexts/buildContext'
-import {DEFAULT_BROWSERSLIST_QUERY} from './core/defaults'
-import {findCommonDirPath, pathContains} from './core/findCommonPath'
-import {parseExports} from './core/pkg/parseExports'
-import type {PackageJSON} from './core/pkg/types'
-import {loadTSConfig} from './core/ts/loadTSConfig'
-import type {Logger} from './logger'
-import {resolveBrowserTarget} from './resolveBrowserTarget'
-import {resolveNodeTarget} from './resolveNodeTarget'
-import {parseStrictOptions} from './strict'
-
-export async function resolveBuildContext(options: {
-  config?: PkgConfigOptions
-  cwd: string
-  emitDeclarationOnly?: boolean
-  logger: Logger
-  pkg: PackageJSON
-  strict: boolean
-  tsconfig: string
-}): Promise<BuildContext> {
-  const {
-    config,
-    cwd,
-    emitDeclarationOnly = false,
-    logger,
-    pkg,
-    strict,
-    tsconfig: tsconfigPath,
-  } = options
-  const tsconfig = await loadTSConfig({cwd, tsconfigPath})
-  const strictOptions = parseStrictOptions(config?.strictOptions ?? {})
-
-  let browserslist = pkg.browserslist
-  if (!browserslist) {
-    if (strict && strictOptions.noImplicitBrowsersList !== 'off') {
-      if (strictOptions.noImplicitBrowsersList === 'error') {
-        throw new Error(
-          '\n- ' +
-            `package.json: "browserslist" is missing, set it to \`"browserslist": "extends @sanity/browserslist-config"\``,
-        )
-      } else {
-        logger.warn(
-          'Could not detect a `browserslist` property in `package.json`, using default configuration. Add `"browserslist": "extends @sanity/browserslist-config"` to silence this warning.',
-        )
-      }
-    }
-    browserslist = DEFAULT_BROWSERSLIST_QUERY
-  }
-  const targetVersions = browserslistToEsbuild(browserslist)
-
-  if (
-    strict &&
-    strictOptions.noImplicitSideEffects !== 'off' &&
-    typeof pkg.sideEffects === 'undefined'
-  ) {
-    const msg =
-      'package.json: `sideEffects` is missing, see https://webpack.js.org/guides/tree-shaking/#clarifying-tree-shaking-and-sideeffects for how to define `sideEffects`'
-
-    if (strictOptions.noImplicitSideEffects === 'error') {
-      throw new Error(msg)
-    } else {
-      logger.warn(msg)
-    }
-  }
-
-  const nodeTarget = resolveNodeTarget(targetVersions)
-  const webTarget = resolveBrowserTarget(targetVersions)
-
-  if (!nodeTarget) {
-    throw new Error('no matching `node` target')
-  }
-
-  if (!webTarget) {
-    throw new Error('no matching `web` target')
-  }
-
-  const target: Record<PkgRuntime, string[]> = {
-    '*': webTarget.concat(nodeTarget),
-    'browser': webTarget,
-    'node': nodeTarget,
-  }
-
-  const parsedExports = parseExports({
-    cwd,
-    pkg,
-    strict,
-    strictOptions,
-    logger,
-  }).reduce<PkgExports>(
-    (acc, {_path: exportPath, ...exportEntry}) => Object.assign(acc, {[exportPath]: exportEntry}),
-    {},
-  )
-
-  const exports = resolveConfigProperty(config?.exports, parsedExports)
-
-  const parsedExternal = [
-    ...(pkg.dependencies ? Object.keys(pkg.dependencies) : []),
-    ...(pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : []),
-  ]
-
-  // Merge externals if an array is provided, replace if it's a function
-  const external =
-    config && Array.isArray(config.external)
-      ? [...parsedExternal, ...config.external]
-      : resolveConfigProperty(config?.external, parsedExternal)
-  // Merge bundledPackages with dev deps, replace if it's a function
-  const externalWithTypes = new Set([pkg.name, ...external, ...external.map(transformPackageName)])
-  const bundledDependencies = (pkg.devDependencies ? Object.keys(pkg.devDependencies) : []).filter(
-    // Do not bundle anything that is marked as external
-    (_) => !externalWithTypes.has(_),
-  )
-  const bundledPackages =
-    config && Array.isArray(config.extract?.bundledPackages)
-      ? [...bundledDependencies, ...config.extract.bundledPackages]
-      : resolveConfigProperty(config?.extract?.bundledPackages, bundledDependencies)
-
-  const outputPaths = Object.values(exports)
-    .flatMap((exportEntry) => {
-      return [
-        exportEntry.import,
-        exportEntry.require,
-        exportEntry.browser?.import,
-        exportEntry.browser?.require,
-        exportEntry.node?.source && exportEntry.node.import,
-        exportEntry.node?.source && exportEntry.node.require,
-      ].filter(Boolean) as string[]
-    })
-    .map((p) => path.resolve(cwd, p))
-
-  const commonDistPath = findCommonDirPath(outputPaths)
-
-  if (commonDistPath === cwd) {
-    throw new Error(
-      'all output files must share a common parent directory which is not the root package directory',
-    )
-  }
-
-  if (commonDistPath && !pathContains(cwd, commonDistPath)) {
-    throw new Error('all output files must be located within the package')
-  }
-
-  const configDistPath = config?.dist ? path.resolve(cwd, config.dist) : undefined
-
-  if (
-    configDistPath &&
-    commonDistPath &&
-    configDistPath !== commonDistPath &&
-    !pathContains(configDistPath, commonDistPath)
-  ) {
-    logger.log(`did you mean to configure \`dist: './${path.relative(cwd, commonDistPath)}'\`?`)
-
-    throw new Error('all output files must be located with the configured `dist` path')
-  }
-
-  const distPath = configDistPath || commonDistPath
-
-  if (!distPath) {
-    throw new Error('could not detect `dist` path')
-  }
-
-  const ctx: BuildContext = {
-    config,
-    cwd,
-    distPath,
-    emitDeclarationOnly,
-    exports,
-    external,
-    bundledPackages,
-    files: [],
-    logger,
-    pkg,
-    runtime: config?.runtime ?? '*',
-    strict,
-    target,
-    ts: {
-      config: tsconfig,
-      configPath: tsconfigPath,
-    },
-    dts: config?.dts === 'rolldown' ? 'rolldown' : 'api-extractor',
-  }
-
-  return ctx
-}
-
-function transformPackageName(packageName: string): string {
-  if (packageName.startsWith('@types/')) {
-    // If it already starts with @types, return it as is
-    return packageName
-  } else if (packageName.startsWith('@')) {
-    // Handle scoped packages
-    const [scope, name] = packageName.split('/')
-
-    return `@types/${scope.slice(1)}__${name}`
-  } else {
-    // Handle regular packages
-    return `@types/${packageName}`
-  }
-}

package/src/node/resolveBuildTasks.ts

@@ -1,199 +0,0 @@
-import path from 'node:path'
-import type {PkgExport, PkgFormat, PkgRuntime} from './core/config/types'
-import type {BuildContext} from './core/contexts/buildContext'
-import {getTargetPaths} from './tasks/dts/getTargetPaths'
-import type {DtsTask} from './tasks/dts/types'
-import type {BuildTask, RolldownDtsTask, RollupTask, RollupTaskEntry} from './tasks/types'
-
-/** @internal */
-export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
-  const {config, pkg, target} = ctx
-
-  const bundles = config?.bundles || []
-
-  const tasks: BuildTask[] = []
-
-  const exports = Object.entries(ctx.exports || {}).map(
-    ([_path, exp]) => ({_path, ...exp}) as PkgExport & {_path: string},
-  )
-
-  const dtsTask: DtsTask = {
-    type: 'build:dts',
-    entries: [],
-  }
-
-  const rolldownDtsTask: Record<string, RolldownDtsTask> = {}
-  const rollupTasks: Record<string, RollupTask> = {}
-
-  function addRollupTaskEntry(format: PkgFormat, runtime: PkgRuntime, entry: RollupTaskEntry) {
-    const buildId = `${format}:${runtime}`
-
-    if (ctx.dts === 'rolldown') {
-      if (rolldownDtsTask[buildId]) {
-        rolldownDtsTask[buildId].entries.push(entry)
-      } else {
-        rolldownDtsTask[buildId] = {
-          type: 'rolldown:dts',
-          buildId,
-          entries: [entry],
-          runtime,
-          format,
-          target: target[runtime],
-        }
-      }
-    }
-
-    if (!ctx.emitDeclarationOnly) {
-      if (rollupTasks[buildId]) {
-        rollupTasks[buildId].entries.push(entry)
-      } else {
-        rollupTasks[buildId] = {
-          type: 'build:js',
-          buildId,
-          entries: [entry],
-          runtime,
-          format,
-          target: target[runtime],
-        }
-      }
-    }
-  }
-
-  if (ctx.dts === 'api-extractor') {
-    // Parse `dts` tasks
-    for (const exp of exports) {
-      const importId = path.join(pkg.name, exp._path)
-
-      if (exp.source?.endsWith('.ts')) {
-        dtsTask.entries.push({
-          importId,
-          exportPath: exp._path,
-          sourcePath: exp.source,
-          targetPaths: getTargetPaths(pkg.type, exp),
-        })
-      }
-
-      if (exp.browser?.source?.endsWith('.ts')) {
-        dtsTask.entries.push({
-          importId,
-          exportPath: exp._path,
-          sourcePath: exp.browser.source,
-          targetPaths: getTargetPaths(pkg.type, exp.browser),
-        })
-      }
-
-      if (exp.node?.source?.endsWith('.ts')) {
-        dtsTask.entries.push({
-          importId,
-          exportPath: exp._path,
-          sourcePath: exp.node.source,
-          targetPaths: getTargetPaths(pkg.type, exp.node),
-        })
-      }
-    }
-
-    // Handle dts tasks for bundles
-    for (const bundle of bundles) {
-      if (bundle.source?.endsWith('.ts')) {
-        // importId needs to be how the bundle is used, like `@sanity/pkg-utils/dist/cli`
-        // exportPath needs to be the path to the bundle, like `./dist/cli`
-        // targetPaths is then: [./dist/cli.d.ts, ./dist/cli.d.cts]
-        const exportPath = (bundle.import || bundle.require)!.replace(/\.[mc]?js$/, '')
-        const importId = path.join(pkg.name, exportPath)
-
-        dtsTask.entries.push({
-          importId,
-          exportPath,
-          sourcePath: bundle.source,
-          targetPaths: getTargetPaths(pkg.type, bundle),
-        })
-      }
-    }
-
-    // Add dts task
-    if (dtsTask.entries.length) {
-      tasks.push(dtsTask)
-    }
-  }
-
-  // Parse rollup:commonjs:* tasks
-  for (const exp of exports) {
-    const output = exp.require
-
-    if (!output) continue
-
-    addRollupTaskEntry('commonjs', ctx.runtime, {
-      path: exp._path,
-      source: exp.source,
-      output,
-    })
-  }
-
-  // Parse rollup:esm:* tasks
-  for (const exp of exports) {
-    const output = exp.import
-
-    if (!output) continue
-
-    addRollupTaskEntry('esm', ctx.runtime, {
-      path: exp._path,
-      source: exp.source,
-      output,
-    })
-  }
-
-  // Parse rollup:commonjs:browser tasks
-  for (const exp of exports) {
-    const output = exp.browser?.require
-
-    if (!output) continue
-
-    addRollupTaskEntry('commonjs', 'browser', {
-      path: exp._path,
-      source: exp.browser?.source || exp.source,
-      output,
-    })
-  }
-
-  // Parse rollup:esm:browser tasks
-  for (const exp of exports) {
-    const output = exp.browser?.import
-
-    if (!output) continue
-
-    addRollupTaskEntry('esm', 'browser', {
-      path: exp._path,
-      source: exp.browser?.source || exp.source,
-      output,
-    })
-  }
-
-  for (const bundle of bundles) {
-    const idx = bundles.indexOf(bundle)
-
-    if (bundle.require) {
-      addRollupTaskEntry('commonjs', bundle.runtime || ctx.runtime, {
-        path: `__$$bundle_cjs_${idx}$$__`,
-        source: bundle.source,
-        output: bundle.require,
-      })
-    }
-
-    if (bundle.import) {
-      addRollupTaskEntry('esm', bundle.runtime || ctx.runtime, {
-        path: `__$$bundle_esm_${idx}$$__`,
-        source: bundle.source,
-        output: bundle.import,
-      })
-    }
-  }
-
-  // Perform rolldown dts tasks first, as they have special logic for removing non .d.ts chunks
-  tasks.push(...Object.values(rolldownDtsTask))
-  // Then run api-extractor tsdoc release tag checking (if rolldown is used for dts bundling, otherwise api-extractor performs both in the build:dts task)
-  // @TODO
-  // Then run rollup tasks
-  tasks.push(...Object.values(rollupTasks))
-
-  return tasks
-}

package/src/node/resolveNodeTarget.ts

@@ -1,9 +0,0 @@
-export function resolveNodeTarget(versions: string[]): string[] | undefined {
-  const target: string[] = versions.filter((version) => version.startsWith('node'))
-
-  if (target.length === 0) {
-    return undefined
-  }
-
-  return target
-}