@sanity/pkg-utils 7.2.10-canary.0 → 7.2.10-canary.2

package/src/node/tasks/rollup/rollupTask.ts

@@ -1,154 +0,0 @@
-import path from 'node:path'
-import chalk from 'chalk'
-import {rollup} from 'rollup'
-import {Observable} from 'rxjs'
-import {createConsoleSpy} from '../../consoleSpy'
-import type {BuildContext} from '../../core/contexts/buildContext'
-import type {RollupTask, TaskHandler} from '../types'
-import {resolveRollupConfig} from './resolveRollupConfig'
-
-/** @internal */
-export const rollupTask: TaskHandler<RollupTask> = {
-  name: (ctx, task) => {
-    const bundleEntries = task.entries.filter((e) => e.path.includes('__$$bundle_'))
-    const entries = task.entries.filter((e) => !e.path.includes('__$$bundle_'))
-
-    const targetLines = task.target.length
-      ? [`  target:`, ...task.target.map((t) => `    - ${chalk.yellow(t)}`)]
-      : []
-
-    const bundlesLines = bundleEntries.length
-      ? [
-          '  bundles:',
-          ...bundleEntries.map((e) =>
-            [
-              `    - `,
-              `${chalk.yellow(e.source)} ${chalk.gray('→')} ${chalk.yellow(e.output)}`,
-            ].join(''),
-          ),
-        ]
-      : []
-
-    const entriesLines = entries.length
-      ? [
-          '  entries:',
-          ...entries.map((e) =>
-            [
-              `    - `,
-              `${chalk.cyan(path.join(ctx.pkg.name, e.path))}: `,
-              `${chalk.yellow(e.source)} ${chalk.gray('→')} ${chalk.yellow(e.output)}`,
-            ].join(''),
-          ),
-        ]
-      : []
-
-    return [
-      `Build javascript files...`,
-      `  format: ${chalk.yellow(task.format)}`,
-      ...targetLines,
-      ...bundlesLines,
-      ...entriesLines,
-    ].join('\n')
-  },
-  exec: (ctx, task) => {
-    return new Observable((observer) => {
-      execPromise(ctx, task)
-        .then((result) => {
-          observer.next(result)
-          observer.complete()
-        })
-        .catch((err) => observer.error(err))
-    })
-  },
-  complete: () => {
-    //
-  },
-  error: (_ctx, _task, err) => {
-    console.error(err)
-  },
-}
-
-async function execPromise(ctx: BuildContext, task: RollupTask) {
-  const {distPath, files, logger} = ctx
-  const outDir = path.relative(ctx.cwd, distPath)
-
-  // Prevent rollup from printing directly to the console
-  const consoleSpy = createConsoleSpy({
-    onRestored: (messages) => {
-      for (const msg of messages) {
-        const text = String(msg.args[0])
-
-        if (msg.code === 'CIRCULAR_DEPENDENCY') {
-          continue // ignore
-        }
-
-        if (text.startsWith('Dynamic import can only')) {
-          continue // ignore
-        }
-
-        if (text.startsWith('Sourcemap is likely to be incorrect')) {
-          continue // ignore
-        }
-
-        if (msg.type === 'log') {
-          logger.info(...msg.args)
-        }
-
-        if (msg.type === 'warn') {
-          logger.warn(...msg.args)
-        }
-
-        if (msg.type === 'error') {
-          logger.error(...msg.args)
-        }
-      }
-    },
-  })
-
-  try {
-    const {inputOptions, outputOptions} = resolveRollupConfig(ctx, task)
-
-    // Create bundle
-    const bundle = await rollup({
-      ...inputOptions,
-      onwarn(warning) {
-        consoleSpy.messages.push({
-          type: 'warn',
-          code: warning.code,
-          args: [warning.message],
-        })
-      },
-    })
-
-    // 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()
-
-    // Restore console
-    consoleSpy.restore()
-  } catch (err) {
-    // Restore console
-    consoleSpy.restore()
-    throw err
-  }
-}

package/src/node/tasks/rollup/rollupWatchTask.ts

