@sanity/pkg-utils 1.3.1 → 1.5.0

package/src/node/_watchConfigFiles.ts

@@ -0,0 +1,52 @@
+import path from 'path'
+import chalk from 'chalk'
+import {Observable} from 'rxjs'
+import {distinctUntilChanged, scan, startWith} from 'rxjs/operators'
+import {_globFiles} from './_globFiles'
+import {_watchFiles} from './_watchFiles'
+
+export async function _watchConfigFiles(options: {cwd: string}): Promise<Observable<string[]>> {
+  const {cwd} = options
+
+  const initialFiles = await _globFiles([
+    path.resolve(cwd, 'package.json'),
+    path.resolve(cwd, 'package.config.cjs'),
+    path.resolve(cwd, 'package.config.js'),
+    path.resolve(cwd, 'package.config.ts'),
+  ])
+
+  const fileEvent$ = _watchFiles([
+    path.resolve(cwd, 'package.json'),
+    path.resolve(cwd, 'package.config.cjs'),
+    path.resolve(cwd, 'package.config.js'),
+    path.resolve(cwd, 'package.config.ts'),
+  ])
+
+  return fileEvent$.pipe(
+    scan((files, fileEvent) => {
+      if (fileEvent.type === 'add') {
+        return files.concat(fileEvent.file)
+      }
+
+      if (fileEvent.type === 'unlink') {
+        return files.filter((f) => f !== fileEvent.file)
+      }
+
+      if (fileEvent.type === 'change') {
+        /* eslint-disable no-console */
+        console.log(
+          '--------------------------------------------------------------------------------'
+        )
+        console.log(chalk.blue('info  '), path.relative(cwd, fileEvent.file), 'changed')
+        console.log('')
+        /* eslint-enable no-console */
+
+        return files.slice(0) // trigger update
+      }
+
+      return files
+    }, initialFiles),
+    startWith(initialFiles),
+    distinctUntilChanged()
+  )
+}

package/src/node/_watchFiles.ts

@@ -0,0 +1,29 @@
+import chokidar from 'chokidar'
+import {Observable} from 'rxjs'
+
+export interface _FileEvent {
+  type: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir'
+  file: string
+}
+
+export function _watchFiles(patterns: string[]): Observable<_FileEvent> {
+  return new Observable((observer) => {
+    const watcher = chokidar.watch(patterns, {
+      ignoreInitial: true,
+    })
+
+    function _handleFileEvent(
+      type: 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir',
+      file: string
+    ) {
+      observer.next({type, file})
+    }
+
+    watcher.on('all', _handleFileEvent)
+
+    return () => {
+      watcher.off('all', _handleFileEvent)
+      watcher.close()
+    }
+  })
+}

package/src/node/build.ts

@@ -0,0 +1,47 @@
+import {_loadConfig, _loadPkgWithReporting} from './_core'
+import {_printPackageTree} from './_printPackageTree'
+import {_resolveBuildContext} from './_resolveBuildContext'
+import {_resolveBuildTasks} from './_resolveBuildTasks'
+import {_spinner} from './_spinner'
+import {_BuildTask, _TaskHandler, _buildTaskHandlers} from './_tasks'
+
+/** @public */
+export async function build(options: {cwd: string; tsconfig?: string}): Promise<void> {
+  const {cwd, tsconfig = 'tsconfig.json'} = options
+
+  const pkg = await _loadPkgWithReporting({cwd})
+  const config = await _loadConfig({cwd})
+
+  const ctx = await _resolveBuildContext({config, cwd, pkg, tsconfig})
+
+  const buildTasks = _resolveBuildTasks(ctx)
+
+  for (const task of buildTasks) {
+    const handler = _buildTaskHandlers[task.type] as _TaskHandler<_BuildTask>
+    const taskName = handler.name(ctx, task)
+
+    const spinner = _spinner(taskName)
+
+    try {
+      const result = await handler.exec(ctx, task).toPromise()
+
+      spinner.complete()
+      ctx.logger.log()
+
+      handler.complete(ctx, task, result)
+    } catch (err) {
+      spinner.error()
+
+      if (err instanceof Error) {
+        ctx.logger.error(err.message.replaceAll(cwd, '.'))
+        ctx.logger.log()
+      }
+
+      handler.error(ctx, task, err)
+
+      process.exit(1)
+    }
+  }
+
+  _printPackageTree(ctx)
+}

package/src/node/check.ts

