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

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

@@ -1,315 +0,0 @@
-import type {PluginItem as BabelPluginItem} from '@babel/core'
-import type {OptimizeLodashOptions} from '@optimize-lodash/rollup-plugin'
-import type {NormalizedOutputOptions, Plugin as RollupPlugin, TreeshakingOptions} from 'rollup'
-import type {StrictOptions} from '../../strict'
-
-/** @public */
-export type PkgFormat = 'commonjs' | 'esm'
-
-/** @public */
-export type PkgRuntime = '*' | 'browser' | 'node'
-
-/** @public */
-export interface PkgExport {
-  /** @internal */
-  _exported?: boolean
-  browser?: {
-    source: string
-    import?: string
-    require?: string
-  }
-  // electron?: {
-  //   node?: string
-  //   default?: string
-  // }
-  node?: {
-    source?: string
-    import?: string
-    require?: string
-  }
-  types?: string
-  source: string
-  import?: string
-  require?: string
-  default: string
-}
-
-/** @public */
-export type PkgConfigPropertyResolver<T> = (prev: T) => T
-
-/** @public */
-export type PkgConfigProperty<T> = PkgConfigPropertyResolver<T> | T
-
-/** @public */
-export interface PkgBundle {
-  source: string
-  import?: string
-  require?: string
-  runtime?: PkgRuntime
-}
-
-/** @public */
-export interface PkgExports {
-  [path: string]: PkgExport
-}
-
-/** @public */
-export type PkgRuleLevel = 'error' | 'warn' | 'info' | 'off'
-
-/** @public */
-export interface TSDocCustomTag {
-  name: string
-  syntaxKind: 'block' | 'modifier'
-  allowMultiple?: boolean
-}
-
-/**
- * Until these types are on npm: https://github.com/facebook/react/blob/0bc30748730063e561d87a24a4617526fdd38349/compiler/packages/babel-plugin-react-compiler/src/Entrypoint/Options.ts#L39-L122
- * @alpha
- */
-export interface ReactCompilerOptions {
-  logger?: ReactCompilerLogger | null
-
-  panicThreshold?: 'ALL_ERRORS' | 'CRITICAL_ERRORS' | 'NONE'
-
-  compilationMode?: 'infer' | 'syntax' | 'annotation' | 'all'
-
-  /*
-   * If enabled, Forget will import `useMemoCache` from the given module
-   * instead of `react/compiler-runtime`.
-   *
-   * ```
-   * // If set to "react-compiler-runtime"
-   * import {c as useMemoCache} from 'react-compiler-runtime';
-   * ```
-   */
-  runtimeModule?: string | null | undefined
-
-  /**
-   * By default React Compiler will skip compilation of code that suppresses the default
-   * React ESLint rules, since this is a strong indication that the code may be breaking React rules
-   * in some way.
-   *
-   * Use eslintSuppressionRules to pass a custom set of rule names: any code which suppresses the
-   * provided rules will skip compilation. To disable this feature (never bailout of compilation
-   * even if the default ESLint is suppressed), pass an empty array.
-   */
-  eslintSuppressionRules?: Array<string> | null | undefined
-
-  sources?: Array<string> | ((filename: string) => boolean) | null
-
-  /**
-   * The minimum major version of React that the compiler should emit code for. If the target is 19
-   * or higher, the compiler emits direct imports of React runtime APIs needed by the compiler. On
-   * versions prior to 19, an extra runtime package react-compiler-runtime is necessary to provide
-   * a userspace approximation of runtime APIs.
-   */
-  target: '17' | '18' | '19'
-}
-
-/**
- * @alpha
- * Represents 'events' that may occur during compilation. Events are only
- * recorded when a logger is set (through the config).
- * These are the different types of events:
- * CompileError:
- *   Forget skipped compilation of a function / file due to a known todo,
- *   invalid input, or compiler invariant being broken.
- * CompileSuccess:
- *   Forget successfully compiled a function.
- * PipelineError:
- *   Unexpected errors that occurred during compilation (e.g. failures in
- *   babel or other unhandled exceptions).
- */
-export type ReactCompilerLoggerEvent =
-  | {
-      kind: 'CompileError'
-      fnLoc: unknown
-      detail: unknown
-    }
-  | {
-      kind: 'CompileDiagnostic'
-      fnLoc: unknown
-      detail: unknown
-    }
-  | {
-      kind: 'CompileSuccess'
-      fnLoc: unknown
-      fnName: string | null
-      memoSlots: number
-      memoBlocks: number
-      memoValues: number
-      prunedMemoBlocks: number
-      prunedMemoValues: number
-    }
-  | {
-      kind: 'PipelineError'
-      fnLoc: unknown
-      data: string
-    }
-
-/**
- * @alpha
- */
-export type ReactCompilerLogger = {
-  logEvent: (filename: string | null, event: ReactCompilerLoggerEvent) => void
-}
-
-export type DtsType = 'api-extractor' | 'rolldown'
-
-/** @public */
-export interface PkgConfigOptions {
-  /** @alpha */
-  babel?: {
-    plugins?: BabelPluginItem[] | null | undefined
-    /** @alpha */
-    reactCompiler?: boolean
-    /** @alpha */
-    styledComponents?:
-      | boolean
-      | {
-          /** @defaultValue true */
-          displayName?: boolean
-          /**
-           * @defaultValue []
-           * @example ["\@xstyled/styled-components", "\@xstyled/styled-components/*"]
-           */
-          topLevelImportPaths?: string[]
-          /** @defaultValue true */
-          ssr?: boolean
-          /** @defaultValue fale */
-          fileName?: boolean
-          /** @defaultValue ["index"] */
-          meaninglessFileNames?: string[]
-          /** @defaultValue true */
-          minify?: boolean
-          /** @defaultValue false */
-          transpileTemplateLiterals?: boolean
-          namespace?: string
-          /** @defaultValue true */
-          pure?: boolean
-        }
-  }
-  /**
-   * Configure the React Compiler.
-   * To enable it, either:
-   * - set `babel.reactCompiler` to `true`
-   * - add a `react-compiler` export condition,  before any `browser`, `require` or `import` conditions. After any `react-server` and `node` conditions
-   * @alpha */
-  reactCompilerOptions?: ReactCompilerOptions
-  bundles?: PkgBundle[]
-  /** @alpha */
-  define?: Record<string, string | number | boolean | undefined | null>
-  /**
-   * Directory of distributed & bundled files.
-   */
-  dist?: string
-  exports?: PkgConfigProperty<PkgExports>
-  /**
-   * Runs `@microsoft/api-extractor` to check that TSDoc tags are valid, and release tags are correct.
-   * This is useful for packages that need to be consumed by TSDoc-based tooling.
-   * It's enabled by default, it can be disabled by setting `extract: {enabled: false}`
-   */
-  extract?: {
-    /**
-     * @defaultValue true
-     */
-    enabled?: boolean
-    /**
-     * Packages in `devDependencies` that are not in `external` are automatically added to the `bundledPackages` config.
-     * You can exclude a package from being bundled by using a callback:
-     * ```
-     * bundledPackages: (prev) => prev.filter(package => package !== 'sanity')
-     * ```
-     */
-    bundledPackages?: PkgConfigProperty<string[]>
-    customTags?: TSDocCustomTag[]
-    rules?: {
-      /**
-       * @deprecated as it's no longer needed since TypeScript 5.5 https://github.com/microsoft/TypeScript/issues/42873
-       */
-      'ae-forgotten-export'?: never
-      'ae-incompatible-release-tags'?: PkgRuleLevel
-      'ae-internal-missing-underscore'?: PkgRuleLevel
-      'ae-missing-release-tag'?: PkgRuleLevel
-      'tsdoc-link-tag-unescaped-text'?: PkgRuleLevel
-      'tsdoc-undefined-tag'?: PkgRuleLevel
-      'tsdoc-unsupported-tag'?: PkgRuleLevel
-    }
-  }
-  /**
-   * Packages to exclude from bundles.
-   * Provide an array to merge with default exclusions, use a function to replace them:
-   * ```
-   * exclude: (prev) => prev.filter(package => package !== 'foo')
-   * ```
-   */
-  external?: PkgConfigProperty<string[]>
-  /**
-   * Defaults to `"automatic"`
-   */
-  jsx?: 'transform' | 'preserve' | 'automatic'
-  /**
-   * Defaults to `"createElement"`
-   */
-  jsxFactory?: string
-  /**
-   * Defaults to `"Fragment"`
-   */
-  jsxFragment?: string
-  /**
-   * Defaults to `"react"`
-   */
-  jsxImportSource?: string
-  /**
-   * @deprecated no longer supported
-   */
-  legacyExports?: never
-  minify?: boolean
-  /** @alpha */
-  rollup?: {
-    plugins?: PkgConfigProperty<RollupPlugin[]>
-    output?: Partial<NormalizedOutputOptions>
-    /**
-     * Default options are `preset: 'recommended'` and `propertyReadSideEffects: false`
-     * @alpha
-     */
-    treeshake?: TreeshakingOptions
-    /** @alpha */
-    experimentalLogSideEffects?: boolean
-    /**
-     * Adds [hash] to chunk filenames, generally only useful if `@sanity/pkg-utils` is used to deploy a package directly to a CDN.
-     * It's not needed when publishing to npm for consumption by other libraries, bundlers and frameworks.
-     * @defaultValue false
-     */
-    hashChunkFileNames?: boolean
-    /**
-     * Optimizes lodash imports using `@optimize-lodash/rollup-plugin` when set to `true`.
-     * It's enabled if `lodash` is found in `dependencies` or `peerDependencies`.
-     * It will use `lodash-es` for ESM targets if found in `dependencies` or `peerDependencies`.
-     * @defaultValue true
-     * @alpha
-     */
-    optimizeLodash?: boolean | OptimizeLodashOptions
-  }
-  /**
-   * Default runtime of package exports
-   */
-  runtime?: PkgRuntime
-  sourcemap?: boolean
-  /**
-   * Directory of source files.
-   */
-  src?: string
-  tsconfig?: string
-  /**
-   * Configure what checks are made when running `--strict` builds and checks
-   */
-  strictOptions?: StrictOptions
-  /**
-   * .d.ts files can be generated either by using `@microsoft/api-extractor` or `rolldown`.
-   * `rolldown` is the faster option, but is not yet stable.
-   * @defaultValue 'api-extractor'
-   */
-  dts?: DtsType
-}

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

