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

package/src/node/resolveWatchTasks.ts

@@ -1,132 +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 {DtsWatchTask} from './tasks/dts/types'
-import type {RollupTaskEntry, RollupWatchTask, WatchTask} from './tasks/types'
-
-/** @internal */
-export function resolveWatchTasks(ctx: BuildContext): WatchTask[] {
-  const {pkg, target} = ctx
-  const tasks: WatchTask[] = []
-
-  const exports = Object.entries(ctx.exports || {}).map(
-    ([_path, exp]) => ({_path, ...exp}) as PkgExport & {_path: string},
-  )
-
-  const dtsTask: DtsWatchTask = {
-    type: 'watch:dts',
-    entries: [],
-  }
-
-  const rollupTasks: Record<string, RollupWatchTask> = {}
-
-  function addRollupTaskEntry(format: PkgFormat, runtime: PkgRuntime, entry: RollupTaskEntry) {
-    const buildId = `${format}:${runtime}`
-
-    if (rollupTasks[buildId]) {
-      rollupTasks[buildId].entries.push(entry)
-    } else {
-      rollupTasks[buildId] = {
-        type: 'watch:js',
-        buildId,
-        entries: [entry],
-        runtime,
-        format,
-        target: target[runtime],
-      }
-    }
-  }
-
-  // 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),
-      })
-    }
-  }
-
-  // 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: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:* 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: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,
-    })
-  }
-
-  if (dtsTask.entries.length) {
-    tasks.push(dtsTask)
-  }
-
-  tasks.push(...Object.values(rollupTasks))
-
-  return tasks
-}

package/src/node/spinner.ts

@@ -1,17 +0,0 @@
-// oxlint-disable no-console
-import chalk from 'chalk'
-
-export function createSpinner(msg: string): {complete: () => void; error: () => void} {
-  const startTime = Date.now()
-
-  console.log(msg)
-
-  return {
-    complete: () => {
-      console.log(`${chalk.green('[success]')} ${chalk.gray(`${Date.now() - startTime}ms`)}`)
-    },
-    error: () => {
-      console.log(`${chalk.red('[error]')} ${chalk.gray(`${Date.now() - startTime}ms`)}`)
-    },
-  }
-}

package/src/node/strict.test-d.ts

@@ -1,6 +0,0 @@
-import {expectTypeOf, test} from 'vitest'
-import type {InferredStrictOptions, StrictOptions} from './strict'
-
-test('the zod schema types matches the manual types', () => {
-  expectTypeOf<StrictOptions>().toEqualTypeOf<Partial<InferredStrictOptions>>()
-})

package/src/node/strict.ts

@@ -1,84 +0,0 @@
-import {z} from 'zod'
-import {errorMap} from 'zod-validation-error'
-
-/**
- * @public
- */
-export const toggle = z.union([z.literal('error'), z.literal('warn'), z.literal('off')])
-
-/**
- * @public
- */
-export type ToggleType = z.infer<typeof toggle>
-
-/**
- * @public
- */
-export const strictOptions = z
-  .object({
-    noPackageJsonTypings: toggle.default('error'),
-    noImplicitSideEffects: toggle.default('warn'),
-    noImplicitBrowsersList: toggle.default('warn'),
-    alwaysPackageJsonTypes: toggle.default('error'),
-    alwaysPackageJsonMain: toggle.default('error'),
-    alwaysPackageJsonFiles: toggle.default('error'),
-  })
-  .strict()
-
-/**
- * To make error message paths line up with the paths in package.config.ts the schema is hoisted into a root schema
- * This way errors will say `Expected boolean, received string at "strict.noPackageJsonTypings"` instead of `Expected boolean, received string at "noPackageJsonTypings"`.
- */
-const validationSchema = z.object({
-  strictOptions: strictOptions.default({}),
-})
-
-/**
- * @public
- */
-export type InferredStrictOptions = z.infer<typeof strictOptions>
-
-/**
- * @public
- */
-export interface StrictOptions {
-  /**
-   * Disallows a top level `typings` field in `package.json` if it is equal to `exports['.'].source`.
-   * @defaultValue 'error'
-   */
-  noPackageJsonTypings?: ToggleType
-  /**
-   * Requires specifying `sideEffects` in `package.json`.
-   * @defaultValue 'warn'
-   */
-  noImplicitSideEffects?: ToggleType
-  /**
-   * Requires specifying `browserslist` in `package.json`, instead of relying on it implicitly being:
-   * @example
-   * ```
-   * "browserslist": "extends @sanity/browserslist-config"
-   * ```
-   * @defaultValue 'warn'
-   */
-  noImplicitBrowsersList?: ToggleType
-  /**
-   * If typescript is used then `types` in `package.json` should be specified for npm listings to show the TS icon.
-   * @defaultValue 'error'
-   */
-  alwaysPackageJsonTypes?: ToggleType
-  /**
-   * A lot of analysis tooling requiers the `main` field to work (like bundlephobia) and so it's best practice to always include it
-   * @defaultValue 'error'
-   */
-  alwaysPackageJsonMain?: ToggleType
-  /**
-   * Using `.npmignore` is error prone, it's best practice to always declare `files` instead
-   * @defaultValue 'error'
-   */
-  alwaysPackageJsonFiles?: ToggleType
-}
-
-/** @alpha */
-export function parseStrictOptions(input: unknown): InferredStrictOptions {
-  return validationSchema.parse({strictOptions: input}, {errorMap}).strictOptions
-}

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

