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

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

@@ -1,233 +0,0 @@
-import {existsSync} from 'node:fs'
-import {resolve as resolvePath} from 'node:path'
-import type {Logger} from '../../logger'
-import type {InferredStrictOptions} from '../../strict'
-import {defaultEnding, fileEnding} from '../../tasks/dts/getTargetPaths'
-import type {PkgExport} from '../config/types'
-import {isRecord} from '../isRecord'
-import {pkgExtMap} from './pkgExt'
-import type {PackageJSON} from './types'
-import {validateExports} from './validateExports'
-
-/** @alpha */
-export function parseExports(options: {
-  cwd: string
-  pkg: PackageJSON
-  strict: boolean
-  strictOptions: InferredStrictOptions
-  logger: Logger
-}): (PkgExport & {_path: string})[] {
-  const {cwd, pkg, strict, strictOptions, logger} = options
-  const type = pkg.type || 'commonjs'
-  const errors: string[] = []
-
-  const report = (kind: 'warn' | 'error', message: string) => {
-    if (kind === 'warn') {
-      logger.warn(message)
-    } else {
-      errors.push(message)
-    }
-  }
-
-  if (!pkg.main && strict && strictOptions.alwaysPackageJsonMain !== 'off') {
-    report(strictOptions.alwaysPackageJsonMain, 'package.json: `main` must be declared')
-  }
-
-  if (!Array.isArray(pkg.files) && strict && strictOptions.alwaysPackageJsonFiles !== 'off') {
-    report(
-      strictOptions.alwaysPackageJsonFiles,
-      'package.json: `files` should be used over `.npmignore`',
-    )
-  }
-
-  if (pkg.source) {
-    if (
-      strict &&
-      pkg.exports?.['.'] &&
-      typeof pkg.exports['.'] === 'object' &&
-      'source' in pkg.exports['.'] &&
-      pkg.exports['.'].source === pkg.source
-    ) {
-      errors.push(
-        'package.json: the "source" property can be removed, as it is equal to exports["."].source.',
-      )
-    } else if (!pkg.exports && pkg.main) {
-      const extMap = pkgExtMap[type]
-      const importExport = pkg.main.replace(fileEnding, extMap.esm)
-      const requireExport = pkg.main.replace(fileEnding, extMap.commonjs)
-      const defaultExport = pkg.main.replace(fileEnding, defaultEnding)
-
-      const maybeBrowserCondition = []
-
-      if (pkg.browser) {
-        const browserConditions = []
-
-        if (pkg.module && pkg.browser?.[pkg.module]) {
-          browserConditions.push(
-            `      "import": ${JSON.stringify(pkg.browser[pkg.module].replace(fileEnding, extMap.esm))}`,
-          )
-        } else if (pkg.browser?.[pkg.main]) {
-          browserConditions.push(
-            `      "import": ${JSON.stringify(pkg.browser?.[pkg.main].replace(fileEnding, extMap.esm))}`,
-          )
-        }
-
-        if (pkg.browser?.[pkg.main]) {
-          browserConditions.push(
-            `      "require": ${JSON.stringify(pkg.browser[pkg.main].replace(fileEnding, extMap.commonjs))}`,
-          )
-        }
-
-        if (browserConditions.length) {
-          maybeBrowserCondition.push(
-            `    "browser": {`,
-            `      "source": ${JSON.stringify(pkg.browser?.[pkg.source] || pkg.source)},`,
-            ...browserConditions,
-            `    }`,
-          )
-        }
-      }
-
-      errors.push(
-        ...([
-          'package.json: `exports` are missing, it should be:',
-          `"exports": {`,
-          `  ".": {`,
-          `    "source": ${JSON.stringify(pkg.source)},`,
-          // If browser conditions are detected then add them to the suggestion
-          ...(maybeBrowserCondition.length > 0 ? maybeBrowserCondition : []),
-          type === 'commonjs' && `    "import": ${JSON.stringify(importExport)},`,
-          type === 'module' && `    "require": ${JSON.stringify(requireExport)},`,
-          `    "default": ${JSON.stringify(defaultExport)}`,
-          `  },`,
-          `  "./package.json": "./package.json"`,
-          `}`,
-        ].filter(Boolean) as string[]),
-      )
-    }
-  }
-
-  if (errors.length) {
-    throw new Error('\n- ' + errors.join('\n- '))
-  }
-
-  if (!pkg.exports) {
-    throw new Error(
-      '\n- ' +
-        [
-          'package.json: `exports` are missing, please set a minimal configuration, for example:',
-          `"exports": {`,
-          `  ".": {`,
-          `    "source": "./src/index.js",`,
-          `    "default": "./dist/index.js"`,
-          `  },`,
-          `  "./package.json": "./package.json"`,
-          `}`,
-        ].join('\n- '),
-    )
-  }
-
-  const _exports: (PkgExport & {_path: string})[] = []
-
-  if (strict && strictOptions.noPackageJsonTypings !== 'off' && 'typings' in pkg) {
-    report(strictOptions.noPackageJsonTypings, 'package.json: `typings` should be `types`')
-  }
-
-  if (
-    strict &&
-    strictOptions.alwaysPackageJsonTypes !== 'off' &&
-    !pkg.types &&
-    typeof pkg.exports?.['.'] === 'object' &&
-    'source' in pkg.exports['.'] &&
-    pkg.exports['.'].source?.endsWith('.ts')
-  ) {
-    report(
-      strictOptions.alwaysPackageJsonTypes,
-      'package.json: `types` must be declared for the npm listing to show as a TypeScript module.',
-    )
-  }
-
-  if (strict && !pkg.exports['./package.json']) {
-    errors.push('package.json: `exports["./package.json"] must be declared.')
-  }
-
-  for (const [exportPath, exportEntry] of Object.entries(pkg.exports)) {
-    if (
-      exportPath.endsWith('.json') ||
-      (typeof exportEntry === 'string' && exportEntry.endsWith('.json'))
-    ) {
-      if (exportPath === './package.json') {
-        if (exportEntry !== './package.json') {
-          errors.push('package.json: `exports["./package.json"]` must be "./package.json".')
-        }
-      }
-    } else if (exportPath.endsWith('.css')) {
-      if (typeof exportEntry === 'string' && !existsSync(resolvePath(cwd, exportEntry))) {
-        errors.push(
-          `package.json: \`exports[${JSON.stringify(exportPath)}]\`: file does not exist.`,
-        )
-      } else if (typeof exportEntry !== 'string') {
-        errors.push(
-          `package.json: \`exports[${JSON.stringify(exportPath)}]\`: export conditions not supported for CSS files.`,
-        )
-      }
-    } else if (isRecord(exportEntry) && 'svelte' in exportEntry) {
-      // @TODO should we report a warning or a debug message here about a detected svelte export that is ignored?
-    } else if (isPkgExport(exportEntry)) {
-      const exp = {
-        _exported: true,
-        _path: exportPath,
-        ...exportEntry,
-      } satisfies PkgExport & {_path: string}
-
-      // Infer the `default` condition based on the `type` and other conditions
-      if (!exp.default) {
-        const fallback = type === 'module' ? exp.import : exp.require
-
-        if (fallback) {
-          exp.default = fallback
-        }
-      }
-
-      // Infer the `require` condition based on the `type` and other conditions
-      if (!exp.require && type === 'commonjs' && exp.default) {
-        exp.require = exp.default
-      }
-
-      // Infer the `import` condition based on the `type` and other conditions
-      if (!exp.import && type === 'module' && exp.default) {
-        exp.import = exp.default
-      }
-
-      if (exportPath === '.') {
-        if (exportEntry.require && pkg.main && exportEntry.require !== pkg.main) {
-          errors.push(
-            'package.json: mismatch between "main" and "exports.require". These must be equal.',
-          )
-        }
-
-        if (exportEntry.import && pkg.module && exportEntry.import !== pkg.module) {
-          errors.push(
-            'package.json: mismatch between "module" and "exports.import" These must be equal.',
-          )
-        }
-      }
-
-      _exports.push(exp)
-    } else if (!isRecord(exportEntry)) {
-      errors.push('package.json: exports must be an object')
-    }
-  }
-
-  errors.push(...validateExports(_exports, {pkg}))
-
-  if (errors.length) {
-    throw new Error('\n- ' + errors.join('\n- '))
-  }
-
-  return _exports
-}
-
-function isPkgExport(value: unknown): value is PkgExport {
-  return isRecord(value) && 'source' in value && typeof value['source'] === 'string'
-}

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

