@sanity/pkg-utils 6.13.3 → 6.13.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/pkg-utils",
-  "version": "6.13.3",
+  "version": "6.13.4",
   "description": "Simple utilities for modern npm packages.",
   "keywords": [
     "sanity-io",
@@ -70,7 +70,7 @@
     "@babel/core": "^7.26.0",
     "@babel/preset-typescript": "^7.26.0",
     "@babel/types": "^7.26.3",
-    "@microsoft/api-extractor": "7.49.0",
+    "@microsoft/api-extractor": "7.48.1",
     "@microsoft/tsdoc-config": "0.17.1",
     "@optimize-lodash/rollup-plugin": "5.0.0",
     "@rollup/plugin-alias": "^5.1.1",
@@ -126,7 +126,6 @@
     "@types/uuid": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
-    "babel-plugin-react-compiler": "beta",
     "browserslist-to-esbuild": "2.1.1",
     "commitizen": "^4.3.1",
     "cpx": "^1.5.0",
@@ -143,9 +142,9 @@
     "rollup-plugin-visualizer": "^5.13.1",
     "semver": "^7.6.0",
     "ts-node": "^10.9.2",
-    "typescript": "5.7.2",
+    "typescript": "5.7.3",
     "vitest": "^2.1.8",
-    "@sanity/pkg-utils": "6.13.3"
+    "@sanity/pkg-utils": "6.13.4"
   },
   "peerDependencies": {
     "babel-plugin-react-compiler": "*",

package/src/node/core/config/types.ts

@@ -16,30 +16,26 @@ export type PkgRuntime = '*' | 'browser' | 'node'
 /** @public */
 export interface PkgExport {
   /** @internal */
-  '_exported'?: boolean
-  'browser'?: {
+  _exported?: boolean
+  browser?: {
     source: string
     import?: string
     require?: string
   }
-  'react-compiler'?: {
-    source?: string
-    default: string
-  }
   // electron?: {
   //   node?: string
   //   default?: string
   // }
-  'node'?: {
+  node?: {
     source?: string
     import?: string
     require?: string
   }
-  'types'?: string
-  'source': string
-  'import'?: string
-  'require'?: string
-  'default': string
+  types?: string
+  source: string
+  import?: string
+  require?: string
+  default: string
 }
 
 /** @public */

package/src/node/core/pkg/validatePkg.ts

@@ -22,35 +22,25 @@ const pkgSchema = z.object({
         z.custom<`./${string}.json`>((val) => /^\.\/.*\.json$/.test(val as string)),
         z.custom<`./${string}.css`>((val) => /^\.\/.*\.css$/.test(val as string)),
         z.object({
-          'types': z.optional(z.string()),
-          'source': z.optional(z.string()),
-          'browser': z.optional(
+          types: z.optional(z.string()),
+          source: z.optional(z.string()),
+          browser: z.optional(
             z.object({
               source: z.string(),
               import: z.optional(z.string()),
               require: z.optional(z.string()),
             }),
           ),
-          'react-compiler': z.optional(
-            // z.union([
-            // @TODO add support for a string shortcut
-            // z.string(),
-            z.object({
-              source: z.optional(z.string()),
-              default: z.string(),
-            }),
-            // ]),
-          ),
-          'node': z.optional(
+          node: z.optional(
             z.object({
               source: z.optional(z.string()),
               import: z.optional(z.string()),
               require: z.optional(z.string()),
             }),
           ),
-          'import': z.optional(z.string()),
-          'require': z.optional(z.string()),
-          'default': z.string(),
+          import: z.optional(z.string()),
+          require: z.optional(z.string()),
+          default: z.string(),
         }),
         z.object({
           types: z.optional(z.string()),

package/src/node/resolveBuildContext.ts

@@ -139,8 +139,6 @@ export async function resolveBuildContext(options: {
         exportEntry.browser?.require,
         exportEntry.node?.source && exportEntry.node.import,
         exportEntry.node?.source && exportEntry.node.require,
-        // @TODO implement this
-        // exportEntry['react-compiler']?.source && exportEntry['react-compiler']?.default,
       ].filter(Boolean) as string[]
     })
     .map((p) => path.resolve(cwd, p))

package/src/node/resolveBuildTasks.ts

@@ -2,14 +2,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 
 import type {BuildContext, PkgExport, PkgFormat, PkgRuntime} from './core'
-import type {
-  BuildTask,
-  DtsTask,
-  RollupLegacyTask,
-  RollupReactCompilerTask,
-  RollupTask,
-  RollupTaskEntry,
-} from './tasks'
+import type {BuildTask, DtsTask, RollupLegacyTask, RollupTask, RollupTaskEntry} from './tasks'
 import {fileEnding, getTargetPaths, legacyEnding} from './tasks/dts/getTargetPaths'
 
 /** @internal */
@@ -31,13 +24,6 @@ export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
 
   const rollupTasks: Record<string, RollupTask> = {}
   const rollupLegacyTasks: Record<string, RollupLegacyTask> = {}
-  const rollupReactCompilerTask: RollupReactCompilerTask = {
-    type: 'build:react-compiler',
-    runtime: 'browser',
-    format: 'esm',
-    entries: [],
-    target: target.browser,
-  }
 
   function addRollupTaskEntry(format: PkgFormat, runtime: PkgRuntime, entry: RollupTaskEntry) {
     const buildId = `${format}:${runtime}`
@@ -74,10 +60,6 @@ export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
     }
   }
 
-  function addRollupReactCompilerTaskEntry(entry: RollupTaskEntry) {
-    rollupReactCompilerTask.entries.push(entry)
-  }
-
   // Parse `dts` tasks
   for (const exp of exports) {
     const importId = path.join(pkg.name, exp._path)
@@ -108,16 +90,6 @@ export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
         targetPaths: getTargetPaths(pkg.type, exp.node),
       })
     }
-
-    // @TODO implement this
-    // if (exp['react-compiler']?.source?.endsWith('.ts')) {
-    //   dtsTask.entries.push({
-    //     importId,
-    //     exportPath: exp._path,
-    //     sourcePath: exp['react-compiler'].source,
-    //     targetPaths: getTargetPaths(pkg.type, exp['react-compiler']),
-    //   })
-    // }
   }
 
   // Handle dts tasks for bundles
@@ -196,24 +168,6 @@ export function resolveBuildTasks(ctx: BuildContext): BuildTask[] {
       })
     }
 
-    // Parse rollup:react-compiler tasks
-    for (const exp of exports) {
-      const output = exp['react-compiler']?.default
-
-      if (!output) continue
-
-      addRollupReactCompilerTaskEntry({
-        path: exp._path,
-        source: exp['react-compiler']?.source || exp.source,
-        output,
-      })
-    }
-
-    // Add react-compiler task
-    if (rollupReactCompilerTask.entries.length) {
-      tasks.push(rollupReactCompilerTask)
-    }
-
     // Create rollup bundles that legacy export files will re-export
     if (config?.legacyExports) {
       for (const exp of exports) {

package/src/node/tasks/dts/createApiExtractorConfig.ts

@@ -26,24 +26,45 @@ export function createApiExtractorConfig(options: {
     tsconfigPath,
   } = options
 
+  // When the module is 'preserve' it's necessary to override the tsconfig file as api-extractor doesn't handle it out of the box
+  const workaroundModulePreserve = tsconfig.options.module === ts.ModuleKind.Preserve
+  // If `paths` are used for self-referencing imports (e.g. the module is named `sanity`, and the `sanity/structure` export is also importing from `sanity/router`),
+  const workaroundPaths = !!tsconfig.options.paths
+
+  const overrideTsconfig = {
+    extends: tsconfigPath,
+    compilerOptions: {},
+  }
+
+  if (workaroundModulePreserve) {
+    Object.assign(overrideTsconfig.compilerOptions, {
+      // Set the equivalent options to `module: 'Preserve'`
+      // https://github.com/microsoft/TypeScript/pull/56785/files?file-filters%5B%5D=.js&file-filters%5B%5D=.json&file-filters%5B%5D=.symbols&file-filters%5B%5D=.ts&file-filters%5B%5D=.types&show-viewed-files=true#diff-31d3c12bafea26bc9e8c8a77920c41af0c593206442add70c45a06c063767445
+      module: 'ESNext',
+      moduleResolution: 'Bundler',
+      esModuleInterop: true,
+      resolveJsonModule: true,
+    })
+  }
+
+  if (workaroundPaths) {
+    Object.assign(overrideTsconfig.compilerOptions, {
+      // An empty object replaces whatever is in the original tsconfig file
+      paths: {},
+    })
+  }
+
   return {
     apiReport: {
       enabled: false,
       reportFileName: '<unscopedPackageName>.api.md',
     },
     bundledPackages,
-    // If `paths` are used for self-referencing imports (e.g. the module is named `sanity`, and the `sanity/structure` export is also importing from `sanity/router`),
-    compiler: tsconfig.options.paths
-      ? {
-          overrideTsconfig: {
-            extends: tsconfigPath,
-            compilerOptions: {
-              // An empty object replaces whatever is in the original tsconfig file
-              paths: {},
-            },
-          },
-        }
-      : {tsconfigFilePath: tsconfigPath},
+
+    compiler:
+      workaroundModulePreserve || workaroundPaths
+        ? {overrideTsconfig}
+        : {tsconfigFilePath: tsconfigPath},
 
     docModel: {
       enabled: false,

package/src/node/tasks/dts/getTargetPaths.ts

@@ -63,17 +63,6 @@ export function getTargetPaths(
         )
       }
     }
-
-    if (!expOrBundle['react-compiler']?.source) {
-      if (expOrBundle['react-compiler']?.default) {
-        set.add(
-          expOrBundle['react-compiler'].default.replace(
-            fileEnding,
-            type === 'module' ? dtsEnding : mtsEnding,
-          ),
-        )
-      }
-    }
   }
 
   return Array.from(set)

package/src/node/tasks/index.ts

@@ -1,5 +1,5 @@
 import {dtsTask, dtsWatchTask} from './dts'
-import {rollupLegacyTask, rollupReactCompilerTask, rollupTask, rollupWatchTask} from './rollup'
+import {rollupLegacyTask, rollupTask, rollupWatchTask} from './rollup'
 import type {BuildTaskHandlers, WatchTaskHandlers} from './types'
 
 export * from './dts'
@@ -11,7 +11,6 @@ export const buildTaskHandlers: BuildTaskHandlers = {
   'build:dts': dtsTask,
   'build:js': rollupTask,
   'build:legacy': rollupLegacyTask,
-  'build:react-compiler': rollupReactCompilerTask,
 }
 
 /** @internal */

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

@@ -1,4 +1,3 @@
 export * from './rollupLegacyTask'
-export * from './rollupReactCompilerTask'
 export * from './rollupTask'
 export * from './rollupWatchTask'

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

@@ -14,7 +14,7 @@ import esbuild from 'rollup-plugin-esbuild'
 
 import {pkgExtMap as extMap} from '../../../node/core/pkg/pkgExt'
 import {type BuildContext, type PackageJSON, resolveConfigProperty} from '../../core'
-import type {RollupLegacyTask, RollupReactCompilerTask, RollupTask, RollupWatchTask} from '../types'
+import type {RollupLegacyTask, RollupTask, RollupWatchTask} from '../types'
 
 export interface RollupConfig {
   inputOptions: InputOptions
@@ -24,12 +24,11 @@ export interface RollupConfig {
 /** @internal */
 export function resolveRollupConfig(
   ctx: BuildContext,
-  buildTask: RollupTask | RollupLegacyTask | RollupReactCompilerTask | RollupWatchTask,
+  buildTask: RollupTask | RollupLegacyTask | RollupWatchTask,
 ): RollupConfig {
   const {format, runtime, target} = buildTask
   const {config, cwd, exports: _exports, external, distPath, logger, pkg, ts} = ctx
   const isLegacyExports = buildTask.type === 'build:legacy'
-  const isReactCompiler = buildTask.type === 'build:react-compiler'
   const outputExt = isLegacyExports ? extMap.legacy : extMap[pkg.type || 'commonjs'][format]
   const minify = config?.minify ?? false
   const outDir = path.relative(cwd, distPath)
@@ -97,7 +96,7 @@ export function resolveRollupConfig(
     }),
     commonjs(),
     json(),
-    (isReactCompiler || config?.babel?.reactCompiler || config?.babel?.styledComponents) &&
+    (config?.babel?.reactCompiler || config?.babel?.styledComponents) &&
       babel({
         babelrc: false,
         presets: ['@babel/preset-typescript'],
@@ -121,7 +120,7 @@ export function resolveRollupConfig(
                 : {}),
             },
           ],
-          (isReactCompiler || config?.babel?.reactCompiler) && [
+          config?.babel?.reactCompiler && [
             'babel-plugin-react-compiler',
             config?.reactCompilerOptions || {},
           ],
@@ -181,13 +180,11 @@ export function resolveRollupConfig(
     : resolveConfigProperty(config?.rollup?.plugins, defaultPlugins)
 
   const hashChunkFileNames = config?.rollup?.hashChunkFileNames ?? false
-  const chunksFolder = isReactCompiler
-    ? '_compiled'
-    : isLegacyExports
-      ? '_legacy'
-      : hashChunkFileNames
-        ? '_chunks'
-        : '_chunks-[format]'
+  const chunksFolder = isLegacyExports
+    ? '_legacy'
+    : hashChunkFileNames
+      ? '_chunks'
+      : '_chunks-[format]'
   const chunkFileNames = `${chunksFolder}/${hashChunkFileNames ? '[name]-[hash]' : '[name]'}${outputExt}`
   const entryFileNames = isLegacyExports ? '[name].js' : `[name]${outputExt}`
 

package/src/node/tasks/types.ts

@@ -31,15 +31,6 @@ export interface RollupLegacyTask {
   target: string[]
 }
 
-/** @internal */
-export interface RollupReactCompilerTask {
-  type: 'build:react-compiler'
-  entries: RollupTaskEntry[]
-  runtime: 'browser'
-  format: 'esm'
-  target: string[]
-}
-
 /** @internal */
 export interface RollupWatchTask {
   type: 'watch:js'
@@ -51,7 +42,7 @@ export interface RollupWatchTask {
 }
 
 /** @internal */
-export type BuildTask = DtsTask | RollupTask | RollupLegacyTask | RollupReactCompilerTask
+export type BuildTask = DtsTask | RollupTask | RollupLegacyTask
 
 /** @internal */
 export type WatchTask = DtsWatchTask | RollupWatchTask
@@ -68,7 +59,6 @@ export type TaskHandler<Task, Result = void> = {
 export interface BuildTaskHandlers {
   'build:dts': TaskHandler<DtsTask, DtsResult>
   'build:js': TaskHandler<RollupTask>
-  'build:react-compiler': TaskHandler<RollupReactCompilerTask>
   'build:legacy': TaskHandler<RollupLegacyTask>
 }
 

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

@@ -1,140 +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'
-import type {RollupReactCompilerTask, TaskHandler} from '../types'
-import {resolveRollupConfig} from './resolveRollupConfig'
-
-/** @internal */
-export const rollupReactCompilerTask: TaskHandler<RollupReactCompilerTask> = {
-  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 react compiler exports...', ...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: RollupReactCompilerTask) {
-  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
-  }
-}