@sanity/pkg-utils 5.1.2 → 5.1.3

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

@@ -0,0 +1,144 @@
+import chalk from 'chalk'
+import path from 'path'
+import {rollup} from 'rollup'
+import {Observable} from 'rxjs'
+
+import {createConsoleSpy} from '../../consoleSpy'
+import type {BuildContext} from '../../core'
+import type {RollupLegacyTask, TaskHandler} from '../types'
+import {resolveRollupConfig} from './resolveRollupConfig'
+
+/** @internal */
+export const rollupLegacyTask: TaskHandler<RollupLegacyTask> = {
+  name: (ctx, task) => {
+    const entries = task.entries.filter((e) => !e.path.includes('__$$bundle_'))
+
+    const targetLines = task.target.length
+      ? ['  target:', ...task.target.map((t) => `    - ${chalk.yellow(t)}`)]
+      : []
+
+    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(''),
+          ),
+        ]
+      : []
+
+    // @TODO list out the root level files that are generated
+
+    return [
+      'Build legacy exports...',
+      `  format: ${chalk.yellow(task.format)}`,
+      ...targetLines,
+      ...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) => {
+    // eslint-disable-next-line no-console
+    console.error(err)
+  },
+}
+
+async function execPromise(ctx: BuildContext, task: RollupLegacyTask) {
+  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/rollupTask.ts

@@ -4,8 +4,8 @@ import {rollup} from 'rollup'
 import {Observable} from 'rxjs'
 
 import {createConsoleSpy} from '../../consoleSpy'
-import {BuildContext} from '../../core'
-import {RollupTask, TaskHandler} from '../types'
+import type {BuildContext} from '../../core'
+import type {RollupTask, TaskHandler} from '../types'
 import {resolveRollupConfig} from './resolveRollupConfig'
 
 /** @internal */

package/src/node/tasks/types.ts

@@ -1,8 +1,8 @@
-import {RollupWatcherEvent} from 'rollup'
-import {Observable} from 'rxjs'
+import type {RollupWatcherEvent} from 'rollup'
+import type {Observable} from 'rxjs'
 
-import {BuildContext, PkgRuntime} from '../core'
-import {DtsResult, DtsTask, DtsWatchTask} from './dts'
+import type {BuildContext, PkgRuntime} from '../core'
+import type {DtsResult, DtsTask, DtsWatchTask} from './dts'
 
 /** @internal */
 export interface RollupTaskEntry {
@@ -21,6 +21,16 @@ export interface RollupTask {
   target: string[]
 }
 
+/** @internal */
+export interface RollupLegacyTask {
+  type: 'build:legacy'
+  buildId: string
+  entries: RollupTaskEntry[]
+  runtime: PkgRuntime
+  format: 'esm'
+  target: string[]
+}
+
 /** @internal */
 export interface RollupWatchTask {
   type: 'watch:js'
@@ -32,7 +42,7 @@ export interface RollupWatchTask {
 }
 
 /** @internal */
-export type BuildTask = DtsTask | RollupTask
+export type BuildTask = DtsTask | RollupTask | RollupLegacyTask
 
 /** @internal */
 export type WatchTask = DtsWatchTask | RollupWatchTask
@@ -49,6 +59,7 @@ export type TaskHandler<Task, Result = void> = {
 export interface BuildTaskHandlers {
   'build:dts': TaskHandler<DtsTask, DtsResult>
   'build:js': TaskHandler<RollupTask>
+  'build:legacy': TaskHandler<RollupLegacyTask>
 }
 
 /** @internal */

package/src/node/watch.ts

@@ -1,11 +1,11 @@
 import path from 'path'
 import {switchMap} from 'rxjs'
 
-import {getPkgExtMap, loadConfig, loadPkgWithReporting} from './core'
+import {loadConfig, loadPkgWithReporting} from './core'
 import {createLogger} from './logger'
 import {resolveBuildContext} from './resolveBuildContext'
 import {resolveWatchTasks} from './resolveWatchTasks'
-import {TaskHandler, WatchTask, watchTaskHandlers} from './tasks'
+import {type TaskHandler, type WatchTask, watchTaskHandlers} from './tasks'
 import {watchConfigFiles} from './watchConfigFiles'
 
 /** @public */
@@ -32,10 +32,9 @@ export async function watch(options: {
 
       const pkg = await loadPkgWithReporting({cwd, logger, strict})
       const config = await loadConfig({cwd})
-      const extMap = getPkgExtMap({legacyExports: config?.legacyExports ?? false})
       const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'
 
-      return resolveBuildContext({config, cwd, extMap, logger, pkg, strict, tsconfig})
+      return resolveBuildContext({config, cwd, logger, pkg, strict, tsconfig})
     }),
   )