@@ -1,22 +0,0 @@
-import {cjsEnding, defaultEnding, mjsEnding} from '../../tasks/dts/getTargetPaths'
-
-/** @internal */
-export interface PkgExtMap {
-  commonjs: {commonjs: string; esm: string}
-  module: {commonjs: string; esm: string}
-}
-
-/** @internal */
-export const pkgExtMap = {
-  // pkg.type: "commonjs"
-  commonjs: {
-    commonjs: defaultEnding,
-    esm: mjsEnding,
-  },
-
-  // pkg.type: "module"
-  module: {
-    commonjs: cjsEnding,
-    esm: defaultEnding,
-  },
-} satisfies PkgExtMap

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

@@ -1,60 +0,0 @@
-/** @alpha */
-export interface PackageJSON {
-  type?: 'commonjs' | 'module'
-  version: string
-  private?: boolean
-  author?: string | {name: string; email?: string; url?: string}
-  name: string
-  description?: string
-  keywords?: string[]
-  bin?: Record<string, string>
-  dependencies?: Record<string, string | undefined>
-  devDependencies?: Record<string, string | undefined>
-  peerDependencies?: Record<string, string | undefined>
-  exports?: Record<
-    string,
-    | `./${string}.json`
-    | `./${string}.css`
-    | {
-        source?: string
-        types?: string
-        browser?: {
-          source: string
-          import?: string
-          require?: string
-        }
-        node?: {
-          source?: string
-          module?: string
-          import?: string
-          require?: string
-        }
-        module?: string
-        import?: string
-        require?: string
-        default: string
-      }
-    | {
-        types?: string
-        svelte: string
-        default?: string
-      }
-  >
-  main?: string
-  browser?: Record<string, string>
-  source?: string
-  module?: string
-  types?: string
-  files?: string[]
-  scripts?: Record<string, string | undefined>
-  browserslist?: string | string[]
-  sideEffects?: boolean | string[]
-  engines?: {
-    node?: string
-    npm?: string
-  }
-  repository?: string | {type: 'git'; url: string}
-  bugs?: string | {url: string; email?: string}
-  homepage?: string
-  license?: string
-}

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