@@ -1,32 +0,0 @@
-import type ts from 'typescript'
-import type {Logger} from '../../logger'
-import type {DtsType, PkgConfigOptions, PkgExports, PkgRuntime} from '../config/types'
-import type {PackageJSON} from '../pkg/types'
-
-/** @internal */
-export interface BuildFile {
-  type: 'asset' | 'chunk' | 'types'
-  path: string
-}
-
-/** @internal */
-export interface BuildContext {
-  config?: PkgConfigOptions
-  cwd: string
-  distPath: string
-  emitDeclarationOnly: boolean
-  exports: PkgExports | undefined
-  external: string[]
-  bundledPackages: string[]
-  files: BuildFile[]
-  logger: Logger
-  pkg: PackageJSON
-  runtime: PkgRuntime
-  strict: boolean
-  target: Record<PkgRuntime, string[]>
-  ts: {
-    config?: ts.ParsedCommandLine
-    configPath?: string
-  }
-  dts: DtsType
-}

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

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

package/src/node/core/defaults.ts

@@ -1,4 +0,0 @@
-import config from '@sanity/browserslist-config'
-
-/** @public */
-export const DEFAULT_BROWSERSLIST_QUERY = config

package/src/node/core/findCommonPath.ts

@@ -1,35 +0,0 @@
-import path from 'node:path'
-
-export function pathContains(containerPath: string, itemPath: string): boolean {
-  return !path.relative(containerPath, itemPath).startsWith('..')
-}
-
-export function findCommonDirPath(filePaths: string[]): string | undefined {
-  let ret: string | undefined = undefined
-
-  for (const filePath of filePaths) {
-    let dirPath = path.dirname(filePath)
-
-    if (!ret) {
-      ret = dirPath
-      continue
-    }
-
-    while (dirPath !== ret) {
-      dirPath = path.dirname(dirPath)
-
-      if (dirPath === ret) {
-        break
-      }
-
-      if (pathContains(dirPath, ret)) {
-        ret = dirPath
-        break
-      }
-
-      if (dirPath === '.') return undefined
-    }
-  }
-
-  return ret
-}