@@ -0,0 +1,136 @@
+/* eslint-disable no-console */
+
+import path from 'path'
+import chalk from 'chalk'
+import esbuild, {BuildFailure} from 'esbuild'
+import {_loadConfig, _loadPkgWithReporting} from './_core'
+import {_fileExists, _printPackageTree} from './_printPackageTree'
+import {_resolveBuildContext} from './_resolveBuildContext'
+
+/** @public */
+export async function check(options: {
+  cwd: string
+  strict?: boolean
+  tsconfig?: string
+}): Promise<void> {
+  const {cwd, strict, tsconfig = 'tsconfig.json'} = options
+
+  const pkg = await _loadPkgWithReporting({cwd})
+  const config = await _loadConfig({cwd})
+  const ctx = await _resolveBuildContext({config, cwd, pkg, tsconfig})
+
+  _printPackageTree(ctx)
+
+  if (strict) {
+    const missingFiles: string[] = []
+
+    // Check if there are missing files
+    for (const [, exp] of Object.entries(ctx.exports || {})) {
+      if (exp.source && !_fileExists(path.resolve(cwd, exp.source))) {
+        missingFiles.push(exp.source)
+      }
+
+      if (exp.require && !_fileExists(path.resolve(cwd, exp.require))) {
+        missingFiles.push(exp.require)
+      }
+
+      if (exp.import && !_fileExists(path.resolve(cwd, exp.import))) {
+        missingFiles.push(exp.import)
+      }
+
+      if (exp.types && !_fileExists(path.resolve(cwd, exp.types))) {
+        missingFiles.push(exp.types)
+      }
+    }
+
+    if (missingFiles.length) {
+      throw new Error('missing files')
+    }
+
+    // Check if the files are resolved
+    const _paths: {require: string[]; import: string[]} = {
+      require: [],
+      import: [],
+    }
+
+    for (const [exportPath, exp] of Object.entries(ctx.exports || {})) {
+      if (!exp._exported) continue
+      if (exp.require) _paths.require.push(exportPath)
+      if (exp.import) _paths.import.push(exportPath)
+    }
+
+    const external = Object.keys(pkg.dependencies || {}).concat(
+      Object.keys(pkg.devDependencies || {})
+    )
+
+    if (_paths.import.length) {
+      const code = _paths.import.map((id) => `import('${id}')`).join('\n')
+
+      try {
+        const esbuildResult = await esbuild.build({
+          external,
+          stdin: {
+            contents: code,
+            loader: 'js',
+            resolveDir: cwd,
+          },
+          format: 'esm',
+          bundle: true,
+          logLevel: 'silent',
+          // otherwise output maps to stdout as we're using stdin
+          outfile: '/dev/null',
+          platform: 'node',
+        })
+
+        if (esbuildResult.warnings.length > 0) {
+          console.warn(...esbuildResult.warnings)
+        }
+      } catch (err) {
+        const {errors} = err as BuildFailure
+
+        for (const _err of errors) {
+          if (_err.location) {
+            console.log(chalk.red('error'), _err.detail || _err.text)
+            console.log(`${_err.location.line} | ${_err.location.lineText}`)
+            console.log(
+              'in',
+              `./${_err.location.file}:${_err.location.line}:${_err.location.column}`
+            )
+          } else {
+            console.log(_err.detail || _err.text)
+          }
+
+          console.log()
+        }
+
+        process.exit(1)
+      }
+    }
+
+    if (_paths.require.length) {
+      const code = _paths.require.map((id) => `require('${id}')`).join('\n')
+
+      const esbuildResult = await esbuild.build({
+        external,
+        stdin: {
+          contents: code,
+          loader: 'js',
+          resolveDir: cwd,
+        },
+        format: 'cjs',
+        bundle: true,
+        // otherwise output maps to stdout as we're using stdin
+        outfile: '/dev/null',
+        platform: 'node',
+      })
+
+      if (esbuildResult.errors.length > 0) {
+        throw new Error(esbuildResult.errors.join(', '))
+      }
+
+      if (esbuildResult.warnings.length > 0) {
+        console.warn(...esbuildResult.warnings)
+      }
+    }
+  }
+}

package/src/node/index.ts

@@ -0,0 +1,6 @@
+export * from './_core'
+export * from './_resolveBuildTasks'
+export * from './_tasks'
+export * from './build'
+export * from './check'
+export * from './watch'

package/src/node/watch.ts

@@ -0,0 +1,56 @@
+import path from 'path'
+import {switchMap} from 'rxjs'
+import {_loadConfig, _loadPkgWithReporting} from './_core'
+import {_resolveBuildContext} from './_resolveBuildContext'
+import {_resolveWatchTasks} from './_resolveWatchTasks'
+import {_WatchTask, _TaskHandler, _watchTaskHandlers} from './_tasks'
+import {_watchConfigFiles} from './_watchConfigFiles'
+
+/** @public */
+export async function watch(options: {cwd: string; tsconfig?: string}): Promise<void> {
+  const {cwd, tsconfig = 'tsconfig.json'} = options
+
+  const configFiles$ = await _watchConfigFiles({cwd})
+
+  const ctx$ = configFiles$.pipe(
+    switchMap(async (configFiles) => {
+      const _files = configFiles.map((f) => path.relative(cwd, f))
+
+      const packageJsonPath = _files.find((f) => f === 'package.json')
+
+      if (!packageJsonPath) {
+        throw new Error('missing package.json')
+      }
+
+      const pkg = await _loadPkgWithReporting({cwd})
+      const config = await _loadConfig({cwd})
+
+      return _resolveBuildContext({config, cwd, pkg, tsconfig})
+    })
+  )
+
+  ctx$.subscribe(async (ctx) => {
+    const watchTasks = _resolveWatchTasks(ctx)
+
+    for (const task of watchTasks) {
+      const handler = _watchTaskHandlers[task.type] as _TaskHandler<_WatchTask, any>
+      const result$ = handler.exec(ctx, task)
+
+      result$.subscribe({
+        error: (err) => {
+          ctx.logger.error(err)
+          ctx.logger.log()
+
+          process.exit(1)
+        },
+        next: (result) => {
+          handler.complete(ctx, task, result)
+        },
+        complete: () => {
+          ctx.logger.success(handler.name(ctx, task))
+          ctx.logger.log()
+        },
+      })
+    }
+  })
+}