@@ -1,30 +0,0 @@
-import type {PkgExport} from '../config/types'
-import {pkgExtMap as extMap} from './pkgExt'
-import type {PackageJSON} from './types'
-
-export function validateExports(
-  _exports: (PkgExport & {_path: string})[],
-  options: {pkg: PackageJSON},
-): string[] {
-  const {pkg} = options
-  const type = pkg.type || 'commonjs'
-  const ext = extMap[type]
-
-  const errors: string[] = []
-
-  for (const exp of _exports) {
-    if (exp.require && !exp.require.endsWith(ext.commonjs)) {
-      errors.push(
-        `package.json with \`type: "${type}"\` - \`exports["${exp._path}"].require\` must end with "${ext.commonjs}"`,
-      )
-    }
-
-    if (exp.import && !exp.import.endsWith(ext.esm)) {
-      errors.push(
-        `package.json with \`type: "${type}"\` - \`exports["${exp._path}"].import\` must end with "${ext.esm}"`,
-      )
-    }
-  }
-
-  return errors
-}

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

@@ -1,82 +0,0 @@
-import {z} from 'zod'
-import type {PackageJSON} from './types'
-
-const pkgSchema = z.object({
-  type: z.optional(z.enum(['commonjs', 'module'])),
-  name: z.string(),
-  version: z.string(),
-  license: z.string(),
-  bin: z.optional(z.record(z.string())),
-  dependencies: z.optional(z.record(z.string())),
-  devDependencies: z.optional(z.record(z.string())),
-  peerDependencies: z.optional(z.record(z.string())),
-  source: z.optional(z.string()),
-  main: z.optional(z.string()),
-  browser: z.optional(z.record(z.string())),
-  module: z.optional(z.string()),
-  types: z.optional(z.string()),
-  exports: z.optional(
-    z.record(
-      z.union([
-        z.custom<`./${string}.json`>((val) => /^\.\/.*\.json$/.test(val as string)),
-        z.custom<`./${string}.css`>((val) => /^\.\/.*\.css$/.test(val as string)),
-        z.object({
-          types: z.optional(z.string()),
-          source: z.optional(z.string()),
-          browser: z.optional(
-            z.object({
-              source: z.string(),
-              import: z.optional(z.string()),
-              require: z.optional(z.string()),
-            }),
-          ),
-          node: z.optional(
-            z.object({
-              source: z.optional(z.string()),
-              import: z.optional(z.string()),
-              require: z.optional(z.string()),
-            }),
-          ),
-          import: z.optional(z.string()),
-          require: z.optional(z.string()),
-          default: z.string(),
-        }),
-        z.object({
-          types: z.optional(z.string()),
-          svelte: z.string(),
-          default: z.optional(z.string()),
-        }),
-      ]),
-    ),
-  ),
-  browserslist: z.optional(z.union([z.string(), z.array(z.string())])),
-  sideEffects: z.optional(z.union([z.boolean(), z.array(z.string())])),
-  // @TODO type this properly
-  typesVersions: z.optional(z.any()),
-})
-
-// Create a map over known keys to catch casing mistakes
-const typoMap = new Map<string, string>()
-
-for (const key of pkgSchema.keyof()._def.values) {
-  typoMap.set(key.toUpperCase(), key)
-}
-
-export function validatePkg(input: unknown): PackageJSON {
-  const pkg = pkgSchema.parse(input)
-
-  const invalidKey = Object.keys(input as PackageJSON).find((key) => {
-    const needle = key.toUpperCase()
-
-    return typoMap.has(needle) ? typoMap.get(needle) !== key : false
-  })
-
-  if (invalidKey) {
-    throw new TypeError(
-      `
-- package.json: "${invalidKey}" is not a valid key. Did you mean "${typoMap.get(invalidKey.toUpperCase())}"?`,
-    )
-  }
-
-  return pkg
-}