package/src/node/core/isRecord.ts

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

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

@@ -1,36 +0,0 @@
-/** @internal */
-export function assertFirst<T>(a: T, arr: T[]): boolean {
-  const aIdx = arr.indexOf(a)
-
-  // if not found, then we don't care
-  if (aIdx === -1) {
-    return true
-  }
-
-  return aIdx === 0
-}
-
-/** @internal */
-export function assertLast<T>(a: T, arr: T[]): boolean {
-  const aIdx = arr.indexOf(a)
-
-  // if not found, then we don't care
-  if (aIdx === -1) {
-    return true
-  }
-
-  return aIdx === arr.length - 1
-}
-
-/** @internal */
-export function assertOrder<T>(a: T, b: T, arr: T[]): boolean {
-  const aIdx = arr.indexOf(a)
-  const bIdx = arr.indexOf(b)
-
-  // if either is not found, then we don't care
-  if (aIdx === -1 || bIdx === -1) {
-    return true
-  }
-
-  return aIdx < bIdx
-}

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

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

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

@@ -1,21 +0,0 @@
-import fs from 'node:fs/promises'
-import pkgUp from 'pkg-up'
-import type {PackageJSON} from './types'
-import {validatePkg} from './validatePkg'
-
-/** @internal */
-export async function loadPkg(options: {cwd: string}): Promise<PackageJSON> {
-  const {cwd} = options
-
-  const pkgPath = await pkgUp({cwd})
-
-  if (!pkgPath) throw new Error('no package.json found')
-
-  const buf = await fs.readFile(pkgPath)
-
-  const raw = JSON.parse(buf.toString())
-
-  validatePkg(raw)
-
-  return raw
-}

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

