@sanity/pkg-utils 1.1.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/pkg-utils",
-  "version": "1.1.0",
+  "version": "1.3.1",
   "author": "Sanity.io <hello@sanity.io>",
   "license": "MIT",
   "description": "Simple utilities for modern npm packages.",
@@ -48,10 +48,12 @@
     "@rollup/plugin-json": "^4.1.0",
     "@rollup/plugin-node-resolve": "^13.3.0",
     "@sanity/tsdoc-to-portable-text": "^0.4.1",
+    "browserslist": "^4.21.3",
     "cac": "^6.7.12",
     "chalk": "^4.1.2",
     "esbuild": "^0.15.5",
     "esbuild-register": "^3.3.3",
+    "find-config": "^1.0.0",
     "jsonc-parser": "^3.1.0",
     "mkdirp": "^1.0.4",
     "pkg-up": "^3.1.0",
@@ -64,6 +66,7 @@
     "@commitlint/config-conventional": "^17.0.3",
     "@sanity/semantic-release-preset": "^2.0.0",
     "@types/cpx": "^1.5.2",
+    "@types/find-config": "^1.0.1",
     "@types/mkdirp": "^1.0.2",
     "@types/node": "^18.7.13",
     "@types/rimraf": "^3.0.2",

package/src/build/_parseBrowserslistVersions.ts

@@ -0,0 +1,60 @@
+import browserslist from 'browserslist'
+
+export interface _PackageTargetVersions {
+  chrome: string[]
+  ff: string[]
+  edge: string[]
+  iosSaf: string[]
+  saf: string[]
+  opera: string[]
+  node: string[]
+}
+
+function _sortAsNumber(a: string, b: string) {
+  const aVersion = Number(a)
+  const bVersion = Number(b)
+
+  return aVersion - bVersion
+}
+
+export function _parseBrowserslistVersions(query: string[]): _PackageTargetVersions {
+  const result = browserslist(query)
+
+  const entries = result.map((key) => {
+    const [name, version] = key.split(' ')
+
+    return {name, version: version.split('-')[0].split('.')[0]}
+  })
+
+  const andChr = entries.filter((b) => b.name === 'and_chr')
+  const andFf = entries.filter((b) => b.name === 'and_ff')
+  const chrome = entries.filter((b) => b.name === 'chrome')
+  const edge = entries.filter((b) => b.name === 'edge')
+  const ff = entries.filter((b) => b.name === 'firefox')
+  const iosSaf = entries.filter((b) => b.name === 'ios_saf')
+  const saf = entries.filter((b) => b.name === 'safari')
+  const opera = entries.filter((b) => b.name === 'opera')
+  const node = entries.filter((b) => b.name === 'node')
+
+  // versions
+  const versions: _PackageTargetVersions = {
+    chrome: andChr.concat(chrome).map((b) => b.version),
+    ff: andFf.concat(ff).map((b) => b.version),
+    edge: edge.map((b) => b.version),
+    iosSaf: iosSaf.map((b) => b.version),
+    saf: saf.map((b) => b.version),
+    opera: opera.map((b) => b.version),
+    node: node.map((b) => b.version),
+  }
+
+  // sort
+  versions.chrome.sort(_sortAsNumber)
+  versions.ff.sort(_sortAsNumber)
+  versions.edge.sort(_sortAsNumber)
+  versions.iosSaf.sort(_sortAsNumber)
+  versions.saf.sort(_sortAsNumber)
+  versions.opera.sort(_sortAsNumber)
+  versions.node.sort(_sortAsNumber)
+
+  return versions
+}

package/src/build/_parseNodeTarget.ts

@@ -0,0 +1,15 @@
+import {_PackageTargetVersions} from './_parseBrowserslistVersions'
+
+export function _parseNodeTarget(versions: _PackageTargetVersions): string[] | undefined {
+  const target: string[] = []
+
+  if (versions.node.length) {
+    target.push(`node${versions.node[0]}`)
+  }
+
+  if (target.length === 0) {
+    return undefined
+  }
+
+  return target
+}

package/src/build/_parseTasks.ts

@@ -1,13 +1,13 @@
 import path from 'path'
 import {PackageSubPathExportEntry} from '../core'
 import {_BuildContext} from './_types'