package/src/node/core/template/createFromTemplate.ts

@@ -1,84 +0,0 @@
-import {writeFile} from 'node:fs/promises'
-import {dirname, relative, resolve} from 'node:path'
-import {mkdirp} from 'mkdirp'
-import prompts from 'prompts'
-import type {Logger} from '../../logger'
-import type {PkgTemplate} from './types'
-
-const promptsTypes = {
-  string: 'text' as const,
-}
-
-/** @internal */
-export async function createFromTemplate(options: {
-  cwd: string
-  logger: Logger
-  packagePath: string
-  template: PkgTemplate
-}): Promise<void> {
-  const {cwd, logger, packagePath, template: templateOrResolver} = options
-
-  const template =
-    typeof templateOrResolver === 'function'
-      ? await templateOrResolver({cwd, logger, packagePath})
-      : templateOrResolver
-
-  logger.log('create new package at', relative(cwd, packagePath))
-
-  const templateOptions: Record<string, string> = {}
-
-  for (const templateOption of template.options) {
-    const templateValidate = templateOption.validate
-
-    const res = await prompts(
-      {
-        type: promptsTypes[templateOption.type],
-        name: templateOption.name,
-        message: templateOption.description,
-        validate: templateValidate ? (prev) => templateValidate(prev) : undefined,
-        initial:
-          typeof templateOption.initial === 'function'
-            ? templateOption.initial(templateOptions)
-            : templateOption.initial,
-      },
-      {onCancel: () => process.exit(0)},
-    )
-
-    templateOptions[templateOption.name] = templateOption.parse
-      ? templateOption.parse(res[templateOption.name])
-      : res[templateOption.name]
-  }
-
-  const features: Record<string, boolean> = {}
-
-  for (const templateFeature of template.features) {
-    const res = templateFeature.optional
-      ? await prompts(
-          {
-            type: 'confirm',
-            name: 'confirm',
-            message: `use ${templateFeature.name}?`,
-            initial: templateFeature.initial,
-          },
-          {onCancel: () => process.exit(0)},
-        )
-      : undefined
-
-    features[templateFeature.name] = res?.confirm || !templateFeature.optional
-  }
-
-  const files = await template.getFiles(templateOptions, features)
-
-  files.sort((a, b) => {
-    return a.name.localeCompare(b.name)
-  })
-
-  for (const file of files) {
-    const filePath = resolve(packagePath, file.name)
-
-    await mkdirp(dirname(filePath))
-    await writeFile(filePath, file.contents.trim() + '\n')
-
-    logger.success(`wrote ${relative(cwd, filePath)}`)
-  }
-}

package/src/node/core/template/define.ts

@@ -1,6 +0,0 @@
-import type {PkgTemplateOption} from './types'
-
-/** @public */
-export function defineTemplateOption<T>(option: PkgTemplateOption<T>): PkgTemplateOption<T> {
-  return option
-}

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

@@ -1,3 +0,0 @@
-export * from './createFromTemplate'
-export * from './define'
-export * from './types'

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

