@sanity/pkg-utils 11.0.17 → 12.0.1

package/MIGRATE.md

@@ -0,0 +1,152 @@
+# Migrating to `@sanity/pkg-utils` v12
+
+v12 replaced the rollup/rolldown build stack with [`tsdown`](https://tsdown.dev) +
+[`@sanity/tsdown-config`](https://github.com/sanity-io/pkg-utils/tree/main/packages/@sanity/tsdown-config#readme).
+
+Most packages need **no changes**. If your `package.config.ts` uses a removed option, the build
+stops with an error that contains these same migration instructions (skipped when
+`NODE_ENV=production`, or with `legacyChecks: false`).
+
+## TL;DR
+
+| v11                                 | v12                                                                 |
+| ----------------------------------- | ------------------------------------------------------------------- |
+| `dts: 'rolldown'`                   | delete it (it's the default now)                                    |
+| `dts: 'api-extractor'`              | delete it (types come from tsdown)                                  |
+| `tsgo: true`                        | `dts: {tsgo: true}`                                                 |
+| `babel: {reactCompiler: true}`      | `reactCompiler: true`                                               |
+| `reactCompilerOptions: {...}`       | `reactCompiler: {...}`                                              |
+| `babel: {styledComponents: true}`   | `styledComponents: true`                                            |
+| `babel: {plugins: [...]}`           | `plugins` + [`@rolldown/plugin-babel`](#custom-babel-plugins)       |
+| `rollup: {vanillaExtract: true}`    | `vanillaExtract: true`                                              |
+| `rollup: {plugins: [...]}`          | `plugins: [...]`                                                    |
+| `rollup: {optimizeLodash: ...}`     | removed — see [lodash](#lodash)                                     |
+| `extract: {enabled: false}`         | `tsdoc: false`                                                      |
+| `extract: {rules, customTags}`      | `tsdoc: {rules, customTags}`                                        |
+| `extract: {bundledPackages: [...]}` | `deps: {alwaysBundle: [...]}` — see [type inlining](#type-inlining) |
+| `external: [...]`                   | `deps: {neverBundle: [...]}` (deprecated, still works)              |
+| `external: (prev) => prev.filter()` | `deps: {alwaysBundle: [...]}` (deprecated, still works)             |
+| `jsx`, `jsxFactory`, …              | `tsconfig.json` `compilerOptions.jsx` and friends                   |
+| `process.env.PKG_FORMAT`            | [`package.json#imports` conditions](#pkg_format-and-pkg_runtime)    |
+| `process.env.PKG_RUNTIME`           | [`package.json#imports` conditions](#pkg_format-and-pkg_runtime)    |
+| `process.env.PKG_FILE_PATH`         | [`import.meta.url`](#pkg_file_path)                                 |
+| `pkg build --clean`                 | delete it (cleaning is on by default; `--no-clean` skips it)        |
+
+Other behavior changes:
+
+- **Node 20 is no longer supported for running builds**: `engines.node` is
+  `^22.18.0 || >=24.11.0` (tsdown's requirement). The published output is unaffected.
+- **Shared chunks are content-hashed** (`_chunks-[format]` folders are gone), so a chunk can
+  never take an entry's filename ([sanity-io/ui#2262](https://github.com/sanity-io/ui/issues/2262)).
+- **`pkg check` runs [publint](https://publint.dev)** on the packed package (with
+  `publishConfig` applied) instead of the esbuild resolution checks. Fix what it reports — it
+  lints what consumers actually install.
+- **Builds keep `exports` in sync**: the map is regenerated from the build (with the
+  `source`-condition development pattern and a `source`-less `publishConfig.exports`), including
+  in CI — so environments that set `CI=true` without meaning "skip package.json" still behave.
+- `tsdown.config.*` files are **never** loaded by `pkg build` — `package.config.ts` is the only
+  config source. For customization beyond the config surface, use `tsdown` +
+  `@sanity/tsdown-config` directly.
+
+## `PKG_FORMAT` and `PKG_RUNTIME`
+
+The `process.env.PKG_FORMAT` and `process.env.PKG_RUNTIME` build-time constants are gone
+(`process.env.PKG_VERSION` remains). Use
+[conditional `package.json#imports`](https://nodejs.org/api/packages.html#imports) instead —
+they express the same thing with more precision, and conditions compose (`require` vs `import`,
+`node`/`browser`/`worker`, `deno`/`bun`, `react-server`, …).
+
+### Per-platform code, resolved at build time (replaces `PKG_RUNTIME`)
+
+Give each platform its own file; every build of the waterfall inlines the matching condition
+(the `browser`/`node` variant builds pick their files, everything else gets `default`):
+
+```json
+{
+  "imports": {
+    "#env": {
+      "browser": "./src/env.browser.ts",
+      "node": "./src/env.node.ts",
+      "default": "./src/env.default.ts"
+    }
+  }
+}
+```
+
+```ts
+// src/index.ts
+export {env} from '#env'
+```
+
+### Per-format (or per-runtime) code, resolved at load time (replaces `PKG_FORMAT`)
+
+Bundled code can't branch per output format at build time — one module graph feeds both
+formats. Point the import map at two small **shipped** files and keep the specifier external,
+so Node (and consumers' bundlers) resolve it when the package loads:
+
+```json
+{
+  "imports": {
+    "#format": {
+      "require": "./format.cjs",
+      "default": "./format.mjs"
+    }
+  },
+  "files": ["dist", "format.cjs", "format.mjs"]
+}
+```
+
+```ts
+// package.config.ts — keep `#…` specifiers external
+export default defineConfig({
+  deps: {neverBundle: [/^#/]},
+})
+```
+
+## `PKG_FILE_PATH`
+
+Use `import.meta.url` — it works in both output formats (the CJS output rewrites it to
+`require("url").pathToFileURL(__filename).href`):
+
+```ts
+import {fileURLToPath} from 'node:url'
+
+const filePath = fileURLToPath(import.meta.url)
+```
+
+## Custom Babel plugins
+
+Install [`@rolldown/plugin-babel`](https://www.npmjs.com/package/@rolldown/plugin-babel) in
+your package and pass it through `plugins`:
+
+```ts
+import pluginBabel from '@rolldown/plugin-babel'
+import {defineConfig} from '@sanity/pkg-utils'
+
+export default defineConfig({
+  plugins: [await pluginBabel({plugins: ['babel-plugin-example']})],
+})
+```
+
+(`styledComponents` no longer needs Babel at all — it uses oxc's native port, so
+`babel-plugin-styled-components` can be uninstalled.)
+
+## Type inlining
+
+Type inlining follows the bundling decisions now:
+
+- imported `devDependencies` are inlined automatically (JS **and** types),
+- `deps: {alwaysBundle: [...]}` force-inlines a `dependency`/`peerDependency` (JS **and** types).
+
+Inlining only the _types_ of an external dependency (the v11 `extract.bundledPackages` pattern)
+has no successor.
+
+Note tsdown's matching semantics: strings match exactly (or as globs), so covering subpath
+imports takes a pattern like `/^@scope\/name(\/|$)/`.
+
+## lodash
+
+The lodash import optimization is gone, including the implicit auto-enable when `lodash` was a
+dependency. Preferably drop lodash altogether (see [e18e.dev](https://e18e.dev) for
+replacements like [`es-toolkit`](https://es-toolkit.dev)), or import from `lodash-es`, which
+tree-shakes in consumers without build-time rewriting.

package/README.md

@@ -28,6 +28,28 @@ pkg-utils watch
 
 Run `pkg-utils -h` for more information on CLI usage.
 
+## How it works
+
+Since v12, `@sanity/pkg-utils` composes [`tsdown`](https://tsdown.dev) and
+[`@sanity/tsdown-config`](https://github.com/sanity-io/pkg-utils/tree/main/packages/@sanity/tsdown-config#readme):
+the hand-written `exports` map in `package.json` stays the input that decides what gets built, and
+for every platform (the default build, plus one extra build per `browser`/`node` exports condition)
+pkg-utils resolves a config from `@sanity/tsdown-config`, layers its own opinions over it
+(browserslist-driven syntax targets, build-time constants, exports reconciliation), and runs
+tsdown's programmatic `build()`.
+
+`tsdown.config.*` files are never loaded — `package.config.ts` is the only configuration source of
+`pkg build`. For customizations beyond the options below, use `tsdown` +
+`@sanity/tsdown-config` directly instead.
+
+Builds regenerate the `exports` map from the build (with `source` conditions for development, and
+a `source`-less `publishConfig.exports` for publishing) and keep it in sync — including in CI —
+so environments that set `CI=true` without meaning "skip package.json" still behave correctly.
+For conditional entries, generated conditions are materialized in both maps, then the authored
+subpath and condition order of each map is preserved independently on later builds. Plain-string
+entries keep their compact shape. This lets you reorder conditions directly in `package.json`;
+earlier matching conditions take precedence over later ones.
+
 ## Configuration
 
 `@sanity/pkg-utils` reads most of its configuration from `package.json`. But sometimes you need more
@@ -40,7 +62,7 @@ control. You may then add a configuration file named `package.config.ts` (or `.m
 import {defineConfig} from '@sanity/pkg-utils'
 
 export default defineConfig({
-  extract: {
+  tsdoc: {
     rules: {
       // do not require internal members to be prefixed with `_`
       'ae-internal-missing-underscore': 'off',
@@ -62,12 +84,35 @@ export default defineConfig({
 An array of entry points to bundle. This is useful if you want to bundle something that should not
 be exported by the package, e.g. CLI scripts or Node.js workers.
 
+#### `clean`
+
+- Type: `boolean | string[]`
+- Default: `true`
+
+tsdown's [`clean` option](https://tsdown.dev/options/cleaning), passed through as-is. Cleaning is
+on by default: `true` cleans the `dist` folder before the build, `false` skips cleaning, and a
+`string[]` replaces the default with the listed paths/globs — include `dist` when you still want it
+cleaned alongside other folders (e.g. `clean: ['dist', 'coverage']` replaces a
+`"clean": "rimraf dist coverage"` script). `pkg build --no-clean` skips cleaning for a single run.
+
 #### `define`
 
 - Type: `Record<string, string | number | boolean | null | undefined>`
 - Default: `{}`
 
-An object defining globals within the package.
+An object defining globals within the package. `process.env.PKG_VERSION` is always defined,
+replaced with the package's `version` (overridable with a `PKG_VERSION` environment variable).
+
+#### `deps`
+
+- Type: `UserConfig['deps']`
+- Default: `undefined`
+
+tsdown's [`deps` option](https://tsdown.dev/options/dependencies), passed through as-is:
+`neverBundle` marks dependencies as external, `alwaysBundle` forces a dependency to be inlined
+(types included — type inlining follows the bundling decisions). Note tsdown's matching semantics:
+strings match exactly (or as globs), so covering subpath imports takes a pattern like
+`/^@scope\/name(\/|$)/`.
 
 #### `dist`
 
@@ -76,78 +121,56 @@ An object defining globals within the package.
 
 The path to the directory to which bundle and chunk files should be written.
 
-#### `exports`
-
-- Type: `PkgConfigProperty<PkgExports>`
-- Default: the value of `"exports"` in `package.json`
-
-Override or modify the value of the `exports` before it’s parsed internally.
+#### `dts`
 
-#### `extract`
-
-- Type:
-  ```ts
-  {
-    rules?: {
-      'ae-incompatible-release-tags'?: PkgRuleLevel
-      'ae-internal-missing-underscore'?: PkgRuleLevel
-      'ae-missing-release-tag'?: PkgRuleLevel
-    }
-  }
-  ```
+- Type: `false | DtsOptions`
 - Default: `undefined`
 
-Configure the level of reporting of [API Extractor](https://api-extractor.com/) (which is used to bundle the
-type definitions, as well as lint the TSDoc of the package).
-
-#### `external`
-
-- Type: `string[]`
-- Default: `[]`
-
-Packages to exclude from bundles.
-
-#### `jsx`
-
-- Type: `'transform' | 'preserve' | 'automatic'`
-- Default: `'automatic'`
-
-Strategy for bundling JSX.
-
-#### `jsxFactory`
-
-- Type: `string`
-- Default: `'createElement'`
-
-The name of the function that creates JSX elements.
+tsdown's [`dts` options](https://tsdown.dev/options/dts), passed through as-is (an object, or
+`false` to skip generating `.d.ts` files entirely). For example `dts: {tsgo: true}` selects the
+Go-native TypeScript compiler for type generation.
 
-#### `jsxFragment`
+#### `exports`
 
-- Type: `string`
-- Default: `'Fragment'`
+- Type: `PkgConfigProperty<PkgExports>`
+- Default: the value of `"exports"` in `package.json`
 
-The name of JSX fragment elements.
+Override or modify the value of the `exports` before it’s parsed internally.
 
-#### `jsxImportSource`
+#### `legacyChecks`
 
-- Type: `string`
-- Default: `'react'`
+- Type: `boolean`
+- Default: `process.env.NODE_ENV !== 'production'`
 
-The name of the library from which to import JSX factory and fragment names.
+Gates the migration checks for options that were removed or deprecated in v12 (they throw helpful
+errors with migration instructions). On by default outside production builds, where migration
+mistakes surface during development; skipped when `NODE_ENV=production`.
 
 #### `minify`
 
 - Type: `boolean`
 - Default: `false`
 
-Whether to minify the bundled JavaScript.
+Whether to fully minify the bundled JavaScript (identifier mangling and whitespace removal
+included). The output is always compressed (constant folding, dead code elimination) with
+function/class names preserved.
 
-#### `rollup.plugins`
+#### `plugins`
 
-- Type: `PkgConfigProperty<RollupPlugin[]>`
+- Type: `UserConfig['plugins']`
 - Default: `[]`
 
-Rollup plugins to load when bundling.
+Extra [rolldown plugins](https://tsdown.dev/advanced/plugins), appended after the plugins
+pkg-utils sets up. Most Rollup plugins are also compatible.
+
+#### `reactCompiler`
+
+- Type: `boolean | ReactCompilerOptions`
+- Default: `false`
+
+Runs `babel-plugin-react-compiler` (which must be installed) on the source files before they are
+bundled, so published components are memoized automatically. Pass `true` for the defaults, or an
+options object to configure the compiler (e.g. `{target: '18'}`).
 
 #### `runtime`
 
@@ -170,6 +193,14 @@ Whether to include source map files.
 
 The path to the directory in which source code is located.
 
+#### `styledComponents`
+
+- Type: `boolean | StyledComponentsOptions`
+- Default: `false`
+
+Applies the `styled-components` transform (`displayName`, `componentId`, CSS minification, etc)
+using oxc's native port of `babel-plugin-styled-components` — no Babel dependencies required.
+
 #### `tsconfig`
 
 - Type: `string`
@@ -177,6 +208,34 @@ The path to the directory in which source code is located.
 
 The path to the TypeScript configuration file.
 
+#### `tsdoc`
+
+- Type: `false | {customTags?: TSDocCustomTag[]; rules?: {...}}`
+- Default: `undefined` (enabled)
+
+Runs [API Extractor](https://api-extractor.com/) during `pkg check` to check that TSDoc tags are
+valid and release tags are correct. Set `tsdoc: false` to disable it.
+
+#### `vanillaExtract`
+
+- Type: `boolean | PackageVanillaExtractOptions`
+- Default: `false`
+
+Extracts the CSS from [vanilla-extract](https://vanilla-extract.style) `.css.ts` files into
+`dist/bundle.css` (minified and lowered with `lightningcss`), injects the self-referential
+`import "<pkg>/bundle.css"`, emits a no-op `bundle-css.js` shim for runtimes that cannot import
+`.css` files, and writes the conditional `"./bundle.css"` export to `package.json`.
+
+## Migrating to v12
+
+v12 replaced the rollup/rolldown build stack with `tsdown` + `@sanity/tsdown-config`. Most
+packages need no changes; removed options throw an error with migration instructions when set
+(gated by [`legacyChecks`](#legacychecks)), and deprecated options keep working with a warning.
+
+See [MIGRATE.md](./MIGRATE.md) for the full guide — including how
+[conditional `package.json#imports`](https://nodejs.org/api/packages.html#imports) replace the
+removed `PKG_FORMAT`/`PKG_RUNTIME` constants, and `import.meta.url` replaces `PKG_FILE_PATH`.
+
 ## License
 
 MIT

package/dist/buildAction-D-M3KYyN.js

@@ -0,0 +1,146 @@
+import { n as createLogger, r as isRecord, t as handleError } from "./handleError-83GwKIFM.js";
+import { a as loadPkgWithReporting, o as loadConfig, t as resolveBuildContext } from "./resolveBuildContext-CbwvYKj1.js";
+import { t as createSpinner } from "./spinner-DAHe7SuT.js";
+import { n as resolveTsdownBuilds, t as resolveTsdownConfig } from "./resolveTsdownConfig-CGE_7cMM.js";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { up } from "empathic/package";
+import { build } from "tsdown";
+const RE_TS_SOURCE = /\.[cm]?tsx?$/;
+/**
+* Build the distribution files of a npm package.
+*
+* @example
+* ```ts
+* import {build} from '@sanity/pkg-utils'
+*
+* build({
+*   cwd: process.cwd(),
+*   tsconfig: 'tsconfig.dist.json,
+* }).then(() => {
+*   console.log('successfully built')
+* }).catch((err) => {
+*   console.log(`build error: ${err.message}`)
+* })
+* ```
+*
+* @public
+*/
+async function build$1(options) {
+	let { cwd, emitDeclarationOnly, strict = !1, tsconfig: tsconfigOption, clean = !0, quiet = !1 } = options, logger = createLogger(quiet), pkgPath = up({ cwd });
+	if (!pkgPath) throw Error("no package.json found", { cause: { cwd } });
+	let config = await loadConfig({
+		cwd,
+		pkgPath
+	}), { parseStrictOptions } = await import("./resolveBuildContext-CbwvYKj1.js").then((n) => n.n), strictOptions = parseStrictOptions(config?.strictOptions ?? {}), pkg = await loadPkgWithReporting({
+		pkgPath,
+		logger,
+		strict,
+		strictOptions
+	}), tsconfig = tsconfigOption || config?.tsconfig || "tsconfig.json", ctx = await resolveBuildContext({
+		config,
+		cwd,
+		emitDeclarationOnly,
+		logger,
+		pkg,
+		strict,
+		tsconfig
+	});
+	warnAboutTsdownConfigFiles(cwd, logger);
+	let builds = resolveTsdownBuilds(ctx), first = !0;
+	for (let buildDef of builds) {
+		if (ctx.emitDeclarationOnly && !buildDef.entries.some((entry) => RE_TS_SOURCE.test(entry.source))) continue;
+		let taskName = buildTaskName(buildDef), spinner = createSpinner(taskName, quiet);
+		try {
+			let inlineConfig = await resolveTsdownConfig(ctx, buildDef, { clean: first && clean });
+			first = !1;
+			let bundles = await build(inlineConfig);
+			ctx.emitDeclarationOnly && removeNonDeclarationOutputs(bundles), buildDef.canonical && restoreAuthoredTypes(ctx), spinner.complete(), ctx.logger.log(), printBuildOutputs(ctx, bundles), ctx.logger.log();
+		} catch (err) {
+			if (spinner.error(), err instanceof Error) {
+				let RE_CWD = new RegExp(escapeRegExp(cwd), "g");
+				ctx.logger.error((err.stack || err.message).replace(RE_CWD, ".")), ctx.logger.log();
+			}
+			process.exit(1);
+		}
+	}
+}
+function buildTaskName(buildDef) {
+	let formats = Array.from(new Set(buildDef.entries.flatMap((entry) => entry.formats)));
+	return `build ${buildDef.key} (${formats.join(", ") || "types"})`;
+}
+const RE_DTS_OUTPUT = /\.d\.[mc]?ts(\.map)?$/;
+/** Removes every emitted file that is not a declaration file (or its sourcemap). */
+function removeNonDeclarationOutputs(bundles) {
+	for (let bundle of bundles) for (let chunk of bundle.chunks) RE_DTS_OUTPUT.test(chunk.fileName) || (rmSync(path.join(chunk.outDir, chunk.fileName), { force: !0 }), rmSync(path.join(chunk.outDir, `${chunk.fileName}.map`), { force: !0 }));
+}
+/**
+* Prints `<pkg>: <source> → <output>` for every entry chunk (JS and `.d.ts`) that tsdown
+* emitted, mirroring the per-file output of previous majors.
+*/
+function printBuildOutputs(ctx, bundles) {
+	let { cwd, logger, pkg } = ctx, lines = /* @__PURE__ */ new Set();
+	for (let bundle of bundles) for (let chunk of bundle.chunks) {
+		if (chunk.type !== "chunk" || !chunk.isEntry || !chunk.facadeModuleId || ctx.emitDeclarationOnly && !RE_DTS_OUTPUT.test(chunk.fileName)) continue;
+		let source = `./${path.relative(cwd, chunk.facadeModuleId).replaceAll("\\", "/").replace(/\.d\.([mc]?)ts$/, ".$1ts")}`, output = `./${path.relative(cwd, path.join(chunk.outDir, chunk.fileName)).replaceAll("\\", "/")}`;
+		lines.add(`${pkg.name}: ${source} \u2192 ${output}`);
+	}
+	for (let line of Array.from(lines).toSorted()) logger.log(line);
+}
+/**
+* tsdown's exports generation rewrites the top-level `types` field alongside `main`/`module`
+* when the `legacy` fields are maintained, preferring the CJS declarations (`.d.cts`) for
+* dual-format packages. The hand-written value is authoritative here (the Sanity convention
+* points `types` at the ESM `.d.ts`), so it is restored after the canonical build.
+*/
+function restoreAuthoredTypes(ctx) {
+	let authoredTypes = ctx.pkg.types;
+	if (!authoredTypes) return;
+	let pkgPath = path.resolve(ctx.cwd, "package.json"), text;
+	try {
+		text = readFileSync(pkgPath, "utf8");
+	} catch {
+		return;
+	}
+	let json = JSON.parse(text);
+	if (!isRecord(json) || json.types === authoredTypes) return;
+	json.types = authoredTypes;
+	let indent = /^([ \t]+)\S/m.exec(text)?.[1] ?? 2, output = JSON.stringify(json, null, indent);
+	text.endsWith("\n") && (output += "\n"), writeFileSync(pkgPath, output, "utf8");
+}
+/**
+* pkg-utils owns its own experience: `tsdown.config.*` files are never loaded in pkg-utils
+* mode (`package.config.ts` is the sole config source), so their presence is worth a warning.
+*/
+function warnAboutTsdownConfigFiles(cwd, logger) {
+	let found = [
+		"tsdown.config.ts",
+		"tsdown.config.mts",
+		"tsdown.config.cts",
+		"tsdown.config.js",
+		"tsdown.config.mjs",
+		"tsdown.config.cjs",
+		"tsdown.config.json"
+	].find((candidate) => existsSync(path.resolve(cwd, candidate)));
+	found && logger.warn(`found \`${found}\`, which @sanity/pkg-utils does not load — \`package.config.ts\` is the only config source of \`pkg build\`. Either migrate the package fully to tsdown (and drop @sanity/pkg-utils), or move the configuration into \`package.config.ts\`.`);
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+async function buildAction(options) {
+	try {
+		await build$1({
+			cwd: process.cwd(),
+			emitDeclarationOnly: options.emitDeclarationOnly,
+			strict: options.strict,
+			tsconfig: options.tsconfig,
+			clean: options.clean,
+			quiet: options.quiet
+		});
+	} catch (err) {
+		handleError(err);
+	}
+}
+export { buildAction };
+
+//# sourceMappingURL=buildAction-D-M3KYyN.js.map

package/dist/buildAction-D-M3KYyN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildAction-D-M3KYyN.js","names":["build","findPkgPath","tsdownBuild","build"],"sources":["../src/node/build.ts","../src/cli/buildAction.ts"],"sourcesContent":["import {existsSync, readFileSync, rmSync, writeFileSync} from 'node:fs'\nimport path from 'node:path'\nimport {up as findPkgPath} from 'empathic/package'\nimport {build as tsdownBuild, type TsdownBundle} from 'tsdown'\nimport {loadConfig} from './core/config/loadConfig.ts'\nimport {isRecord} from './core/isRecord.ts'\nimport {loadPkgWithReporting} from './core/pkg/loadPkgWithReporting.ts'\nimport {createLogger, type Logger} from './logger.ts'\nimport {resolveBuildContext} from './resolveBuildContext.ts'\nimport {createSpinner} from './spinner.ts'\nimport {\n  resolveTsdownBuilds,\n  type TsdownBuild as TsdownBuildDef,\n} from './tasks/tsdown/resolveTsdownBuilds.ts'\nimport {resolveTsdownConfig} from './tasks/tsdown/resolveTsdownConfig.ts'\n\nconst RE_TS_SOURCE = /\\.[cm]?tsx?$/\n\n/**\n * Build the distribution files of a npm package.\n *\n * @example\n * ```ts\n * import {build} from '@sanity/pkg-utils'\n *\n * build({\n *   cwd: process.cwd(),\n *   tsconfig: 'tsconfig.dist.json,\n * }).then(() => {\n *   console.log('successfully built')\n * }).catch((err) => {\n *   console.log(`build error: ${err.message}`)\n * })\n * ```\n *\n * @public\n */\nexport async function build(options: {\n  cwd: string\n  emitDeclarationOnly?: boolean\n  strict?: boolean\n  tsconfig?: string\n  clean?: boolean\n  quiet?: boolean\n}): Promise<void> {\n  const {\n    cwd,\n    emitDeclarationOnly,\n    strict = false,\n    tsconfig: tsconfigOption,\n    // `--no-clean` skips cleaning for this run; `true` (the CLI default — `--clean` still\n    // parses as a no-op for v11 compatibility) defers to the `clean` config option\n    clean = true,\n    quiet = false,\n  } = options\n  const logger = createLogger(quiet)\n\n  const pkgPath = findPkgPath({cwd})\n  if (!pkgPath) {\n    throw new Error('no package.json found', {cause: {cwd}})\n  }\n  const config = await loadConfig({cwd, pkgPath})\n\n  const {parseStrictOptions} = await import('./strict.ts')\n  const strictOptions = parseStrictOptions(config?.strictOptions ?? {})\n  const pkg = await loadPkgWithReporting({pkgPath, logger, strict, strictOptions})\n\n  const tsconfig = tsconfigOption || config?.tsconfig || 'tsconfig.json'\n\n  const ctx = await resolveBuildContext({\n    config,\n    cwd,\n    emitDeclarationOnly,\n    logger,\n    pkg,\n    strict,\n    tsconfig,\n  })\n\n  warnAboutTsdownConfigFiles(cwd, logger)\n\n  const builds = resolveTsdownBuilds(ctx)\n\n  let first = true\n  for (const buildDef of builds) {\n    // A types-only run skips builds without TypeScript sources entirely\n    if (\n      ctx.emitDeclarationOnly &&\n      !buildDef.entries.some((entry) => RE_TS_SOURCE.test(entry.source))\n    ) {\n      continue\n    }\n\n    const taskName = buildTaskName(buildDef)\n    const spinner = createSpinner(taskName, quiet)\n\n    try {\n      const inlineConfig = await resolveTsdownConfig(ctx, buildDef, {clean: first && clean})\n      first = false\n\n      const bundles = await tsdownBuild(inlineConfig)\n\n      if (ctx.emitDeclarationOnly) {\n        // `dts.emitDtsOnly` suppresses the JS chunks of the ES pass, but the CJS pass emits\n        // its JS regardless (only its extra dts pass runs the dts plugin) — a types-only\n        // build removes everything that is not a declaration file\n        removeNonDeclarationOutputs(bundles)\n      }\n\n      if (buildDef.canonical) {\n        restoreAuthoredTypes(ctx)\n      }\n\n      spinner.complete()\n      ctx.logger.log()\n\n      printBuildOutputs(ctx, bundles)\n      ctx.logger.log()\n    } catch (err) {\n      spinner.error()\n\n      if (err instanceof Error) {\n        const RE_CWD = new RegExp(escapeRegExp(cwd), 'g')\n\n        ctx.logger.error((err.stack || err.message).replace(RE_CWD, '.'))\n        ctx.logger.log()\n      }\n\n      process.exit(1)\n    }\n  }\n}\n\nfunction buildTaskName(buildDef: TsdownBuildDef): string {\n  const formats = Array.from(new Set(buildDef.entries.flatMap((entry) => entry.formats)))\n  return `build ${buildDef.key} (${formats.join(', ') || 'types'})`\n}\n\nconst RE_DTS_OUTPUT = /\\.d\\.[mc]?ts(\\.map)?$/\n\n/** Removes every emitted file that is not a declaration file (or its sourcemap). */\nfunction removeNonDeclarationOutputs(bundles: TsdownBundle[]): void {\n  for (const bundle of bundles) {\n    for (const chunk of bundle.chunks) {\n      if (RE_DTS_OUTPUT.test(chunk.fileName)) continue\n      rmSync(path.join(chunk.outDir, chunk.fileName), {force: true})\n      rmSync(path.join(chunk.outDir, `${chunk.fileName}.map`), {force: true})\n    }\n  }\n}\n\n/**\n * Prints `<pkg>: <source> → <output>` for every entry chunk (JS and `.d.ts`) that tsdown\n * emitted, mirroring the per-file output of previous majors.\n */\nfunction printBuildOutputs(\n  ctx: {cwd: string; emitDeclarationOnly: boolean; logger: Logger; pkg: {name: string}},\n  bundles: TsdownBundle[],\n): void {\n  const {cwd, logger, pkg} = ctx\n  const lines = new Set<string>()\n\n  for (const bundle of bundles) {\n    for (const chunk of bundle.chunks) {\n      if (chunk.type !== 'chunk' || !chunk.isEntry || !chunk.facadeModuleId) continue\n      if (ctx.emitDeclarationOnly && !RE_DTS_OUTPUT.test(chunk.fileName)) continue\n      const source = `./${path\n        .relative(cwd, chunk.facadeModuleId)\n        .replaceAll('\\\\', '/')\n        // the dts chunks facade the fake `.d.ts` module ids of rolldown-plugin-dts; print the\n        // actual `.ts` source instead\n        .replace(/\\.d\\.([mc]?)ts$/, '.$1ts')}`\n      const output = `./${path\n        .relative(cwd, path.join(chunk.outDir, chunk.fileName))\n        .replaceAll('\\\\', '/')}`\n      lines.add(`${pkg.name}: ${source} \\u2192 ${output}`)\n    }\n  }\n\n  for (const line of Array.from(lines).toSorted()) {\n    logger.log(line)\n  }\n}\n\n/**\n * tsdown's exports generation rewrites the top-level `types` field alongside `main`/`module`\n * when the `legacy` fields are maintained, preferring the CJS declarations (`.d.cts`) for\n * dual-format packages. The hand-written value is authoritative here (the Sanity convention\n * points `types` at the ESM `.d.ts`), so it is restored after the canonical build.\n */\nfunction restoreAuthoredTypes(ctx: {cwd: string; pkg: {types?: string | undefined}}): void {\n  const authoredTypes = ctx.pkg.types\n  if (!authoredTypes) return\n\n  const pkgPath = path.resolve(ctx.cwd, 'package.json')\n  let text: string\n  try {\n    text = readFileSync(pkgPath, 'utf8')\n  } catch {\n    return\n  }\n  const json: unknown = JSON.parse(text)\n  if (!isRecord(json) || json['types'] === authoredTypes) return\n  json['types'] = authoredTypes\n\n  const indent = /^([ \\t]+)\\S/m.exec(text)?.[1] ?? 2\n  let output = JSON.stringify(json, null, indent)\n  if (text.endsWith('\\n')) output += '\\n'\n  writeFileSync(pkgPath, output, 'utf8')\n}\n\n/**\n * pkg-utils owns its own experience: `tsdown.config.*` files are never loaded in pkg-utils\n * mode (`package.config.ts` is the sole config source), so their presence is worth a warning.\n */\nfunction warnAboutTsdownConfigFiles(cwd: string, logger: Logger): void {\n  const candidates = [\n    'tsdown.config.ts',\n    'tsdown.config.mts',\n    'tsdown.config.cts',\n    'tsdown.config.js',\n    'tsdown.config.mjs',\n    'tsdown.config.cjs',\n    'tsdown.config.json',\n  ]\n  const found = candidates.find((candidate) => existsSync(path.resolve(cwd, candidate)))\n  if (found) {\n    logger.warn(\n      `found \\`${found}\\`, which @sanity/pkg-utils does not load — \\`package.config.ts\\` is the only config source of \\`pkg build\\`. Either migrate the package fully to tsdown (and drop @sanity/pkg-utils), or move the configuration into \\`package.config.ts\\`.`,\n    )\n  }\n}\n\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n}\n","import {build} from '../node/build.ts'\nimport {handleError} from './handleError.ts'\n\nexport async function buildAction(options: {\n  emitDeclarationOnly?: boolean\n  strict?: boolean\n  tsconfig?: string\n  clean?: boolean\n  quiet?: boolean\n}): Promise<void> {\n  try {\n    await build({\n      cwd: process.cwd(),\n      emitDeclarationOnly: options.emitDeclarationOnly,\n      strict: options.strict,\n      tsconfig: options.tsconfig,\n      clean: options.clean,\n      quiet: options.quiet,\n    })\n  } catch (err) {\n    handleError(err)\n  }\n}\n"],"mappings":"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"}