@sanity/pkg-utils 1.2.0 → 1.4.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,14 @@
+import {_loadConfig, _loadPkgWithReporting} from './_core'
+import {_printPackageTree} from './_printPackageTree'
+import {_resolveBuildContext} from './_resolveBuildContext'
+
+/** @public */
+export async function check(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})
+
+  _printPackageTree(ctx)
+}

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()
+        },
+      })
+    }
+  })
+}