@@ -1,11 +0,0 @@
-import type {ExtractorMessage} from '@microsoft/api-extractor'
-
-/** @internal */
-export class DtsError extends Error {
-  messages: ExtractorMessage[]
-
-  constructor(message: string, messages: ExtractorMessage[]) {
-    super(message)
-    this.messages = messages
-  }
-}

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

@@ -1,42 +0,0 @@
-import ts from 'typescript'
-import type {Logger} from '../../logger'
-import {printDiagnostic} from './printDiagnostic'
-
-/** @internal */
-export async function buildTypes(options: {
-  cwd: string
-  logger: Logger
-  outDir: string
-  tsconfig: ts.ParsedCommandLine
-  strict: boolean
-}): Promise<void> {
-  const {cwd, logger, outDir, tsconfig, strict = false} = options
-
-  const compilerOptions: ts.CompilerOptions = {
-    ...tsconfig.options,
-    declaration: true,
-    declarationDir: outDir,
-    emitDeclarationOnly: true,
-    noEmit: false,
-    noEmitOnError: strict ? true : (tsconfig.options.noEmitOnError ?? true),
-    outDir,
-  }
-
-  const program = ts.createProgram(tsconfig.fileNames, compilerOptions)
-
-  const emitResult = program.emit()
-
-  const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(emitResult.diagnostics)
-
-  for (const diagnostic of allDiagnostics) {
-    printDiagnostic({cwd, logger, diagnostic})
-  }
-
-  if (emitResult.emitSkipped) {
-    const errors = allDiagnostics.filter((diag) => diag.category === ts.DiagnosticCategory.Error)
-
-    if (errors.length) {
-      throw new Error('failed to compile TypeScript definitions')
-    }
-  }
-}

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

@@ -1,67 +0,0 @@
-import path from 'node:path'
-import type {IConfigFile, IExtractorMessagesConfig} from '@microsoft/api-extractor'
-import ts from 'typescript'
-
-export function createApiExtractorConfig(options: {
-  bundledPackages?: string[]
-  distPath: string
-  exportPath: string
-  filePath: string
-  messages: IExtractorMessagesConfig
-  projectFolder: string
-  mainEntryPointFilePath: string
-  tsconfig: ts.ParsedCommandLine
-  tsconfigPath: string
-  dtsRollupEnabled: boolean
-}): IConfigFile {
-  const {
-    bundledPackages,
-    distPath,
-    exportPath,
-    filePath,
-    messages,
-    projectFolder,
-    mainEntryPointFilePath,
-    tsconfig,
-    tsconfigPath,
-    dtsRollupEnabled,
-  } = options
-
-  return {
-    apiReport: {
-      enabled: false,
-      reportFileName: '<unscopedPackageName>.api.md',
-    },
-    bundledPackages,
-
-    // If `paths` are used for self-referencing imports (e.g. the module is named `sanity`, and the `sanity/structure` export is also importing from `sanity/router`),
-    compiler: tsconfig.options.paths
-      ? {
-          overrideTsconfig: {
-            extends: tsconfigPath,
-            compilerOptions: {
-              // An empty object replaces whatever is in the original tsconfig file
-              paths: {},
-            },
-          },
-        }
-      : {tsconfigFilePath: tsconfigPath},
-
-    docModel: {
-      enabled: false,
-      apiJsonFilePath: path.resolve(distPath, `${exportPath}.api.json`),
-    },
-    dtsRollup: {
-      enabled: dtsRollupEnabled,
-      untrimmedFilePath: path.resolve(distPath, filePath),
-      // betaTrimmedFilePath: path.resolve(distPath, filePath.replace('.d.ts', '-beta.d.ts')),
-      // publicTrimmedFilePath: path.resolve(distPath, filePath.replace('.d.ts', '-public.d.ts')),
-    },
-    tsdocMetadata: {
-      enabled: false,
-    },
-    messages,
-    mainEntryPointFilePath,
-    projectFolder,
-  }
-}

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