@@ -1,77 +0,0 @@
-import path from 'node:path'
-import chalk from 'chalk'
-import {watch as rollupWatch, type RollupWatcherEvent, type RollupWatchOptions} from 'rollup'
-import {Observable} from 'rxjs'
-import type {RollupWatchTask, TaskHandler} from '../types'
-import {resolveRollupConfig} from './resolveRollupConfig'
-
-/** @internal */
-export const rollupWatchTask: TaskHandler<RollupWatchTask, RollupWatcherEvent> = {
-  name: (ctx, task) =>
-    `build javascript files (target ${task.target.join(' + ')}, format ${
-      task.format
-    })\n       ${task.entries
-      .map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`)
-      .join('\n       ')}`,
-  exec: (ctx, task) => {
-    const {inputOptions, outputOptions} = resolveRollupConfig(ctx, task)
-
-    return new Observable((observer) => {
-      const watchOptions: RollupWatchOptions = {
-        ...inputOptions,
-        output: outputOptions,
-      }
-
-      const watcher = rollupWatch(watchOptions)
-
-      watcher.on('event', (event) => {
-        observer.next(event)
-      })
-
-      return () => {
-        watcher.close()
-      }
-    })
-  },
-  complete: (ctx, task, event) => {
-    const {logger} = ctx
-
-    if (event.code === 'BUNDLE_END') {
-      logger.success(
-        `build javascript files (target ${task.target.join(' + ')}, format ${
-          task.format
-        })\n       ${task.entries
-          .map((e) => `${chalk.blue(path.join(ctx.pkg.name, e.path))}: ${e.source} -> ${e.output}`)
-          .join('\n       ')}`,
-      )
-      logger.log('')
-
-      return
-    }
-
-    if (event.code === 'BUNDLE_START') {
-      return
-    }
-
-    if (event.code === 'END') {
-      return
-    }
-
-    if (event.code === 'ERROR') {
-      logger.error(event.code, event)
-
-      return
-    }
-
-    if (event.code === 'START') {
-      return
-    }
-  },
-  error: (ctx, _task, err) => {
-    const {logger} = ctx
-
-    if (err instanceof Error) {
-      logger.log(err)
-    }
-  },
-}

package/src/node/tasks/types.ts

@@ -1,69 +0,0 @@
-import type {RollupWatcherEvent} from 'rollup'
-import type {Observable} from 'rxjs'
-import type {PkgRuntime} from '../core/config/types'
-import type {BuildContext} from '../core/contexts/buildContext'
-import type {DtsResult, DtsTask, DtsWatchTask} from './dts/types'
-
-/** @internal */
-export interface RollupTaskEntry {
-  path: string
-  source: string
-  output: string
-}
-
-/** @internal */
-export interface RollupTask {
-  type: 'build:js'
-  buildId: string
-  entries: RollupTaskEntry[]
-  runtime: PkgRuntime
-  format: 'commonjs' | 'esm'
-  target: string[]
-}
-
-/** @internal */
-export interface RolldownDtsTask {
-  type: 'rolldown:dts'
-  buildId: string
-  entries: RollupTaskEntry[]
-  runtime: PkgRuntime
-  format: 'commonjs' | 'esm'
-  target: string[]
-}
-
-/** @internal */
-export interface RollupWatchTask {
-  type: 'watch:js'
-  buildId: string
-  entries: RollupTaskEntry[]
-  runtime: PkgRuntime
-  format: 'commonjs' | 'esm'
-  target: string[]
-}
-
-/** @internal */
-export type BuildTask = DtsTask | RollupTask | RolldownDtsTask
-
-/** @internal */
-export type WatchTask = DtsWatchTask | RollupWatchTask
-
-/** @internal */
-export type TaskHandler<Task, Result = void> = {
-  name: (ctx: BuildContext, task: Task) => string
-  exec: (ctx: BuildContext, task: Task) => Observable<Result>
-  complete: (ctx: BuildContext, task: Task, result: Result) => void
-  error: (ctx: BuildContext, task: Task, error: unknown) => void
-}
-
-/** @internal */
-export interface BuildTaskHandlers {
-  'build:dts': TaskHandler<DtsTask, DtsResult>
-  'build:js': TaskHandler<RollupTask>
-  'rolldown:dts': TaskHandler<RolldownDtsTask>
-}
-
-/** @internal */
-export interface WatchTaskHandlers {
-  'watch:dts': TaskHandler<DtsWatchTask, DtsResult>
-  'watch:js': TaskHandler<RollupWatchTask, RollupWatcherEvent>
-}

package/src/node/templates/default/index.ts

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