-import {_RollupTask, _BuildTask, _DtsTask} from './tasks'
+import {_BuildTask, _DtsTask, _RollupTask} from './tasks'
 
 /**
  * @internal
  */
 export function _parseTasks(ctx: _BuildContext): _BuildTask[] {
-  const {pkg} = ctx
+  const {config, pkg} = ctx
 
   const entries = Object.entries(ctx.exports || {}).map(
     ([path, entry]) => ({path, ...entry} as PackageSubPathExportEntry & {path: string})
@@ -35,6 +35,8 @@ export function _parseTasks(ctx: _BuildContext): _BuildTask[] {
 
   // Parse `rollup` tasks
   for (const entry of entries) {
+    const runtime = entry.runtime || config?.runtime || 'web'
+
     const format: ('commonjs' | 'esm')[] = []
     const target: string[] = []
 
@@ -46,23 +48,23 @@ export function _parseTasks(ctx: _BuildContext): _BuildTask[] {
       format.push('esm')
     }
 
-    if (entry.runtime === 'node') {
-      target.push('node12')
+    if (runtime === 'node') {
+      target.push(...ctx.target.node)
     }
 
-    if (entry.runtime === 'web') {
-      target.push('chrome104')
+    if (runtime === 'web') {
+      target.push(...ctx.target.web)
     }
 
     for (const f of format) {
-      const buildId = `${entry.runtime}:${f}:${target.join(',')}`
+      const buildId = `${runtime}:${f}:${target.join(',')}`
 
       if (!rollupTasks[buildId]) {
         rollupTasks[buildId] = {
           type: 'rollup',
           buildId,
           entries: [entry],
-          runtime: entry.runtime,
+          runtime,
           format: f,
           target,
         }

package/src/build/_parseWebTarget.ts

@@ -0,0 +1,35 @@
+import {_PackageTargetVersions} from './_parseBrowserslistVersions'
+
+export function _parseWebTarget(versions: _PackageTargetVersions): string[] | undefined {
+  const target: string[] = []
+
+  if (versions.chrome.length) {
+    target.push(`chrome${versions.chrome[0]}`)
+  }
+
+  if (versions.ff.length) {
+    target.push(`firefox${versions.ff[0]}`)
+  }
+
+  if (versions.edge.length) {
+    target.push(`edge${versions.edge[0]}`)
+  }
+
+  if (versions.iosSaf.length) {
+    target.push(`ios${versions.iosSaf[0]}`)
+  }
+
+  if (versions.saf.length) {
+    target.push(`safari${versions.saf[0]}`)
+  }
+
+  if (versions.opera.length) {
+    target.push(`opera${versions.opera[0]}`)
+  }
+
+  if (target.length === 0) {
+    return undefined
+  }
+
+  return target
+}

package/src/build/_types.ts

@@ -21,5 +21,6 @@ export interface _BuildContext {
   dist: string
   pkg: _PackageJSON
   src: string
+  target: {node: string[]; web: string[]}
   tsconfig?: string
 }

package/src/build/build.ts

@@ -2,8 +2,18 @@
 
 import path from 'path'
 import chalk from 'chalk'
-import {PackageExports, _loadConfig, _loadPkg, _parseExports, _resolveConfigProperty} from '../core'
+import {
+  PackageExports,
+  _DEFAULTS,
+  _loadConfig,
+  _loadPkg,
+  _parseExports,
+  _resolveConfigProperty,
+} from '../core'
+import {_parseBrowserslistVersions} from './_parseBrowserslistVersions'
+import {_parseNodeTarget} from './_parseNodeTarget'
 import {_parseTasks} from './_parseTasks'
+import {_parseWebTarget} from './_parseWebTarget'
 import {_BuildContext} from './_types'
 import {_dtsTask, _extractTask, _rollupTask} from './tasks'
 
@@ -19,33 +29,37 @@ export async function build(options: {
   const pkg = await _loadPkg({cwd})
   const config = await _loadConfig({cwd})
 
-  // if (!config) {
-  //   console.log('no configuration found')
-  //   return
-  // }
-
   const parsedExports = _parseExports(pkg).reduce<PackageExports>((acc, x) => {
     const {path: exportPath, ...exportEntry} = x
 
     return {...acc, [exportPath]: exportEntry}
   }, {})
 
-  const exports = config?.exports
-    ? _resolveConfigProperty(config.exports, parsedExports)
-    : parsedExports
+  const exports = _resolveConfigProperty(config?.exports, parsedExports)
 
-  const initialExternal = [
+  const parsedExternal = [
     ...(pkg.dependencies ? Object.keys(pkg.dependencies) : []),
     ...(pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : []),
   ]
 
-  const external = config?.external
-    ? _resolveConfigProperty(config.external, initialExternal)
-    : initialExternal
+  const external = _resolveConfigProperty(config?.external, parsedExternal)
+
+  const targetVersions = _parseBrowserslistVersions(pkg.browserslist || _DEFAULTS.browserslist)
 
   const srcPath = path.resolve(cwd, config?.src || 'src')
   const distPath = path.resolve(cwd, config?.dist || 'dist')
 
+  const nodeTarget = _parseNodeTarget(targetVersions)
+  const webTarget = _parseWebTarget(targetVersions)
+
+  if (!nodeTarget) {
+    throw new Error('no matching `node` target')
+  }
+
+  if (!webTarget) {
+    throw new Error('no matching `web` target')
+  }
+
   const context: _BuildContext = {
     config,
     cwd,
@@ -56,11 +70,11 @@ export async function build(options: {
     dist: path.relative(cwd, distPath),
     pkg,
     src: path.relative(cwd, srcPath),
+    target: {node: nodeTarget, web: webTarget},
     tsconfig,
   }
 
   console.log(chalk.gray('cwd       '), context.cwd)
-  // console.log('external ', context.external)
   console.log(chalk.gray('src       '), context.src)
   console.log(chalk.gray('dist      '), context.dist)
   console.log(chalk.gray('tsconfig  '), context.tsconfig)

package/src/core/_defaults.ts

@@ -0,0 +1,11 @@
+/**
+ * @internal
+ */
+export const _DEFAULTS = {
+  browserslist: [
+    '> 0.2% and supports es6-module and supports es6-module-dynamic-import',
+    'not dead',
+    'not IE 11',
+    'maintained node versions',
+  ],
+}

package/src/core/config/_loadConfig.ts

@@ -1,5 +1,6 @@
 import path from 'path'
 import {register} from 'esbuild-register/dist/node'
+import findConfig from 'find-config'
 import pkgUp from 'pkg-up'
 import {PkgConfigOptions} from './types'
 
@@ -15,16 +16,40 @@ export async function _loadConfig(options: {cwd: string}): Promise<PkgConfigOpti
 
   const root = path.dirname(pkgPath)
 
+  const configFile = _findConfigFile(root)
+
+  if (!configFile) {
+    return undefined
+  }
+
   try {
-    const {unregister} = register({extensions: ['.js', '.ts']})
+    const {unregister} = configFile.transform
+      ? register({extensions: ['.js', '.ts']})
+      : {unregister: () => undefined}
 
     // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const mod = require(path.resolve(root, 'package.config.ts'))
+    const mod = require(configFile.path)
 
     unregister()
 
-    return mod.default
+    return mod?.default || mod || undefined
   } catch (_) {
     return undefined
   }
 }
+
+// Looks for:
+// 1. package.config.ts
+// 2. package.config.cjs
+//
+function _findConfigFile(cwd: string): {path: string; transform: boolean} | null {
+  const ts = findConfig('package.config.ts', {cwd})
+
+  if (ts) return {path: ts, transform: true}
+
+  const cjs = findConfig('package.config.cjs', {cwd})
+
+  if (cjs) return {path: cjs, transform: false}
+
+  return null
+}

package/src/core/config/_resolveConfigProperty.ts

@@ -3,7 +3,9 @@ import {ConfigProperty, ConfigPropertyResolver} from './types'
 /**
  * @internal
  */
-export function _resolveConfigProperty<T>(prop: ConfigProperty<T>, initialValue: T): T {
+export function _resolveConfigProperty<T>(prop: ConfigProperty<T> | undefined, initialValue: T): T {
+  if (!prop) return initialValue
+
   if (typeof prop === 'function') {
     return (prop as ConfigPropertyResolver<T>)(initialValue)
   }

package/src/core/config/types.ts

@@ -2,7 +2,7 @@
  * @public
  */
 export interface PackageSubPathExportEntry {
-  runtime: 'node' | 'web'
+  runtime?: 'node' | 'web'
 
   // paths
   source: string
@@ -41,6 +41,10 @@ export interface PkgConfigOptions {
    * Packages to exclude from the bundles.
    */
   external?: ConfigProperty<string[]>
+  /**
+   * Default runtime of package exports
+   */
+  runtime?: 'node' | 'web'
   /**
    * Directory of source files.
    */

package/src/core/index.ts

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

package/src/core/pkg/_parseExports.ts

@@ -8,7 +8,7 @@ import {_PackageJSON} from './_types'
 export function _parseExports(pkg: _PackageJSON): (PackageSubPathExportEntry & {path: string})[] {
   const rootExport: PackageSubPathExportEntry & {path: string} = {
     path: '.',
-    runtime: 'web',
+    runtime: undefined,
 
     source: pkg.source || 'index.js',
     require: pkg.main,
@@ -26,7 +26,6 @@ export function _parseExports(pkg: _PackageJSON): (PackageSubPathExportEntry & {
         } else {
           extraExports.push({
             path: exportPath,
-            runtime: 'web',
             source: exportEntry.source,
             ...exportEntry,
           })

package/src/core/pkg/_types.ts

@@ -15,4 +15,5 @@ export interface _PackageJSON {
   source?: string
   module?: string
   types?: string
+  browserslist?: string[]
 }