@@ -1,53 +0,0 @@
-import {readFile} from 'node:fs/promises'
-import {TSDocConfigFile} from '@microsoft/tsdoc-config'
-import {parse} from 'jsonc-parser'
-
-/** @public */
-export interface TSDocCustomTag {
-  name: string
-  syntaxKind: 'block' | 'modifier'
-  allowMultiple?: boolean
-}
-
-/** @internal */
-export async function createTSDocConfig(opts: {
-  customTags: TSDocCustomTag[]
-}): Promise<TSDocConfigFile | undefined> {
-  const {customTags} = opts
-
-  if (customTags.length === 0) {
-    return undefined
-  }
-
-  const tsDocBaseBuf = await readFile(
-    require.resolve('@microsoft/api-extractor/extends/tsdoc-base.json'),
-  )
-
-  // Include the definitions that are required for API Extractor
-  // extends: ['@microsoft/api-extractor/extends/tsdoc-base.json'],
-  const tsDocBaseConfig = parse(tsDocBaseBuf.toString())
-
-  // Define custom tags and specify how they should be parsed
-  const tagDefinitions = (tsDocBaseConfig.tagDefinitions || []).concat(
-    customTags.map((t) => ({
-      tagName: `@${t.name}`,
-      syntaxKind: t.syntaxKind,
-      allowMultiple: t.allowMultiple,
-    })),
-  )
-
-  // Indicate that custom tags are supported by your tooling.
-  // (Without this, warnings may be reported saying that a tag is unsupported.)
-  const supportForTags = {...tsDocBaseConfig.supportForTags}
-
-  for (const customTag of customTags) {
-    supportForTags[`@${customTag.name}`] = true
-  }
-
-  return TSDocConfigFile.loadFromObject({
-    ...tsDocBaseConfig,
-    noStandardTags: false,
-    tagDefinitions,
-    supportForTags,
-  })
-}

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

@@ -1,80 +0,0 @@
-import path from 'node:path'
-import type {ExtractorMessage} from '@microsoft/api-extractor'
-import {rimraf} from 'rimraf'
-import type {BuildContext} from '../../core/contexts/buildContext'
-import {buildTypes} from './buildTypes'
-import {DtsError} from './DtsError'
-import {extractTypes} from './extractTypes'
-import type {DtsResult, DtsTask, DtsWatchTask} from './types'
-
-/**
- * - Build type definitions to a temporary directory using TypeScript compiler.
- * - 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> {
-  const {config, cwd, files, logger, strict, ts, bundledPackages} = ctx
-
-  if (!ts.config || !ts.configPath) {
-    return {type: 'dts', messages: [], results: []}
-  }
-
-  const {outDir, rootDir = cwd} = ts.config.options
-
-  if (!outDir) {
-    throw new Error('tsconfig.json is missing `compilerOptions.outDir`')
-  }
-
-  const tmpPath = path.resolve(outDir, '__tmp__')
-
-  await buildTypes({cwd, logger, outDir: tmpPath, strict, tsconfig: ts.config})
-  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))
-    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: ts.config,
-      tmpPath,
-      tsconfigPath: path.resolve(cwd, ts.configPath || 'tsconfig.json'),
-      extractorDisabled: config?.extract?.enabled === false,
-    })
-
-    messages.push(...result.messages)
-
-    const errors = result.messages.filter((msg) => msg.logLevel === 'error')
-
-    if (errors.length > 0) {
-      await rimraf(tmpPath)
-      throw new DtsError(`encountered ${errors.length} errors when extracting types`, errors)
-    }
-
-    results.push({sourcePath: path.resolve(cwd, entry.sourcePath), filePaths: targetPaths})
-  }
-
-  await rimraf(tmpPath)
-
-  return {type: 'dts', messages, results}
-}

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

@@ -1,50 +0,0 @@
-import chalk from 'chalk'
-import {Observable} from 'rxjs'
-import {printExtractMessages} from '../../printExtractMessages'
-import type {TaskHandler} from '../types'
-import {doExtract} from './doExtract'
-import {DtsError} from './DtsError'
-import type {DtsResult, DtsTask} from './types'
-
-/** @internal */
-export const dtsTask: TaskHandler<DtsTask, DtsResult> = {
-  name: (ctx, task) =>
-    [
-      `Build type definitions with ${chalk.bold(ctx.dts)}...`,
-      '  entries:',
-      ...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')
-      }),
-    ].join('\n'),
-  exec: (ctx, task) => {
-    return new Observable((observer) => {
-      doExtract(ctx, task)
-        .then((result) => {
-          observer.next(result)
-          observer.complete()
-        })
-        .catch((err) => {
-          observer.error(err)
-        })
-    })
-  },
-  complete: (ctx, _task, result) => {
-    printExtractMessages(ctx, result.messages)
-  },
-  error: (ctx, _task, err) => {
-    const {logger} = ctx
-
-    if (err instanceof DtsError) {
-      printExtractMessages(ctx, err.messages)
-    } else if (err instanceof Error) {
-      logger.error(err)
-    }
-  },
-}