@sanity/pkg-utils 1.0.0

package/src/build/tasks/dts/dts.ts

@@ -0,0 +1,60 @@
+/* eslint-disable no-console */
+
+import path from 'path'
+import {promisify} from 'util'
+import chalk from 'chalk'
+import rimrafCallback from 'rimraf'
+import {_BuildContext} from '../../_types'
+import {_buildTypes} from './_buildTypes'
+import {_extractTypes} from './_extractTypes'
+
+const rimraf = promisify(rimrafCallback)
+
+/**
+ * @internal
+ */
+export interface _DtsTask {
+  type: 'dts'
+  exportId: string
+  exportPath: string
+  source: string
+  output: string
+}
+
+/**
+ * @internal
+ */
+export async function _dtsTask(ctx: _BuildContext, task: _DtsTask): Promise<void> {
+  const {cwd, dist, files, tsconfig} = ctx
+  const exportPath = task.exportPath === '.' ? './index' : task.exportPath
+
+  console.log('=================================================================================')
+  console.log(chalk.gray('task      '), 'd.ts')
+  console.log(chalk.gray('source    '), path.join('', task.source))
+  console.log(chalk.gray('export    '), path.join(dist, `${exportPath}.d.ts`))
+
+  const distPath = path.resolve(cwd, dist)
+  const tmpPath = path.resolve(cwd, dist, 'tmp')
+
+  const tsconfigPath = path.resolve(cwd, tsconfig || 'tsconfig.json')
+
+  const types = await _buildTypes({
+    cwd,
+    outDir: tmpPath,
+    sourcePath: task.source,
+    tsconfigPath,
+  })
+
+  await _extractTypes({
+    cwd,
+    exportPath,
+    files,
+    projectPath: cwd,
+    sourcePath: types.path,
+    tsconfigPath,
+    distPath,
+  })
+
+  // Delete tmp directory
+  await rimraf(tmpPath)
+}

package/src/build/tasks/dts/index.ts

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

package/src/build/tasks/extract/_extractTask.ts

@@ -0,0 +1,49 @@
+/* eslint-disable no-console */
+
+import fs from 'fs/promises'
+import path from 'path'
+import {extract, transform} from '@sanity/tsdoc-to-portable-text'
+import chalk from 'chalk'
+import mkdirp from 'mkdirp'
+import {_BuildContext} from '../../_types'
+
+/**
+ * @internal
+ */
+export interface _ExtractTask {
+  type: 'extract'
+  mainEntryPointPath: string
+}
+
+export async function _extractTask(ctx: _BuildContext, task: _ExtractTask): Promise<void> {
+  const {mainEntryPointPath} = task
+
+  console.log('=================================================================================')
+  console.log(chalk.gray('task      '), 'extract')
+  console.log(
+    chalk.gray('source    '),
+    path.relative(ctx.cwd, path.resolve(ctx.cwd, mainEntryPointPath))
+  )
+
+  const extracted = await extract(ctx.cwd, {
+    tsconfigPath: path.resolve(ctx.cwd, ctx.tsconfig || 'tsconfig.json'),
+  })
+
+  const transformed = transform(extracted, {
+    package: {
+      version: ctx.pkg.version,
+    },
+  })
+
+  const apiJsonDirPath = path.resolve(ctx.cwd, 'etc/api', ctx.pkg.name)
+
+  await mkdirp(apiJsonDirPath)
+
+  const jsonPath = path.resolve(apiJsonDirPath, `${ctx.pkg.version}.json`)
+
+  if (transformed.length) {
+    await fs.writeFile(jsonPath, JSON.stringify(transformed, null, 2) + '\n')
+
+    console.log(chalk.gray('result    '), path.relative(ctx.cwd, jsonPath))
+  }
+}

package/src/build/tasks/extract/index.ts

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

package/src/build/tasks/index.ts

@@ -0,0 +1,4 @@
+export * from './_types'
+export * from './dts'
+export * from './extract'
+export * from './rollup'

package/src/build/tasks/rollup/_resolveRollupConfig.ts