@@ -1,154 +0,0 @@
-import chalk from 'chalk'
-import {ZodError} from 'zod'
-import type {Logger} from '../../logger'
-import {assertLast, assertOrder} from './helpers'
-import {loadPkg} from './loadPkg'
-import type {PackageJSON} from './types'
-
-/** @alpha */
-export async function loadPkgWithReporting(options: {
-  cwd: string
-  logger: Logger
-  strict: boolean
-}): Promise<PackageJSON> {
-  const {cwd, logger, strict} = options
-
-  try {
-    const pkg = await loadPkg({cwd})
-    let shouldError = false
-
-    if (strict) {
-      if (!pkg.type) {
-        shouldError = true
-        logger.error(
-          `the \`type\` field in \`./package.json\` must be either "module" or "commonjs")`,
-        )
-      }
-    }
-
-    // validate exports
-    if (pkg.exports) {
-      const _exports = Object.entries(pkg.exports)
-
-      for (const [expPath, exp] of _exports) {
-        if (typeof exp === 'string' || 'svelte' in exp) {
-          continue
-        }
-
-        const keys = Object.keys(exp)
-
-        if (exp.types) {
-          shouldError = true
-          logger.error(
-            `exports["${expPath}"]: the \`types\` condition shouldn't be used as dts files are generated in such a way that both CJS and ESM is supported`,
-          )
-        }
-
-        if (exp.module) {
-          shouldError = true
-          logger.error(
-            `exports["${expPath}"]: the \`module\` condition shouldn't be used as it's not well supported in all bundlers.`,
-          )
-        }
-
-        if (exp.node) {
-          if (exp.import && exp.node.import && !assertOrder('node', 'import', keys)) {
-            shouldError = true
-            logger.error(
-              `exports["${expPath}"]: the \`node\` property should come before the \`import\` property`,
-            )
-          }
-
-          if (exp.node.module) {
-            shouldError = true
-            logger.error(
-              `exports["${expPath}"]: the \`node.module\` condition shouldn't be used as it's not well supported in all bundlers. A better strategy is to refactor the codebase to no longer be vulnerable to the "dual package hazard"`,
-            )
-          }
-
-          if (
-            !exp.node.source &&
-            exp.node.import &&
-            (exp.node.require || exp.require) &&
-            (exp.node.import.endsWith('.cjs.js') || exp.node.import.endsWith('.cjs.mjs'))
-          ) {
-            shouldError = true
-            logger.error(
-              `exports["${expPath}"]: the \`node.import\` re-export pattern shouldn't be used as it's not well supported in all bundlers. A better strategy is to refactor the codebase to no longer be vulnerable to the "dual package hazard"`,
-            )
-          }
-
-          if (exp.require && exp.node.require && exp.require === exp.node.require) {
-            shouldError = true
-            logger.error(
-              `exports["${expPath}"]: the \`node.require\` property isn't necessary as it's identical to \`require\``,
-            )
-          } else if (exp.require && exp.node.require && !assertOrder('node', 'require', keys)) {
-            shouldError = true
-            logger.error(
-              `exports["${expPath}"]: the \`node\` property should come before the \`require\` property`,
-            )
-          }
-        } else {
-          if (!assertOrder('import', 'require', keys)) {
-            logger.warn(
-              `exports["${expPath}"]: the \`import\` property should come before the \`require\` property`,
-            )
-          }
-        }
-
-        if (!assertLast('default', keys)) {
-          shouldError = true
-          logger.error(
-            `exports["${expPath}"]: the \`default\` property should be the last property`,
-          )
-        }
-      }
-    }
-
-    if (shouldError) {
-      process.exit(1)
-    }
-
-    return pkg
-  } catch (err) {
-    if (err instanceof ZodError) {
-      for (const issue of err.issues) {
-        if (issue.code === 'invalid_type') {
-          logger.error(
-            [
-              `\`${formatPath(issue.path)}\` `,
-              `in \`./package.json\` must be of type ${chalk.magenta(issue.expected)} `,
-              `(received ${chalk.magenta(issue.received)})`,
-            ].join(''),
-          )
-          continue
-        }
-
-        logger.error(issue)
-      }
-    } else {
-      logger.error(err)
-    }
-
-    process.exit(1)
-  }
-}
-
-function formatPath(segments: Array<string | number>) {
-  return segments
-    .map((s, idx) => {
-      if (idx === 0) return s
-
-      if (typeof s === 'number') {
-        return `[${s}]`
-      }
-
-      if (s.startsWith('.')) {
-        return `["${s}"]`
-      }
-
-      return `.${s}`
-    })
-    .join('')
-}