@@ -1,45 +0,0 @@
-import type {Logger} from '../../logger'
-
-/** @public */
-export interface PkgTemplateFile {
-  name: string
-  contents: string
-}
-
-/** @public */
-export interface PkgTemplateStringOption<T = string> {
-  name: string
-  type: 'string'
-  description: string
-  initial?: T | ((options: Record<string, any>) => T)
-  parse?: (v: string) => T | null
-  validate?: (v: string) => string | true
-}
-
-/** @public */
-export type PkgTemplateOption<T = string> = PkgTemplateStringOption<T>
-
-/** @public */
-export interface PkgTemplateDefinition {
-  options: PkgTemplateStringOption<any>[]
-  features: {
-    name: string
-    optional: boolean
-    initial: boolean
-  }[]
-  getFiles: (
-    options: Record<string, any>,
-    features: Record<string, boolean>,
-  ) => Promise<PkgTemplateFile[]>
-}
-
-/** @public */
-export type PkgTemplateResolver = (options: {
-  cwd: string
-  /** @internal */
-  logger: Logger
-  packagePath: string
-}) => PkgTemplateDefinition | Promise<PkgTemplateDefinition>
-
-/** @public */
-export type PkgTemplate = PkgTemplateDefinition | PkgTemplateResolver

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

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

package/src/node/core/ts/loadTSConfig.ts

@@ -1,19 +0,0 @@
-import ts from 'typescript'
-
-/** @internal */
-export async function loadTSConfig(options: {
-  cwd: string
-  tsconfigPath: string
-}): Promise<ts.ParsedCommandLine | undefined> {
-  const {cwd, tsconfigPath} = options
-
-  const configPath = ts.findConfigFile(cwd, ts.sys.fileExists, tsconfigPath)
-
-  if (!configPath) {
-    return undefined
-  }
-
-  const configFile = ts.readConfigFile(configPath, ts.sys.readFile)
-
-  return ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd)
-}

package/src/node/fileExists.ts

@@ -1,12 +0,0 @@
-import {statSync} from 'node:fs'
-
-/** @internal */
-export function fileExists(filePath: string): boolean {
-  try {
-    statSync(filePath)
-
-    return true
-  } catch {
-    return false
-  }
-}

package/src/node/getFilesize.ts

@@ -1,8 +0,0 @@
-import {statSync} from 'node:fs'
-import prettyBytes from 'pretty-bytes'
-
-export function getFilesize(file: string): string {
-  const stats = statSync(file)
-
-  return prettyBytes(stats.size)
-}

package/src/node/globFiles.ts

@@ -1,6 +0,0 @@
-import path from 'node:path'
-import globby from 'globby'
-
-export function globFiles(patterns: string[]): Promise<string[]> {
-  return globby(patterns.map((pattern) => pattern.split(path.sep).join(path.posix.sep)))
-}

package/src/node/index.ts

@@ -1,48 +0,0 @@
-export {build} from './build'
-export {check} from './check'
-export {defineConfig} from './core/config/defineConfig'
-export {loadConfig} from './core/config/loadConfig'
-export type {
-  PkgFormat,
-  PkgRuntime,
-  PkgExport,
-  PkgConfigPropertyResolver,
-  PkgConfigProperty,
-  PkgBundle,
-  PkgExports,
-  PkgRuleLevel,
-  TSDocCustomTag,
-  ReactCompilerOptions,
-  ReactCompilerLoggerEvent,
-  ReactCompilerLogger,
-  PkgConfigOptions,
-} from './core/config/types'
-export {DEFAULT_BROWSERSLIST_QUERY} from './core/defaults'
-export {loadPkg} from './core/pkg/loadPkg'
-export {loadPkgWithReporting} from './core/pkg/loadPkgWithReporting'
-export {parseExports} from './core/pkg/parseExports'
-export * from './core/pkg/types'
-export {defineTemplateOption} from './core/template/define'
-export {
-  type PkgTemplateFile,
-  type PkgTemplateStringOption,
-  type PkgTemplateOption,
-  type PkgTemplateDefinition,
-  type PkgTemplateResolver,
-  type PkgTemplate,
-} from './core/template/types'
-
-export {init} from './init'
-export {createLogger} from './logger'
-export {
-  type StrictOptions,
-  type InferredStrictOptions,
-  parseStrictOptions,
-  strictOptions,
-  toggle,
-  type ToggleType,
-} from './strict'
-export {getExtractMessagesConfig} from './tasks/dts/getExtractMessagesConfig'
-export {watch} from './watch'
-
-export type {Plugin as RollupPlugin} from 'rollup'