@@ -0,0 +1,95 @@
+import commonjs from '@rollup/plugin-commonjs'
+import json from '@rollup/plugin-json'
+import {nodeResolve} from '@rollup/plugin-node-resolve'
+import {InputOptions, OutputOptions} from 'rollup'
+import esbuild from 'rollup-plugin-esbuild'
+import {_BuildContext} from '../../_types'
+import {_RollupTask} from './rollup'
+
+/**
+ * @internal
+ */
+export function _resolveRollupConfig(
+  ctx: _BuildContext,
+  buildTask: _RollupTask
+): {
+  inputOptions: InputOptions
+  outputOptions: OutputOptions
+} {
+  const {format, runtime, target} = buildTask
+  const {cwd, external, dist: outDir, pkg, tsconfig} = ctx
+  const outputExt = format === 'commonjs' ? '.cjs' : pkg.type === 'module' ? '.mjs' : '.js'
+
+  return {
+    inputOptions: {
+      context: cwd,
+
+      external,
+
+      input: buildTask.entries.reduce<{[entryAlias: string]: string}>((acc, entry) => {
+        const key = entry.path === '.' ? 'index' : entry.path.slice(2)
+
+        return {...acc, [key]: entry.source || ''}
+      }, {}),
+
+      plugins: [
+        nodeResolve({
+          mainFields: ['module', 'jsnext', 'main'],
+          browser: runtime !== 'node',
+          exportConditions: [runtime === 'node' ? 'node' : 'browser'],
+          extensions: ['.cjs', '.mjs', '.js', '.jsx', '.json', '.node'],
+          preferBuiltins: runtime === 'node',
+        }),
+        commonjs({
+          esmExternals: false,
+          include: /\/node_modules\//,
+          // requireReturnsDefault: 'namespace',
+        }),
+        json(),
+        esbuild({
+          // include: /\.[jt]sx?$/, // default, inferred from `loaders` option
+          // exclude: /node_modules/, // default
+          // sourceMap: false, // by default inferred from rollup's `output.sourcemap` option
+          minify: false, // process.env.NODE_ENV === 'production',
+          // target: 'es2017', // default, or 'es20XX', 'esnext'
+          jsx: 'transform', // default, or 'preserve'
+          jsxFactory: 'React.createElement',
+          jsxFragment: 'React.Fragment',
+          // // Like @rollup/plugin-replace
+          // define: {
+          //   __VERSION__: '"x.y.z"',
+          // },
+          // plugins: [],
+          target,
+          // target:
+          //   target === 'node'
+          //     ? ['node12']
+          //     : ['es2020', 'chrome104', 'edge104', 'firefox103', 'safari15'],
+          tsconfig: tsconfig || 'tsconfig.json', // 'tsconfig.json', // default
+          // Add extra loaders
+          loaders: {
+            // Add .json files support
+            // require @rollup/plugin-commonjs
+            '.json': 'json',
+            // Enable JSX in .js files too
+            // '.js': 'jsx',
+          },
+        }),
+      ],
+
+      treeshake: {
+        propertyReadSideEffects: false,
+      },
+    },
+    outputOptions: {
+      chunkFileNames: () => `_[name]-[hash]${outputExt}`,
+      dir: outDir,
+      entryFileNames: () => `[name]${outputExt}`,
+      format,
+      esModule: false,
+      exports: 'auto',
+      freeze: false,
+      sourcemap: true,
+    },
+  }
+}

package/src/build/tasks/rollup/index.ts

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

package/src/build/tasks/rollup/rollup.ts

@@ -0,0 +1,96 @@
+/* eslint-disable no-console */
+
+import path from 'path'
+import chalk from 'chalk'
+import {rollup} from 'rollup'
+import {PackageSubPathExportEntry} from '../../../core'
+import {_BuildContext} from '../../_types'
+import {_resolveRollupConfig} from './_resolveRollupConfig'
+
+/**
+ * @internal
+ */
+export interface _RollupTask {
+  type: 'rollup'
+  buildId: string
+  entries: (PackageSubPathExportEntry & {path: string})[]
+  runtime: 'node' | 'web'
+  format: 'commonjs' | 'esm'
+  target: string[]
+}
+
+export async function _rollupTask(ctx: _BuildContext, buildTask: _RollupTask): Promise<void> {
+  console.log('=================================================================================')
+
+  console.log(chalk.gray('task      '), 'rollup')
+  console.log(chalk.gray('target    '), buildTask.target.join(', '))
+  console.log(chalk.gray('format    '), buildTask.format)
+
+  const {cwd, files, dist: outDir, pkg} = ctx
+
+  const {inputOptions, outputOptions} = _resolveRollupConfig(ctx, buildTask)
+
+  // Create bundle
+  const bundle = await rollup(inputOptions)
+
+  // an array of file names this bundle depends on
+  // console.log(bundle.watchFiles)
+
+  // generate output specific code in-memory
+  // you can call this function multiple times on the same bundle object
+  const {output} = await bundle.generate(outputOptions)
+
+  for (const chunkOrAsset of output) {
+    if (chunkOrAsset.type === 'asset') {
+      files.push({
+        type: 'asset',
+        path: path.resolve(outDir, chunkOrAsset.fileName),
+      })
+    } else {
+      files.push({
+        type: 'chunk',
+        path: path.resolve(outDir, chunkOrAsset.fileName),
+      })
+    }
+  }
+
+  // or write the bundle to disk
+  await bundle.write(outputOptions)
+
+  // closes the bundle
+  await bundle.close()
+
+  for (const entry of buildTask.entries) {
+    console.log(`- ${path.join(pkg.name, entry.path)}`)
+
+    console.log(chalk.gray('  source  '), path.relative(cwd, path.resolve(cwd, entry.source)))
+
+    const defaultFile = files.find(
+      (f) => entry.default && f.path === path.resolve(cwd, entry.default)
+    )
+
+    const requireFile = files.find(
+      (f) => entry.require && f.path === path.resolve(cwd, entry.require)
+    )
+
+    const typesFile = files.find((f) => entry.types && f.path === path.resolve(cwd, entry.types))
+
+    if (buildTask.format.includes('esm'))
+      console.log(
+        chalk.gray('  default '),
+        defaultFile ? path.relative(cwd, defaultFile.path) : undefined
+      )
+
+    if (buildTask.format.includes('commonjs'))
+      console.log(
+        chalk.gray('  require '),
+        requireFile ? path.relative(cwd, requireFile.path) : undefined
+      )
+
+    if (entry.types)
+      console.log(
+        chalk.gray('  types   '),
+        typesFile ? path.relative(cwd, typesFile.path) : undefined
+      )
+  }
+}

