@sanity/pkg-utils 1.3.0 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/pkg-utils",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "author": "Sanity.io <hello@sanity.io>",
   "license": "MIT",
   "description": "Simple utilities for modern npm packages.",
@@ -13,53 +13,67 @@
     "build",
     "bundling"
   ],
-  "source": "./src/index.ts",
+  "source": "./src/node/index.ts",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "default": "./dist/index.js",
+      "source": "./src/node/index.ts",
+      "import": "./dist/index.js",
       "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
     }
   },
   "bin": {
+    "pkg": "./bin/pkg-utils",
     "pkg-utils": "./bin/pkg-utils"
   },
   "files": [
+    "bin",
     "src",
     "dist"
   ],
   "scripts": {
-    "build": "node -r esbuild-register src/cli build --extract --tsconfig tsconfig.dist.json",
+    "build": "node -r esbuild-register scripts/build",
+    "extract": "sanity-tsdoc etl --outDir etc/api/@sanity/pkg-utils --tsconfig tsconfig.dist.json",
     "format": "prettier --write --cache --ignore-unknown .",
     "lint": "eslint . --ext .cjs,.js,.ts",
     "prebuild": "rimraf dist",
     "prepublishOnly": "pnpm run build",
     "release": "semantic-release",
-    "test": "vitest run",
-    "type-check": "tsc --noEmit"
+    "test": "node -r esbuild-register scripts/status && vitest run",
+    "type-check": "tsc --build",
+    "watch": "node -r esbuild-register scripts/watch"
   },
   "dependencies": {
     "@microsoft/api-extractor": "^7.29.5",
     "@microsoft/tsdoc-config": "^0.16.1",
+    "@rollup/plugin-alias": "^3.1.9",
     "@rollup/plugin-commonjs": "^22.0.2",
     "@rollup/plugin-json": "^4.1.0",
     "@rollup/plugin-node-resolve": "^13.3.0",
-    "@sanity/tsdoc-to-portable-text": "^0.4.1",
+    "@rollup/plugin-replace": "^4.0.0",
     "browserslist": "^4.21.3",
     "cac": "^6.7.12",
     "chalk": "^4.1.2",
+    "chokidar": "^3.5.3",
     "esbuild": "^0.15.5",
     "esbuild-register": "^3.3.3",
     "find-config": "^1.0.0",
+    "globby": "^11.1.0",
     "jsonc-parser": "^3.1.0",
     "mkdirp": "^1.0.4",
+    "ora": "^5.4.1",
     "pkg-up": "^3.1.0",
+    "prettier": "^2.7.1",
+    "pretty-bytes": "^5.6.0",
     "rimraf": "^3.0.2",
     "rollup": "^2.78.1",
-    "rollup-plugin-esbuild": "^4.9.3"
+    "rollup-plugin-esbuild": "^4.9.3",
+    "rxjs": "^7.5.6",
+    "treeify": "^1.1.0",
+    "zod": "^3.18.0"
   },
   "devDependencies": {
     "@commitlint/cli": "^17.0.3",
@@ -67,10 +81,13 @@
     "@sanity/semantic-release-preset": "^2.0.0",
     "@types/cpx": "^1.5.2",
     "@types/find-config": "^1.0.1",
+    "@types/globby": "^9.1.0",
     "@types/mkdirp": "^1.0.2",
     "@types/node": "^18.7.13",
+    "@types/prettier": "^2.7.0",
     "@types/rimraf": "^3.0.2",
     "@types/tmp": "^0.2.3",
+    "@types/treeify": "^1.0.0",
     "@typescript-eslint/eslint-plugin": "^5.35.1",
     "@typescript-eslint/parser": "^5.35.1",
     "commitizen": "^4.2.5",
@@ -81,7 +98,6 @@
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.1",
     "lint-staged": "^12.5.0",
-    "prettier": "^2.7.1",
     "semantic-release": "^19.0.5",
     "tmp": "^0.2.1",
     "ts-node": "^10.9.1",

package/src/cli/buildAction.ts

@@ -0,0 +1,8 @@
+import {build} from '../node/build'
+
+export async function buildAction(options: {tsconfig?: string}): Promise<void> {
+  return await build({
+    cwd: process.cwd(),
+    tsconfig: options.tsconfig,
+  })
+}

package/src/cli/index.ts

@@ -0,0 +1,41 @@
+import cac from 'cac'
+import {version} from '../../package.json'
+
+const cli = cac()
+
+// default commands checks package status
+cli
+  .command('', 'Status')
+  .option('--tsconfig [tsconfig]', '[string] tsconfig.json')
+  .action(async (options) => {
+    const {statusAction} = await import('./statusAction')
+
+    return statusAction(options)
+  })
+
+cli
+  .command('build', 'Build package')
+  .option('--tsconfig [tsconfig]', '[string] tsconfig.json')
+  .action(async (options) => {
+    const {buildAction} = await import('./buildAction')
+
+    return buildAction(options)
+  })
+
+cli
+  .command('watch', 'Watch package')
+  .option('--tsconfig [tsconfig]', '[string] tsconfig.json')
+  .action(async (options) => {
+    const {watchAction} = await import('./watchAction')
+
+    return watchAction(options)
+  })
+
+// Display help message when `-h` or `--help` appears
+cli.help()
+
+// Display version number when `-v` or `--version` appears
+// It's also used in help message
+cli.version(version)
+
+cli.parse()

package/src/cli/statusAction.ts

@@ -0,0 +1,8 @@
+import {check} from '../node/check'
+
+export async function statusAction(options: {tsconfig?: string}): Promise<void> {
+  return await check({
+    cwd: process.cwd(),
+    tsconfig: options.tsconfig,
+  })
+}

package/src/cli/watchAction.ts

@@ -0,0 +1,8 @@
+import {watch} from '../node/watch'
+
+export async function watchAction(options: {tsconfig?: string}): Promise<void> {
+  return await watch({
+    cwd: process.cwd(),
+    tsconfig: options.tsconfig,
+  })
+}

package/src/{core → node/_core}/_defaults.ts

@@ -1,6 +1,4 @@
-/**
- * @internal
- */
+/** @internal */
 export const _DEFAULTS = {
   browserslist: [
     '> 0.2% and supports es6-module and supports es6-module-dynamic-import',

package/src/{core → node/_core}/_isRecord.ts

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

package/src/{core → node/_core}/config/_loadConfig.ts

@@ -4,9 +4,7 @@ import findConfig from 'find-config'
 import pkgUp from 'pkg-up'
 import {PkgConfigOptions} from './types'
 
-/**
- * @internal
- */
+/** @internal */
 export async function _loadConfig(options: {cwd: string}): Promise<PkgConfigOptions | undefined> {
   const {cwd} = options
 

package/src/node/_core/config/_resolveConfigProperty.ts

@@ -0,0 +1,15 @@
+import {PkgConfigProperty, PkgConfigPropertyResolver} from './types'
+
+/** @internal */
+export function _resolveConfigProperty<T>(
+  prop: PkgConfigProperty<T> | undefined,
+  initialValue: T
+): T {
+  if (!prop) return initialValue
+
+  if (typeof prop === 'function') {
+    return (prop as PkgConfigPropertyResolver<T>)(initialValue)
+  }
+
+  return prop
+}

package/src/{core → node/_core}/config/defineConfig.ts

@@ -1,8 +1,6 @@
 import {PkgConfigOptions} from './types'
 
-/**
- * @public
- */
+/** @public */
 export function defineConfig(configOptions: PkgConfigOptions): PkgConfigOptions {
   return configOptions
 }

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

@@ -0,0 +1,69 @@
+/** @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
+  // }
+  import?: string
+  require?: string
+  source: string
+  types?: string
+}
+
+/** @public */
+export type PkgConfigPropertyResolver<T> = (prev: T) => T
+
+/** @public */
+export type PkgConfigProperty<T> = PkgConfigPropertyResolver<T> | T
+
+/** @public */
+export interface PkgExports {
+  [path: string]: PkgExport
+}
+
+/** @public */
+export type PkgRuleLevel = 'error' | 'warn' | 'info' | 'off'
+
+/** @public */
+export interface PkgConfigOptions {
+  /**
+   * Directory of distributed & bundled files.
+   */
+  dist?: string
+  exports?: PkgConfigProperty<PkgExports>
+  extract?: {
+    rules?: {
+      'ae-forgotten-export'?: PkgRuleLevel
+      'ae-incompatible-release-tags'?: PkgRuleLevel
+      'ae-internal-missing-underscore'?: PkgRuleLevel
+      'ae-missing-release-tag'?: PkgRuleLevel
+    }
+  }
+  /**
+   * Packages to exclude from the bundles.
+   */
+  external?: PkgConfigProperty<string[]>
+  minify?: boolean
+  /**
+   * Default runtime of package exports
+   */
+  runtime?: PkgRuntime
+  sourcemap?: boolean
+  /**
+   * Directory of source files.
+   */
+  src?: string
+}

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

@@ -0,0 +1,34 @@
+import ts from 'typescript'
+import {PkgExports, PkgRuntime, PkgConfigOptions} from '../config'
+import {_PackageJSON} from '../pkg'
+
+/** @internal */
+export interface _BuildFile {
+  type: 'asset' | 'chunk' | 'types'
+  path: string
+}
+
+/** @internal */
+export interface _BuildContext {
+  config?: PkgConfigOptions
+  cwd: string
+  dist: string
+  exports: PkgExports | undefined
+  external: string[]
+  files: _BuildFile[]
+  logger: {
+    log: (...args: unknown[]) => void
+    info: (...args: unknown[]) => void
+    warn: (...args: unknown[]) => void
+    error: (...args: unknown[]) => void
+    success: (...args: unknown[]) => void
+  }
+  pkg: _PackageJSON
+  runtime: PkgRuntime
+  src: string
+  target: Record<PkgRuntime, string[]>
+  ts: {
+    config?: ts.ParsedCommandLine
+    configPath?: string
+  }
+}

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

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

package/src/{core → node/_core}/index.ts

@@ -1,4 +1,6 @@
 export * from './_defaults'
 export * from './_isRecord'
 export * from './config'
+export * from './contexts'
 export * from './pkg'
+export * from './ts'

package/src/node/_core/pkg/_loadPkg.ts

@@ -0,0 +1,54 @@
+import fs from 'fs/promises'
+import pkgUp from 'pkg-up'
+import {z} from 'zod'
+import {_PackageJSON} from './_types'
+
+const pkgSchema = z.object({
+  type: z.optional(z.enum(['module'])),
+  name: z.string(),
+  version: 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.string(),
+  main: z.optional(z.string()),
+  browser: z.optional(z.record(z.string())),
+  module: z.optional(z.string()),
+  exports: z.optional(
+    z.record(
+      z.object({
+        source: z.string(),
+        browser: z.optional(
+          z.object({
+            require: z.optional(z.string()),
+            import: z.optional(z.string()),
+          })
+        ),
+        node: z.optional(
+          z.object({
+            require: z.optional(z.string()),
+            import: z.optional(z.string()),
+          })
+        ),
+        require: z.optional(z.string()),
+        import: z.optional(z.string()),
+        types: z.optional(z.string()),
+      })
+    )
+  ),
+  browserslist: z.optional(z.array(z.string())),
+})
+
+/** @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)
+
+  return pkgSchema.parse(JSON.parse(buf.toString()))
+}

package/src/node/_core/pkg/_loadPkgWithReporting.ts

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+
+import chalk from 'chalk'
+import {ZodError} from 'zod'
+import {_loadPkg} from './_loadPkg'
+import {_PackageJSON} from './_types'
+
+/** @internal */
+export async function _loadPkgWithReporting(options: {cwd: string}): Promise<_PackageJSON> {
+  try {
+    return await _loadPkg(options)
+  } catch (err) {
+    if (err instanceof ZodError) {
+      for (const issue of err.issues) {
+        if (issue.code === 'invalid_type') {
+          console.log(
+            `${chalk.red('invalid type')} in ./package.json at ${chalk.magenta(
+              `\`${issue.path.join('')}\``
+            )} (expected ${issue.expected}, received ${issue.received})`
+          )
+        }
+      }
+    } else {
+      console.error(err)
+    }
+
+    process.exit(1)
+  }
+}

package/src/node/_core/pkg/_parseExports.ts

@@ -0,0 +1,45 @@
+import {_isRecord} from '../_isRecord'
+import {PkgExport} from '../config'
+import {_PackageJSON} from './_types'
+
+/** @internal */
+export function _parseExports(options: {pkg: _PackageJSON}): (PkgExport & {_path: string})[] {
+  const {pkg} = options
+
+  const rootExport: PkgExport & {_path: string} = {
+    _exported: true,
+    _path: '.',
+    browser: pkg.browser && {
+      require: pkg.main && pkg.browser[pkg.main],
+      import: pkg.module && pkg.browser[pkg.module],
+    },
+    source: pkg.source || 'index.js',
+    require: pkg.main,
+    import: pkg.module,
+    types: pkg.types,
+  }
+
+  const extraExports: (PkgExport & {_path: string})[] = []
+
+  if (pkg.exports) {
+    for (const [exportPath, exportEntry] of Object.entries(pkg.exports)) {
+      if (_isRecord(exportEntry)) {
+        if (exportPath === '.') {
+          Object.assign(rootExport, exportEntry)
+        } else {
+          const extraExport: PkgExport & {_path: string} = {
+            _exported: true,
+            _path: exportPath,
+            ...exportEntry,
+          }
+
+          extraExports.push(extraExport)
+        }
+      } else {
+        throw new Error('string entries are not supported')
+      }
+    }
+  }
+
+  return [rootExport, ...extraExports]
+}

package/src/{core → node/_core}/pkg/_types.ts

@@ -1,6 +1,4 @@
-/**
- * @internal
- */
+/** @internal */
 export interface _PackageJSON {
   type?: 'module'
   version: string
@@ -10,9 +8,22 @@ export interface _PackageJSON {
   dependencies?: Record<string, string>
   devDependencies?: Record<string, string>
   peerDependencies?: Record<string, string>
-  exports?: Record<string, string | Record<string, string>>
+  exports?: Record<
+    string,
+    {
+      source: string
+      browser?: {
+        require?: string
+        import?: string
+      }
+      require?: string
+      import?: string
+      types?: string
+    }
+  >
   main?: string
-  source?: string
+  browser?: Record<string, string>
+  source: string
   module?: string
   types?: string
   browserslist?: string[]

package/src/{core → node/_core}/pkg/index.ts

@@ -1,3 +1,4 @@
 export * from './_loadPkg'
+export * from './_loadPkgWithReporting'
 export * from './_parseExports'
 export * from './_types'

package/src/{build/tasks/dts → node/_core/ts}/_loadTSConfig.ts

@@ -1,5 +1,6 @@
 import ts from 'typescript'
 
+/** @internal */
 export async function _loadTSConfig(options: {
   cwd: string
   tsconfigPath: string

package/src/node/_core/ts/index.ts

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

package/src/node/_getFilesize.ts

@@ -0,0 +1,8 @@
+import {statSync} from '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

@@ -0,0 +1,5 @@
+import globby from 'globby'
+
+export function _globFiles(patterns: string[]): Promise<string[]> {
+  return globby(patterns)
+}

package/src/node/_printExtractMessages.ts

@@ -0,0 +1,56 @@
+import path from 'path'
+import {ExtractorMessage} from '@microsoft/api-extractor'
+import chalk from 'chalk'
+import {_BuildContext} from './_core'
+
+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') {
+      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

@@ -0,0 +1,72 @@
+import fs from 'fs'
+import path from 'path'
+import chalk from 'chalk'
+import treeify from 'treeify'
+import {PkgExport, _BuildContext} from './_core'
+import {_getFilesize} from './_getFilesize'
+
+function _getFileExists(file: string) {
+  try {
+    fs.accessSync(file)
+
+    return true
+  } catch (_) {
+    return false
+  }
+}
+
+function _getFileInfo(cwd: string, filePath: string) {
+  const p = path.resolve(cwd, filePath)
+  const exists = _getFileExists(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)}`)
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const tree: Record<string, any> = {}
+
+  if (pkg.bin) {
+    tree.bin = pkg.bin
+  }
+
+  function _fileInfo(file: string) {
+    const info = _getFileInfo(cwd, file)
+
+    if (!info.size) {
+      return chalk.gray(file)
+    }
+
+    return `${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: entry.source}
+
+        if (entry.browser) {
+          exp.browser = {}
+
+          if (entry.browser.import) exp.browser.import = _fileInfo(entry.browser.import)
+          if (entry.browser.require) exp.browser.import = _fileInfo(entry.browser.require)
+        }
+
+        if (entry.import) exp.import = _fileInfo(entry.import)
+        if (entry.require) exp.require = _fileInfo(entry.require)
+        if (entry.types) exp.types = _fileInfo(entry.types)
+
+        return [chalk.green(path.join(pkg.name, exportPath)), exp]
+      })
+  )
+
+  logger.log(treeify.asTree(tree, true, true))
+}