package/src/cli.ts

@@ -0,0 +1,25 @@
+import cac from 'cac'
+import {build} from './build'
+
+const cli = cac()
+
+cli
+  .command('build', 'Build package')
+  .option('--extract', 'Extract API reference')
+  .option('--tsconfig [tsconfig]', '[string] tsconfig.json')
+  .action(async (options) => {
+    await build({
+      cwd: process.cwd(),
+      extract: options.extract ? Boolean(options.extract) : undefined,
+      tsconfig: options.tsconfig,
+    })
+  })
+
+// 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('0.0.0')
+
+cli.parse()

package/src/core/_isRecord.ts

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

package/src/core/config/_loadConfig.ts

@@ -0,0 +1,30 @@
+import path from 'path'
+import {register} from 'esbuild-register/dist/node'
+import pkgUp from 'pkg-up'
+import {PkgConfigOptions} from './types'
+
+/**
+ * @internal
+ */
+export async function _loadConfig(options: {cwd: string}): Promise<PkgConfigOptions | undefined> {
+  const {cwd} = options
+
+  const pkgPath = await pkgUp({cwd})
+
+  if (!pkgPath) return undefined
+
+  const root = path.dirname(pkgPath)
+
+  try {
+    const {unregister} = register({extensions: ['.js', '.ts']})
+
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const mod = require(path.resolve(root, 'package.config.ts'))
+
+    unregister()
+
+    return mod.default
+  } catch (_) {
+    return undefined
+  }
+}

package/src/core/config/_resolveConfigProperty.ts

@@ -0,0 +1,12 @@
+import {ConfigProperty, ConfigPropertyResolver} from './types'
+
+/**
+ * @internal
+ */
+export function _resolveConfigProperty<T>(prop: ConfigProperty<T>, initialValue: T): T {
+  if (typeof prop === 'function') {
+    return (prop as ConfigPropertyResolver<T>)(initialValue)
+  }
+
+  return prop
+}

package/src/core/config/defineConfig.ts

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

package/src/core/config/index.ts

@@ -0,0 +1,4 @@
+export * from './_loadConfig'
+export * from './_resolveConfigProperty'
+export * from './defineConfig'
+export * from './types'

package/src/core/config/types.ts

@@ -0,0 +1,48 @@
+/**
+ * @public
+ */
+export interface PackageSubPathExportEntry {
+  runtime: 'node' | 'web'
+
+  // paths
+  source: string
+  require?: string
+  default?: string
+  types?: string
+}
+
+/**
+ * @public
+ */
+export type ConfigPropertyResolver<T> = (prev: T) => T
+
+/**
+ * @public
+ */
+export type ConfigProperty<T> = ConfigPropertyResolver<T> | T
+
+/**
+ * @public
+ */
+export interface PackageExports {
+  [path: string]: PackageSubPathExportEntry
+}
+
+/**
+ * @public
+ */
+export interface PkgConfigOptions {
+  /**
+   * Directory of distributed & bundled files.
+   */
+  dist?: string
+  exports?: ConfigProperty<PackageExports>
+  /**
+   * Packages to exclude from the bundles.
+   */
+  external?: ConfigProperty<string[]>
+  /**
+   * Directory of source files.
+   */
+  src?: string
+}

package/src/core/index.ts

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

package/src/core/pkg/_loadPkg.ts

@@ -0,0 +1,13 @@
+import pkgUp from 'pkg-up'
+import {_PackageJSON} from './_types'
+
+/**
+ * @internal
+ */
+export async function _loadPkg(options: {cwd: string}): Promise<_PackageJSON> {
+  const {cwd} = options
+
+  const pkgPath = await pkgUp({cwd})
+
+  return pkgPath ? require(pkgPath) : undefined
+}

package/src/core/pkg/_parseExports.ts

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

package/src/core/pkg/_types.ts

@@ -0,0 +1,18 @@
+/**
+ * @internal
+ */
+export interface _PackageJSON {
+  type?: 'module'
+  version: string
+  private?: boolean
+  name: string
+  bin?: Record<string, string>
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+  peerDependencies?: Record<string, string>
+  exports?: Record<string, string | Record<string, string>>
+  main?: string
+  source?: string
+  module?: string
+  types?: string
+}

package/src/core/pkg/index.ts

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

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './build'
+export * from './core'