@sanity/tsdown-config 0.8.0 → 0.10.0

package/README.md

@@ -12,6 +12,37 @@ import {defineConfig} from '@sanity/tsdown-config'
 export default defineConfig({tsconfig: 'tsconfig.dist.json'})
 ```
 
+## React Compiler
+
+The same React Compiler feature as `@sanity/pkg-utils` is available. It runs
+[`babel-plugin-react-compiler`](https://react.dev/learn/react-compiler) on the source files before
+they are bundled, so published components are memoized automatically. The plugin needs to be
+installed separately:
+
+```sh
+pnpm add --save-dev babel-plugin-react-compiler
+```
+
+Then enable it:
+
+```ts
+import {defineConfig} from '@sanity/tsdown-config'
+
+export default defineConfig({
+  tsconfig: 'tsconfig.dist.json',
+  reactCompiler: true,
+})
+```
+
+Pass an object to configure the compiler, using the same options as [`babel-plugin-react-compiler`](https://react.dev/reference/react-compiler/configuration):
+
+```ts
+export default defineConfig({
+  tsconfig: 'tsconfig.dist.json',
+  reactCompiler: {target: '18'},
+})
+```
+
 ## styled-components
 
 If your package uses `styled-components`, enable the same `styledComponents` transform that `@sanity/pkg-utils` has:
@@ -36,3 +67,45 @@ export default defineConfig({
   styledComponents: {namespace: 'my-package'},
 })
 ```
+
+## vanilla-extract
+
+The same `vanillaExtract` feature as `@sanity/pkg-utils` is available. It extracts the CSS from
+`.css.ts` files into a separate, `lightningcss`-optimized file (`dist/bundle.css` by default).
+Start by installing `@vanilla-extract/css` for authoring the `.css.ts` files:
+
+```sh
+pnpm add --save-dev @vanilla-extract/css
+```
+
+```ts
+import {defineConfig} from '@sanity/tsdown-config'
+
+export default defineConfig({
+  tsconfig: 'tsconfig.dist.json',
+  vanillaExtract: true,
+})
+```
+
+By default a compatibility mode is active that automatically wires up the conditional CSS export
+pattern:
+
+- injects the self-referential `import "<pkg>/bundle.css"` into the `index` entry chunk,
+- emits a no-op `bundle.css.js` shim (plus `bundle.css.d.ts`) for runtimes that cannot import
+  `.css` files, and
+- writes the conditional `"./bundle.css"` export to `package.json` (`browser`/`style` → the real
+  CSS, `node`/`default` → the shim).
+
+The result is that `import "<pkg>/bundle.css"` resolves to the real CSS in bundlers/browsers and to
+the no-op shim in Node and similar runtimes. Make sure the extracted CSS survives tree-shaking in
+consumers by adding it to `sideEffects` in `package.json`:
+
+```json
+{
+  "sideEffects": ["*.css"]
+}
+```
+
+Pass an options object instead of `true` to customize (e.g. `minify`, `browserslist`,
+`extract.name`), or set `extract.compatMode: false` to wire up the import, shim, and export
+yourself.

package/dist/bundleCssShim.mjs

@@ -0,0 +1,34 @@
+/**
+* Emits a no-op JavaScript shim (`export default ""`) alongside the extracted CSS. The conditional
+* `./<css>` export points its `node`/`default` conditions at this file so that the self-referential
+* `import "<pkg>/<css>"` resolves to a harmless module in runtimes that cannot import `.css` files,
+* instead of throwing `Error: Unknown file extension ".css"`.
+*
+* A matching `.d.ts` declaration is emitted next to the shim as well. Both the `browser`/`style`
+* (`<css>`) and the `node`/`default` (`<css>.js`) conditions of the `./<css>` export resolve their
+* types to the same `<css>.d.ts` file, so type-aware tooling (e.g. dts export checkers that load a
+* `.d.ts` for every export target) does not crash on a missing declaration file.
+*
+* @param options.fileName - The shim file name, e.g. `bundle.css.js`.
+* @internal
+*/
+function bundleCssShim(options) {
+	let cssName = options.fileName.replace(/\.js$/, "");
+	return {
+		name: "sanity-tsdown-config:bundle-css-shim",
+		generateBundle() {
+			this.emitFile({
+				type: "asset",
+				fileName: options.fileName,
+				source: `// No-op shim for \`${cssName}\` in runtimes that cannot import \`.css\` files directly.\nexport default ""\n`
+			}), this.emitFile({
+				type: "asset",
+				fileName: `${cssName}.d.ts`,
+				source: `// Type declarations for \`${cssName}\` and its no-op JS shim.\ndeclare const _default: string\nexport default _default\n`
+			});
+		}
+	};
+}
+export { bundleCssShim };
+
+//# sourceMappingURL=bundleCssShim.mjs.map

package/dist/bundleCssShim.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundleCssShim.mjs","names":[],"sources":["../src/bundleCssShim.ts"],"sourcesContent":["import type {Rolldown} from 'tsdown'\n\n/**\n * Emits a no-op JavaScript shim (`export default \"\"`) alongside the extracted CSS. The conditional\n * `./<css>` export points its `node`/`default` conditions at this file so that the self-referential\n * `import \"<pkg>/<css>\"` resolves to a harmless module in runtimes that cannot import `.css` files,\n * instead of throwing `Error: Unknown file extension \".css\"`.\n *\n * A matching `.d.ts` declaration is emitted next to the shim as well. Both the `browser`/`style`\n * (`<css>`) and the `node`/`default` (`<css>.js`) conditions of the `./<css>` export resolve their\n * types to the same `<css>.d.ts` file, so type-aware tooling (e.g. dts export checkers that load a\n * `.d.ts` for every export target) does not crash on a missing declaration file.\n *\n * @param options.fileName - The shim file name, e.g. `bundle.css.js`.\n * @internal\n */\nexport function bundleCssShim(options: {fileName: string}): Rolldown.Plugin {\n  const cssName = options.fileName.replace(/\\.js$/, '')\n\n  return {\n    name: 'sanity-tsdown-config:bundle-css-shim',\n    generateBundle() {\n      this.emitFile({\n        type: 'asset',\n        fileName: options.fileName,\n        source: `// No-op shim for \\`${cssName}\\` in runtimes that cannot import \\`.css\\` files directly.\\nexport default \"\"\\n`,\n      })\n      this.emitFile({\n        type: 'asset',\n        fileName: `${cssName}.d.ts`,\n        source: `// Type declarations for \\`${cssName}\\` and its no-op JS shim.\\ndeclare const _default: string\\nexport default _default\\n`,\n      })\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAgBA,SAAgB,cAAc,SAA8C;CAC1E,IAAM,UAAU,QAAQ,SAAS,QAAQ,SAAS,EAAE;CAEpD,OAAO;EACL,MAAM;EACN,iBAAiB;GAMf,AALA,KAAK,SAAS;IACZ,MAAM;IACN,UAAU,QAAQ;IAClB,QAAQ,uBAAuB,QAAQ;GACzC,CAAC,GACD,KAAK,SAAS;IACZ,MAAM;IACN,UAAU,GAAG,QAAQ;IACrB,QAAQ,8BAA8B,QAAQ;GAChD,CAAC;EACH;CACF;AACF"}

package/dist/index.d.mts

@@ -1,4 +1,57 @@
 import { UserConfig } from "tsdown";
+import { PluginOptions } from "babel-plugin-react-compiler";
+import { Options } from "@vanilla-extract/rollup-plugin";
+/**
+* Options for the `@vanilla-extract/rollup-plugin` integration, including the same extensions as
+* `@sanity/pkg-utils` (`minify`, `browserslist`, and `extract.compatMode`).
+* @public
+*/
+interface PackageVanillaExtractOptions extends Omit<Options, "extract"> {
+  /**
+  * Minify the extracted CSS with `lightningcss`.
+  * @defaultValue true
+  */
+  minify?: boolean;
+  /**
+  * Browserslist query passed to `lightningcss` when optimizing the extracted CSS.
+  * @defaultValue `@sanity/browserslist-config`
+  */
+  browserslist?: string | string[];
+  /**
+  * Different formatting of identifiers (e.g. class names, keyframes, CSS Vars, etc).
+  * @defaultValue "short"
+  */
+  identifiers?: Options["identifiers"];
+  /**
+  * Extract the CSS into a separate file. The CSS is always extracted, so this configures _how_.
+  */
+  extract?: {
+    /**
+    * Name of the emitted `.css` file (and, with `compatMode`, the `exports` subpath + shim base).
+    * @defaultValue "bundle.css"
+    */
+    name?: string;
+    /**
+    * Generate a `.css.map` sourcemap file.
+    * @defaultValue true
+    */
+    sourcemap?: boolean;
+    /**
+    * Compatibility mode automatically wires up the conditional CSS export pattern so userland does
+    * not have to. When enabled, the config:
+    *
+    * - injects `import "<pkg-name>/<name>"` into the `index` entry chunk,
+    * - emits a no-op `<name>.js` shim for runtimes that cannot import `.css` files, and
+    * - writes the conditional `"./<name>"` export to `package.json`
+    *   (`browser`/`style` → the real CSS, `node`/`default` → the shim).
+    *
+    * The result is that `import "<pkg>/<name>"` resolves to the real CSS in bundlers/browsers and
+    * to the no-op shim in Node and similar runtimes. Disable it to wire these up yourself.
+    * @defaultValue true
+    */
+    compatMode?: boolean;
+  };
+}
 /**
 * Options for the `styled-components` transform, the same options as `babel-plugin-styled-components`.
 * @public
@@ -26,6 +79,14 @@ interface StyledComponentsOptions {
   pure?: boolean;
 }
 /**
+* Options for the React Compiler, the same options as `babel-plugin-react-compiler`.
+* The typings resolve in userland once `babel-plugin-react-compiler` (an optional peer
+* dependency, required to use `reactCompiler`) is installed, and always match the installed
+* version of the compiler.
+* @public
+*/
+type ReactCompilerOptions = Partial<PluginOptions>;
+/**
 * @public
 */
 interface PackageOptions extends Pick<UserConfig, "tsconfig" | "entry" | "format"> {
@@ -34,6 +95,16 @@ interface PackageOptions extends Pick<UserConfig, "tsconfig" | "entry" | "format
   */
   platform?: UserConfig["platform"];
   /**
+  * Runs `babel-plugin-react-compiler` on the source files before they are bundled, so published
+  * components are memoized automatically. Pass `true` to use the defaults, or an options object
+  * to configure the compiler (e.g. `{target: '18'}`).
+  * This is the same feature as the `babel: {reactCompiler: true}` and `reactCompilerOptions`
+  * options in `@sanity/pkg-utils`. Unlike `styledComponents` there's no oxc native port of the
+  * React Compiler yet, so `babel-plugin-react-compiler` needs to be installed.
+  * @defaultValue false
+  */
+  reactCompiler?: boolean | ReactCompilerOptions;
+  /**
   * Applies the `styled-components` transform (`displayName`, `componentId`, CSS minification, etc)
   * with the same defaults as the `babel: {styledComponents: true}` option in `@sanity/pkg-utils`.
   * Unlike `@sanity/pkg-utils` it doesn't use `babel-plugin-styled-components`, but oxc's native port of it,
@@ -41,10 +112,21 @@ interface PackageOptions extends Pick<UserConfig, "tsconfig" | "entry" | "format
   * @defaultValue false
   */
   styledComponents?: boolean | StyledComponentsOptions;
+  /**
+  * Enables `@vanilla-extract/rollup-plugin` to extract CSS into a separate file, with support for
+  * minifying the extracted CSS. Pass `true` to use the defaults, or an object to customize.
+  *
+  * By default (`extract.compatMode: true`) the config also injects the self-referential
+  * `import "<pkg>/bundle.css"`, emits a `bundle.css.js` shim, and writes the conditional
+  * `"./bundle.css"` export to `package.json` - see {@link PackageVanillaExtractOptions}.
+  * This is the same feature as `rollup.vanillaExtract` in `@sanity/pkg-utils`.
+  * @alpha
+  */
+  vanillaExtract?: boolean | PackageVanillaExtractOptions;
 }
 /**
 * @public
 */
-declare function defineConfig(options?: PackageOptions): UserConfig;
-export { PackageOptions, StyledComponentsOptions, defineConfig };
+declare function defineConfig(options?: PackageOptions): Promise<UserConfig>;
+export { PackageOptions, type PackageVanillaExtractOptions, ReactCompilerOptions, StyledComponentsOptions, defineConfig };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;AAMA;;;UAAiB,uBAAA;;EAEf,WAAA;;;;;EAKA,mBAAA;;EAEA,GAAA;EAWA;EATA,QAAA;EAeF;EAbE,oBAAA;;EAEA,MAAA;;EAEA,yBAAA;EACA,SAAA;EAQsC;EANtC,IAAA;AAAA;;;;UAMe,cAAA,SAAuB,IAAA,CAAK,UAAA;;;AAYd;EAR7B,QAAA,GAAW,UAAA;EAcG;;;;;;;EANd,gBAAA,aAA6B,uBAAA;AAAA;;;;iBAMf,YAAA,CAAa,OAAA,GAAS,cAAA,GAAsB,UAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/vanillaExtract.ts","../src/index.ts"],"mappings":";;;;;AAaA;;;UAAiB,4BAAA,SAAqC,IAAA,CAAK,OAAA;;;;;EAKzD,MAAA;;;;;EAKA,YAAA;;;;;EAKA,WAAA,GAAc,OAAA;EA4BZ;;AC9CJ;EDsBE,OAAA;;;;;IAKE,IAAA;IChBF;;;;IDqBE,SAAA;ICZF;;AAAA;AAUF;;;;AAA2C;AAK3C;;;;;IDWI,UAAA;EAAA;AAAA;AA3CJ;;;;AAAA,UCHiB,uBAAA;;EAEf,WAAA;EDCoD;;;;ECIpD,mBAAA;;EAEA,GAAA;;EAEA,QAAA;;EAEA,oBAAA;EDiCE;EC/BF,MAAA;;EAEA,yBAAA;EACA,SAAA;;EAEA,IAAA;AAAA;;;;;;;;KAUU,oBAAA,GAAuB,OAAA,CAAQ,aAAA;;AAVzC;AAUF;UAKiB,cAAA,SAAuB,IAAA,CAAK,UAAA;;;AALF;EASzC,QAAA,GAAW,UAAA;EAJI;;;;;;;;;EAcf,aAAA,aAA0B,oBAAA;;;;;;;;EAQ1B,gBAAA,aAA6B,uBAAA;;;;AAWF;AAM7B;;;;;;EANE,cAAA,aAA2B,4BAAA;AAAA;;;;iBAMP,YAAA,CAAa,OAAA,GAAS,cAAA,GAAsB,OAAA,CAAQ,UAAA"}

package/dist/index.mjs

@@ -2,31 +2,75 @@ import { defineConfig as defineConfig$1 } from "tsdown";
 /**
 * @public
 */
-function defineConfig(options = {}) {
-	let { entry } = options, tsconfig = options.tsconfig ?? "tsconfig.json", platform = options.platform ?? "neutral", styledComponents = options.styledComponents ?? !1, report = { gzip: !1 };
+async function defineConfig(options = {}) {
+	let { entry } = options, tsconfig = options.tsconfig ?? "tsconfig.json", platform = options.platform ?? "neutral", reactCompiler = options.reactCompiler ?? !1, styledComponents = options.styledComponents ?? !1, report = { gzip: !1 }, format = options.format ?? "esm", inputOptions = {
+		preserveEntrySignatures: "strict",
+		experimental: { attachDebugInfo: "none" },
+		...styledComponents !== !1 && { transform: { plugins: { styledComponents: {
+			fileName: !1,
+			transpileTemplateLiterals: !1,
+			pure: !0,
+			cssProp: !1,
+			...typeof styledComponents == "object" ? styledComponents : {}
+		} } } }
+	}, baseOutputOptions = { hoistTransitiveImports: !1 }, outputOptions = baseOutputOptions, treeshake, customExports, plugins = [];
+	if (reactCompiler !== !1) {
+		let [{ default: pluginBabel }, { reactCompilerPreset }] = await Promise.all([import("@rolldown/plugin-babel"), import("@vitejs/plugin-react")]);
+		plugins.push(await pluginBabel({ presets: [reactCompilerPreset(typeof reactCompiler == "object" ? reactCompiler : {})] }));
+	}
+	if (options.vanillaExtract) {
+		let [{ vanillaExtractPlugin }, { default: browserslistConfig }, { optimizeCss }, { bundleCssShim }, { composeIntro, createConditionalCssExport, insertCssExport, readPackageName, resolveVanillaExtract, resolveVanillaExtractCssName }] = await Promise.all([
+			import("@vanilla-extract/rollup-plugin"),
+			import("@sanity/browserslist-config"),
+			import("./optimizeCss.mjs"),
+			import("./bundleCssShim.mjs"),
+			import("./vanillaExtract.mjs")
+		]), vanillaExtract = resolveVanillaExtract(options.vanillaExtract), cssName = resolveVanillaExtractCssName(vanillaExtract.options);
+		plugins.push(vanillaExtractPlugin({
+			identifiers: vanillaExtract.options.identifiers ?? "short",
+			cwd: vanillaExtract.options.cwd,
+			esbuildOptions: vanillaExtract.options.esbuildOptions,
+			unstable_injectFilescopes: vanillaExtract.options.unstable_injectFilescopes,
+			extract: {
+				name: cssName,
+				sourcemap: vanillaExtract.options.extract?.sourcemap ?? !0
+			}
+		}), optimizeCss({
+			extractFileName: cssName,
+			browserslist: vanillaExtract.options.browserslist || browserslistConfig,
+			minify: vanillaExtract.options.minify ?? !0
+		})), treeshake = { moduleSideEffects: [{
+			test: /\.vanilla\.css$/,
+			external: !0,
+			sideEffects: !1
+		}] };
+		let cssImportId = vanillaExtract.compatMode ? `${readPackageName(process.cwd())}/${cssName}` : void 0;
+		if (outputOptions = (_options, outputFormat, context) => ({
+			...baseOutputOptions,
+			assetFileNames: "[name][extname]",
+			...cssImportId && !context.cjsDts && (outputFormat === "es" || outputFormat === "cjs") ? { intro: composeIntro(outputFormat === "cjs" ? `require(${JSON.stringify(cssImportId)})` : `import ${JSON.stringify(cssImportId)}`) } : {}
+		}), vanillaExtract.compatMode) {
+			plugins.push(bundleCssShim({ fileName: `${cssName}.js` }));
+			let conditionalCssExport = createConditionalCssExport(cssName, "dist");
+			customExports = (exportsMap) => insertCssExport(exportsMap, `./${cssName}`, conditionalCssExport);
+		}
+	}
 	return defineConfig$1({
 		entry,
 		exports: {
 			enabled: "local-only",
-			devExports: !0
+			devExports: !0,
+			...customExports && { customExports }
 		},
-		format: options.format ?? "esm",
+		format,
 		hash: !1,
-		inputOptions: {
-			preserveEntrySignatures: "strict",
-			experimental: { attachDebugInfo: "none" },
-			...styledComponents !== !1 && { transform: { plugins: { styledComponents: {
-				fileName: !1,
-				transpileTemplateLiterals: !1,
-				pure: !0,
-				cssProp: !1,
-				...typeof styledComponents == "object" ? styledComponents : {}
-			} } } }
-		},
-		outputOptions: { hoistTransitiveImports: !1 },
+		inputOptions,
+		outputOptions,
 		platform,
+		plugins,
 		publint: !0,
 		report,
+		treeshake,
 		tsconfig,
 		minify: {
 			compress: !0,

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["defineTsdownConfig"],"sources":["../src/index.ts"],"sourcesContent":["import {defineConfig as defineTsdownConfig, type UserConfig} from 'tsdown'\n\n/**\n * Options for the `styled-components` transform, the same options as `babel-plugin-styled-components`.\n * @public\n */\nexport interface StyledComponentsOptions {\n  /** @defaultValue true */\n  displayName?: boolean\n  /**\n   * @defaultValue []\n   * @example [\"\\@xstyled/styled-components\", \"\\@xstyled/styled-components/*\"]\n   */\n  topLevelImportPaths?: string[]\n  /** @defaultValue true */\n  ssr?: boolean\n  /** @defaultValue false */\n  fileName?: boolean\n  /** @defaultValue [\"index\"] */\n  meaninglessFileNames?: string[]\n  /** @defaultValue true */\n  minify?: boolean\n  /** @defaultValue false */\n  transpileTemplateLiterals?: boolean\n  namespace?: string\n  /** @defaultValue true */\n  pure?: boolean\n}\n\n/**\n * @public\n */\nexport interface PackageOptions extends Pick<UserConfig, 'tsconfig' | 'entry' | 'format'> {\n  /**\n   * @defaultValue 'neutral'\n   */\n  platform?: UserConfig['platform']\n  /**\n   * Applies the `styled-components` transform (`displayName`, `componentId`, CSS minification, etc)\n   * with the same defaults as the `babel: {styledComponents: true}` option in `@sanity/pkg-utils`.\n   * Unlike `@sanity/pkg-utils` it doesn't use `babel-plugin-styled-components`, but oxc's native port of it,\n   * so there's no need to install babel dependencies.\n   * @defaultValue false\n   */\n  styledComponents?: boolean | StyledComponentsOptions\n}\n\n/**\n * @public\n */\nexport function defineConfig(options: PackageOptions = {}): UserConfig {\n  const {entry} = options\n  const tsconfig = options.tsconfig ?? 'tsconfig.json'\n  const platform = options.platform ?? 'neutral'\n  const styledComponents = options.styledComponents ?? false\n  const report = {gzip: false} as const satisfies UserConfig['report']\n  const publint = true\n  const hash = false\n  const format = options.format ?? 'esm'\n  const inputOptions = {\n    preserveEntrySignatures: 'strict',\n    experimental: {attachDebugInfo: 'none'},\n    ...(styledComponents !== false && {\n      transform: {\n        plugins: {\n          styledComponents: {\n            // The same defaults as `babel: {styledComponents: true}` in `@sanity/pkg-utils`:\n            // `fileName` is unnecessary, as the way we use styled-components in Sanity is usually by wrapping\n            // `@sanity/ui` primitives, not declaring new ones like \"const Button = styled.button``\"\n            fileName: false,\n            // Native template literals take less space than this transpilation, and unlike\n            // `babel-plugin-styled-components`, oxc doesn't add a `@__PURE__` annotation to the\n            // transpiled call expression either, so enabling it wouldn't improve tree-shaking\n            transpileTemplateLiterals: false,\n            // Helps dead code elimination and tree-shaking, although oxc only annotates plain call\n            // expressions so far, not tagged template expressions (https://github.com/rollup/rollup/issues/4035)\n            pure: true,\n            // Disabled, as tsdown tends to be used for npm publishing, while other tooling,\n            // like `sanity dev`, `next dev`, etc are used for testing\n            cssProp: false,\n            ...(typeof styledComponents === 'object' ? styledComponents : {}),\n          },\n        },\n      },\n    }),\n  } as const satisfies UserConfig['inputOptions']\n  const outputOptions = {\n    hoistTransitiveImports: false,\n  } as const satisfies UserConfig['outputOptions']\n  const exports = {\n    enabled: 'local-only',\n    // @TODO use @sanity/parse-package-json to determine if devExports should be `true` or `source`\n    devExports: true,\n  } as const satisfies UserConfig['exports']\n\n  return defineTsdownConfig({\n    entry,\n    exports,\n    format,\n    hash,\n    inputOptions,\n    outputOptions,\n    platform,\n    publint,\n    report,\n    tsconfig,\n    minify: {compress: true, codegen: false, mangle: false},\n    // Rely on tsdown's/rolldown's default tree-shaking (`moduleSideEffects: true`) rather than\n    // customizing it. Previously this set the equivalent of `moduleSideEffects: 'no-external'`\n    // (with a `.css` exemption), which stripped intentional side-effect-only imports of external\n    // packages (e.g. `import 'react-time-ago/locale/en'`) from the output. The default preserves\n    // those imports while still honoring `package.json` `sideEffects` fields for bundled modules.\n  })\n}\n"],"mappings":";;;;AAkDA,SAAgB,aAAa,UAA0B,CAAC,GAAe;CACrE,IAAM,EAAC,UAAS,SACV,WAAW,QAAQ,YAAY,iBAC/B,WAAW,QAAQ,YAAY,WAC/B,mBAAmB,QAAQ,oBAAoB,IAC/C,SAAS,EAAC,MAAM,GAAK;CAwC3B,OAAOA,eAAmB;EACxB;EACA,SAAA;GAPA,SAAS;GAET,YAAY;EAKN;EACN,QAxCa,QAAQ,UAAU;EAyC/B,MAAA;EACA,cAAA;GAxCA,yBAAyB;GACzB,cAAc,EAAC,iBAAiB,OAAM;GACtC,GAAI,qBAAqB,MAAS,EAChC,WAAW,EACT,SAAS,EACP,kBAAkB;IAIhB,UAAU;IAIV,2BAA2B;IAG3B,MAAM;IAGN,SAAS;IACT,GAAI,OAAO,oBAAqB,WAAW,mBAAmB,CAAC;GACjE,EACF,EACF,EACF;EAgBW;EACX,eAAA,EAdA,wBAAwB,GAcZ;EACZ;EACA;EACA;EACA;EACA,QAAQ;GAAC,UAAU;GAAM,SAAS;GAAO,QAAQ;EAAK;CAMxD,CAAC;AACH"}
+{"version":3,"file":"index.mjs","names":["defineTsdownConfig"],"sources":["../src/index.ts"],"sourcesContent":["import type {PluginOptions as ReactCompilerPluginOptions} from 'babel-plugin-react-compiler'\nimport {defineConfig as defineTsdownConfig, type Rolldown, type UserConfig} from 'tsdown'\nimport type {PackageVanillaExtractOptions} from './vanillaExtract.ts'\n\nexport type {PackageVanillaExtractOptions}\n\n/**\n * Options for the `styled-components` transform, the same options as `babel-plugin-styled-components`.\n * @public\n */\nexport interface StyledComponentsOptions {\n  /** @defaultValue true */\n  displayName?: boolean\n  /**\n   * @defaultValue []\n   * @example [\"\\@xstyled/styled-components\", \"\\@xstyled/styled-components/*\"]\n   */\n  topLevelImportPaths?: string[]\n  /** @defaultValue true */\n  ssr?: boolean\n  /** @defaultValue false */\n  fileName?: boolean\n  /** @defaultValue [\"index\"] */\n  meaninglessFileNames?: string[]\n  /** @defaultValue true */\n  minify?: boolean\n  /** @defaultValue false */\n  transpileTemplateLiterals?: boolean\n  namespace?: string\n  /** @defaultValue true */\n  pure?: boolean\n}\n\n/**\n * Options for the React Compiler, the same options as `babel-plugin-react-compiler`.\n * The typings resolve in userland once `babel-plugin-react-compiler` (an optional peer\n * dependency, required to use `reactCompiler`) is installed, and always match the installed\n * version of the compiler.\n * @public\n */\nexport type ReactCompilerOptions = Partial<ReactCompilerPluginOptions>\n\n/**\n * @public\n */\nexport interface PackageOptions extends Pick<UserConfig, 'tsconfig' | 'entry' | 'format'> {\n  /**\n   * @defaultValue 'neutral'\n   */\n  platform?: UserConfig['platform']\n  /**\n   * Runs `babel-plugin-react-compiler` on the source files before they are bundled, so published\n   * components are memoized automatically. Pass `true` to use the defaults, or an options object\n   * to configure the compiler (e.g. `{target: '18'}`).\n   * This is the same feature as the `babel: {reactCompiler: true}` and `reactCompilerOptions`\n   * options in `@sanity/pkg-utils`. Unlike `styledComponents` there's no oxc native port of the\n   * React Compiler yet, so `babel-plugin-react-compiler` needs to be installed.\n   * @defaultValue false\n   */\n  reactCompiler?: boolean | ReactCompilerOptions\n  /**\n   * Applies the `styled-components` transform (`displayName`, `componentId`, CSS minification, etc)\n   * with the same defaults as the `babel: {styledComponents: true}` option in `@sanity/pkg-utils`.\n   * Unlike `@sanity/pkg-utils` it doesn't use `babel-plugin-styled-components`, but oxc's native port of it,\n   * so there's no need to install babel dependencies.\n   * @defaultValue false\n   */\n  styledComponents?: boolean | StyledComponentsOptions\n  /**\n   * Enables `@vanilla-extract/rollup-plugin` to extract CSS into a separate file, with support for\n   * minifying the extracted CSS. Pass `true` to use the defaults, or an object to customize.\n   *\n   * By default (`extract.compatMode: true`) the config also injects the self-referential\n   * `import \"<pkg>/bundle.css\"`, emits a `bundle.css.js` shim, and writes the conditional\n   * `\"./bundle.css\"` export to `package.json` - see {@link PackageVanillaExtractOptions}.\n   * This is the same feature as `rollup.vanillaExtract` in `@sanity/pkg-utils`.\n   * @alpha\n   */\n  vanillaExtract?: boolean | PackageVanillaExtractOptions\n}\n\n/**\n * @public\n */\nexport async function defineConfig(options: PackageOptions = {}): Promise<UserConfig> {\n  const {entry} = options\n  const tsconfig = options.tsconfig ?? 'tsconfig.json'\n  const platform = options.platform ?? 'neutral'\n  const reactCompiler = options.reactCompiler ?? false\n  const styledComponents = options.styledComponents ?? false\n  const report = {gzip: false} as const satisfies UserConfig['report']\n  const publint = true\n  const hash = false\n  const format = options.format ?? 'esm'\n  const inputOptions = {\n    preserveEntrySignatures: 'strict',\n    experimental: {attachDebugInfo: 'none'},\n    ...(styledComponents !== false && {\n      transform: {\n        plugins: {\n          styledComponents: {\n            // The same defaults as `babel: {styledComponents: true}` in `@sanity/pkg-utils`:\n            // `fileName` is unnecessary, as the way we use styled-components in Sanity is usually by wrapping\n            // `@sanity/ui` primitives, not declaring new ones like \"const Button = styled.button``\"\n            fileName: false,\n            // Native template literals take less space than this transpilation, and unlike\n            // `babel-plugin-styled-components`, oxc doesn't add a `@__PURE__` annotation to the\n            // transpiled call expression either, so enabling it wouldn't improve tree-shaking\n            transpileTemplateLiterals: false,\n            // Helps dead code elimination and tree-shaking, although oxc only annotates plain call\n            // expressions so far, not tagged template expressions (https://github.com/rollup/rollup/issues/4035)\n            pure: true,\n            // Disabled, as tsdown tends to be used for npm publishing, while other tooling,\n            // like `sanity dev`, `next dev`, etc are used for testing\n            cssProp: false,\n            ...(typeof styledComponents === 'object' ? styledComponents : {}),\n          },\n        },\n      },\n    }),\n  } as const satisfies UserConfig['inputOptions']\n\n  const baseOutputOptions = {\n    hoistTransitiveImports: false,\n  } as const satisfies UserConfig['outputOptions']\n\n  let outputOptions: UserConfig['outputOptions'] = baseOutputOptions\n  let treeshake: UserConfig['treeshake']\n  let customExports: ((exportsMap: Record<string, unknown>) => Record<string, unknown>) | undefined\n\n  const plugins: Rolldown.Plugin[] = []\n  if (reactCompiler !== false) {\n    // Follows the official tsdown recipe for the React Compiler:\n    // https://tsdown.dev/recipes/react-support#enabling-react-compiler\n    // The plugins are lazy loaded so they're only paid for when the React Compiler is enabled.\n    // `babel-plugin-react-compiler` itself is resolved by Babel from the consumer package during\n    // the build, which is why it can be an optional peer dependency. Once rolldown ships its rust\n    // port of the React Compiler this can be swapped out for an oxc transform, like `styledComponents`.\n    const [{default: pluginBabel}, {reactCompilerPreset}] = await Promise.all([\n      import('@rolldown/plugin-babel'),\n      import('@vitejs/plugin-react'),\n    ])\n    plugins.push(\n      // The plugin types don't match when `@rolldown/plugin-babel` resolves its `rolldown` peer\n      // dependency to a different version than the one bundled with `tsdown`, so cast it:\n      // https://tsdown.dev/advanced/plugins#rollup-plugins\n      // oxlint-disable-next-line no-unsafe-type-assertion\n      (await pluginBabel({\n        presets: [reactCompilerPreset(typeof reactCompiler === 'object' ? reactCompiler : {})],\n      })) as unknown as Rolldown.Plugin,\n    )\n  }\n  if (options.vanillaExtract) {\n    // Everything vanilla-extract related is lazy loaded, like `reactCompiler`, so it's only paid\n    // for when the option is enabled: `@vanilla-extract/rollup-plugin` compiles the `.css.ts`\n    // files, and `optimizeCss` pulls in the CSS toolchain (`lightningcss`, `browserslist`) that\n    // minifies the extracted CSS.\n    const [\n      {vanillaExtractPlugin},\n      {default: browserslistConfig},\n      {optimizeCss},\n      {bundleCssShim},\n      {\n        composeIntro,\n        createConditionalCssExport,\n        insertCssExport,\n        readPackageName,\n        resolveVanillaExtract,\n        resolveVanillaExtractCssName,\n      },\n    ] = await Promise.all([\n      import('@vanilla-extract/rollup-plugin'),\n      import('@sanity/browserslist-config'),\n      import('./optimizeCss.ts'),\n      import('./bundleCssShim.ts'),\n      import('./vanillaExtract.ts'),\n    ])\n\n    // Resolve vanilla-extract options + the conditional CSS export \"compat mode\"\n    const vanillaExtract = resolveVanillaExtract(options.vanillaExtract)\n    const cssName = resolveVanillaExtractCssName(vanillaExtract.options)\n\n    plugins.push(\n      // Rolldown supports most Rollup plugins, but the plugin types are not identical, so the\n      // official guidance is to cast: https://tsdown.dev/advanced/plugins#rollup-plugins\n      // oxlint-disable-next-line no-unsafe-type-assertion\n      vanillaExtractPlugin({\n        identifiers: vanillaExtract.options.identifiers ?? 'short',\n        cwd: vanillaExtract.options.cwd,\n        esbuildOptions: vanillaExtract.options.esbuildOptions,\n        unstable_injectFilescopes: vanillaExtract.options.unstable_injectFilescopes,\n        extract: {\n          name: cssName,\n          sourcemap: vanillaExtract.options.extract?.sourcemap ?? true,\n        },\n      }) as unknown as Rolldown.Plugin,\n      optimizeCss({\n        extractFileName: cssName,\n        browserslist: vanillaExtract.options.browserslist || browserslistConfig,\n        minify: vanillaExtract.options.minify ?? true,\n      }),\n    )\n\n    // The vanilla-extract plugin resolves each compiled `.css.ts` module's CSS to an external,\n    // side-effect-only `<file>.vanilla.css` import and extracts the CSS into a single file. The\n    // imports are redundant once the CSS is extracted, so let tree-shaking drop them up front:\n    // the plugin's own `generateBundle` cleanup only strips imports at the start of a line, which\n    // the minifier's statement merging can defeat (e.g. `a(), require(\"….vanilla.css\")` in CJS).\n    // Modules not matching the rule keep the default tree-shaking behavior.\n    treeshake = {moduleSideEffects: [{test: /\\.vanilla\\.css$/, external: true, sideEffects: false}]}\n\n    // In compat mode, the self-referential `import \"<pkg>/<css>\"` needs the package name.\n    const cssImportId = vanillaExtract.compatMode\n      ? `${readPackageName(process.cwd())}/${cssName}`\n      : undefined\n\n    outputOptions = (_options, outputFormat, context) => ({\n      ...baseOutputOptions,\n      // Emit the extracted CSS (and its sourcemap) with a stable name at the root of the tsdown\n      // default `outDir` ('dist', not configurable yet) instead of rolldown's default\n      // `assets/[name]-[hash][extname]`, so it can back the conditional `./<css>` export.\n      assetFileNames: '[name][extname]',\n      // In compat mode, inject the self-referential CSS import into the `index` entry chunk so\n      // userland does not need to set `outputOptions.intro` themselves. Use `require()` for\n      // CommonJS output (a top-level `import` would be invalid in a `.cjs` bundle).\n      ...(cssImportId && !context.cjsDts && (outputFormat === 'es' || outputFormat === 'cjs')\n        ? {\n            intro: composeIntro(\n              outputFormat === 'cjs'\n                ? `require(${JSON.stringify(cssImportId)})`\n                : `import ${JSON.stringify(cssImportId)}`,\n            ),\n          }\n        : {}),\n    })\n\n    if (vanillaExtract.compatMode) {\n      // In compat mode, emit the no-op JS shim that the `node`/`default` conditions of the\n      // `./<css>` export resolve to.\n      plugins.push(bundleCssShim({fileName: `${cssName}.js`}))\n\n      // Write the conditional `./<css>` export to `package.json` (and, through tsdown, mirror it\n      // into `publishConfig.exports`) so userland does not have to maintain it.\n      const conditionalCssExport = createConditionalCssExport(cssName, 'dist')\n      customExports = (exportsMap) =>\n        insertCssExport(exportsMap, `./${cssName}`, conditionalCssExport)\n    }\n  }\n\n  const exports = {\n    enabled: 'local-only',\n    // @TODO use @sanity/parse-package-json to determine if devExports should be `true` or `source`\n    devExports: true,\n    ...(customExports && {customExports}),\n  } as const satisfies UserConfig['exports']\n\n  return defineTsdownConfig({\n    entry,\n    exports,\n    format,\n    hash,\n    inputOptions,\n    outputOptions,\n    platform,\n    plugins,\n    publint,\n    report,\n    treeshake,\n    tsconfig,\n    minify: {compress: true, codegen: false, mangle: false},\n    // `treeshake` stays `undefined` (tsdown's/rolldown's default, `moduleSideEffects: true`)\n    // unless vanilla-extract needs its targeted rule above. Previously this set the equivalent of\n    // `moduleSideEffects: 'no-external'` (with a `.css` exemption), which stripped intentional\n    // side-effect-only imports of external packages (e.g. `import 'react-time-ago/locale/en'`)\n    // from the output. The default preserves those imports while still honoring `package.json`\n    // `sideEffects` fields for bundled modules.\n  })\n}\n"],"mappings":";;;;AAoFA,eAAsB,aAAa,UAA0B,CAAC,GAAwB;CACpF,IAAM,EAAC,UAAS,SACV,WAAW,QAAQ,YAAY,iBAC/B,WAAW,QAAQ,YAAY,WAC/B,gBAAgB,QAAQ,iBAAiB,IACzC,mBAAmB,QAAQ,oBAAoB,IAC/C,SAAS,EAAC,MAAM,GAAK,GAGrB,SAAS,QAAQ,UAAU,OAC3B,eAAe;EACnB,yBAAyB;EACzB,cAAc,EAAC,iBAAiB,OAAM;EACtC,GAAI,qBAAqB,MAAS,EAChC,WAAW,EACT,SAAS,EACP,kBAAkB;GAIhB,UAAU;GAIV,2BAA2B;GAG3B,MAAM;GAGN,SAAS;GACT,GAAI,OAAO,oBAAqB,WAAW,mBAAmB,CAAC;EACjE,EACF,EACF,EACF;CACF,GAEM,oBAAoB,EACxB,wBAAwB,GAC1B,GAEI,gBAA6C,mBAC7C,WACA,eAEE,UAA6B,CAAC;CACpC,IAAI,kBAAkB,IAAO;EAO3B,IAAM,CAAC,EAAC,SAAS,eAAc,EAAC,yBAAwB,MAAM,QAAQ,IAAI,CACxE,OAAO,2BACP,OAAO,uBACT,CAAC;EACD,QAAQ,KAKL,MAAM,YAAY,EACjB,SAAS,CAAC,oBAAoB,OAAO,iBAAkB,WAAW,gBAAgB,CAAC,CAAC,CAAC,EACvF,CAAC,CACH;CACF;CACA,IAAI,QAAQ,gBAAgB;EAK1B,IAAM,CACJ,EAAC,wBACD,EAAC,SAAS,sBACV,EAAC,eACD,EAAC,iBACD,EACE,cACA,4BACA,iBACA,iBACA,uBACA,kCAEA,MAAM,QAAQ,IAAI;GACpB,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;GACP,OAAO;EACT,CAAC,GAGK,iBAAiB,sBAAsB,QAAQ,cAAc,GAC7D,UAAU,6BAA6B,eAAe,OAAO;EA6BnE,AA3BA,QAAQ,KAIN,qBAAqB;GACnB,aAAa,eAAe,QAAQ,eAAe;GACnD,KAAK,eAAe,QAAQ;GAC5B,gBAAgB,eAAe,QAAQ;GACvC,2BAA2B,eAAe,QAAQ;GAClD,SAAS;IACP,MAAM;IACN,WAAW,eAAe,QAAQ,SAAS,aAAa;GAC1D;EACF,CAAC,GACD,YAAY;GACV,iBAAiB;GACjB,cAAc,eAAe,QAAQ,gBAAgB;GACrD,QAAQ,eAAe,QAAQ,UAAU;EAC3C,CAAC,CACH,GAQA,YAAY,EAAC,mBAAmB,CAAC;GAAC,MAAM;GAAmB,UAAU;GAAM,aAAa;EAAK,CAAC,EAAC;EAG/F,IAAM,cAAc,eAAe,aAC/B,GAAG,gBAAgB,QAAQ,IAAI,CAAC,EAAE,GAAG,YACrC,KAAA;EAsBJ,IApBA,iBAAiB,UAAU,cAAc,aAAa;GACpD,GAAG;GAIH,gBAAgB;GAIhB,GAAI,eAAe,CAAC,QAAQ,WAAW,iBAAiB,QAAQ,iBAAiB,SAC7E,EACE,OAAO,aACL,iBAAiB,QACb,WAAW,KAAK,UAAU,WAAW,EAAE,KACvC,UAAU,KAAK,UAAU,WAAW,GAC1C,EACF,IACA,CAAC;EACP,IAEI,eAAe,YAAY;GAG7B,QAAQ,KAAK,cAAc,EAAC,UAAU,GAAG,QAAQ,KAAI,CAAC,CAAC;GAIvD,IAAM,uBAAuB,2BAA2B,SAAS,MAAM;GACvE,iBAAiB,eACf,gBAAgB,YAAY,KAAK,WAAW,oBAAoB;EACpE;CACF;CASA,OAAOA,eAAmB;EACxB;EACA,SAAA;GARA,SAAS;GAET,YAAY;GACZ,GAAI,iBAAiB,EAAC,cAAa;EAK7B;EACN;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,QAAQ;GAAC,UAAU;GAAM,SAAS;GAAO,QAAQ;EAAK;CAOxD,CAAC;AACH"}

package/dist/optimizeCss.mjs

@@ -0,0 +1,38 @@
+import { basename } from "node:path";
+import browserslist from "browserslist";
+import { browserslistToTargets, transform } from "lightningcss";
+/**
+* Post-processes the CSS file extracted by `@vanilla-extract/rollup-plugin` with `lightningcss`,
+* applying browserslist targets and (unless disabled) minification. Ported from the equivalent
+* `@sanity/pkg-utils` Rollup plugin.
+* @internal
+*/
+function optimizeCss(options) {
+	return {
+		name: "sanity-tsdown-config:optimize-css",
+		async generateBundle(_outputOptions, bundle, _isWrite) {
+			for (let [fileName, assetOrChunk] of Object.entries(bundle)) if (assetOrChunk.type === "asset") {
+				let asset = assetOrChunk;
+				if (asset.fileName === options.extractFileName || asset.originalFileNames.includes(options.extractFileName)) {
+					let sourceMap = bundle[`${fileName}.map`];
+					await transformCss(asset, sourceMap?.type === "asset" ? sourceMap : void 0, options.browserslist, options.minify ?? !0);
+				}
+			}
+		}
+	};
+}
+async function transformCss(asset, sourceMapAsset, browserslistConfig, minify) {
+	let css = asset.source.toString(), file = asset.fileName, targets = browserslistToTargets(browserslist(browserslistConfig)), lightningCssResult = transform({
+		filename: file,
+		code: Buffer.from(css),
+		minify,
+		cssModules: !1,
+		targets,
+		sourceMap: !!sourceMapAsset,
+		inputSourceMap: sourceMapAsset ? sourceMapAsset.source.toString() : void 0
+	});
+	lightningCssResult.warnings.length && console.warn(lightningCssResult.warnings), asset.source = new TextDecoder().decode(lightningCssResult.code), sourceMapAsset && lightningCssResult.map && (sourceMapAsset.source = new TextDecoder().decode(lightningCssResult.map), asset.source += `\n/*# sourceMappingURL=${basename(sourceMapAsset.fileName)}*/\n`);
+}
+export { optimizeCss };
+
+//# sourceMappingURL=optimizeCss.mjs.map

package/dist/optimizeCss.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizeCss.mjs","names":[],"sources":["../src/optimizeCss.ts"],"sourcesContent":["import {basename} from 'node:path'\nimport browserslist from 'browserslist'\nimport {browserslistToTargets, transform} from 'lightningcss'\nimport type {Rolldown} from 'tsdown'\n\n/**\n * Post-processes the CSS file extracted by `@vanilla-extract/rollup-plugin` with `lightningcss`,\n * applying browserslist targets and (unless disabled) minification. Ported from the equivalent\n * `@sanity/pkg-utils` Rollup plugin.\n * @internal\n */\nexport function optimizeCss(options: {\n  extractFileName: string\n  browserslist: string | string[]\n  minify?: boolean\n}): Rolldown.Plugin {\n  return {\n    name: 'sanity-tsdown-config:optimize-css',\n\n    async generateBundle(_outputOptions, bundle, _isWrite) {\n      for (const [fileName, assetOrChunk] of Object.entries(bundle)) {\n        // find the extracted CSS asset\n        if (assetOrChunk.type === 'asset') {\n          const asset = assetOrChunk\n          if (\n            asset.fileName === options.extractFileName ||\n            asset.originalFileNames.includes(options.extractFileName)\n          ) {\n            const sourceMap = bundle[`${fileName}.map`]\n            await transformCss(\n              asset,\n              sourceMap?.type === 'asset' ? sourceMap : undefined,\n              options.browserslist,\n              options.minify ?? true,\n            )\n          }\n        }\n      }\n    },\n  }\n}\n\nasync function transformCss(\n  asset: Rolldown.OutputAsset,\n  sourceMapAsset: Rolldown.OutputAsset | undefined,\n  browserslistConfig: string | string[],\n  minify: boolean,\n) {\n  const css = asset.source.toString()\n  const file = asset.fileName\n\n  const targets = browserslistToTargets(browserslist(browserslistConfig))\n\n  // process (and, unless disabled, minify) css using lightningcss\n  const lightningCssResult = transform({\n    filename: file,\n    code: Buffer.from(css),\n    minify,\n    cssModules: false,\n    targets,\n    sourceMap: !!sourceMapAsset,\n    inputSourceMap: sourceMapAsset ? sourceMapAsset.source.toString() : undefined,\n  })\n\n  if (lightningCssResult.warnings.length) {\n    console.warn(lightningCssResult.warnings)\n  }\n\n  asset.source = new TextDecoder().decode(lightningCssResult.code)\n  if (sourceMapAsset && lightningCssResult.map) {\n    sourceMapAsset.source = new TextDecoder().decode(lightningCssResult.map)\n    asset.source += `\\n/*# sourceMappingURL=${basename(sourceMapAsset.fileName)}*/\\n`\n  }\n}\n"],"mappings":";;;;;;;;;AAWA,SAAgB,YAAY,SAIR;CAClB,OAAO;EACL,MAAM;EAEN,MAAM,eAAe,gBAAgB,QAAQ,UAAU;GACrD,KAAK,IAAM,CAAC,UAAU,iBAAiB,OAAO,QAAQ,MAAM,GAE1D,IAAI,aAAa,SAAS,SAAS;IACjC,IAAM,QAAQ;IACd,IACE,MAAM,aAAa,QAAQ,mBAC3B,MAAM,kBAAkB,SAAS,QAAQ,eAAe,GACxD;KACA,IAAM,YAAY,OAAO,GAAG,SAAS;KACrC,MAAM,aACJ,OACA,WAAW,SAAS,UAAU,YAAY,KAAA,GAC1C,QAAQ,cACR,QAAQ,UAAU,EACpB;IACF;GACF;EAEJ;CACF;AACF;AAEA,eAAe,aACb,OACA,gBACA,oBACA,QACA;CACA,IAAM,MAAM,MAAM,OAAO,SAAS,GAC5B,OAAO,MAAM,UAEb,UAAU,sBAAsB,aAAa,kBAAkB,CAAC,GAGhE,qBAAqB,UAAU;EACnC,UAAU;EACV,MAAM,OAAO,KAAK,GAAG;EACrB;EACA,YAAY;EACZ;EACA,WAAW,CAAC,CAAC;EACb,gBAAgB,iBAAiB,eAAe,OAAO,SAAS,IAAI,KAAA;CACtE,CAAC;CAOD,AALI,mBAAmB,SAAS,UAC9B,QAAQ,KAAK,mBAAmB,QAAQ,GAG1C,MAAM,SAAS,IAAI,YAAY,CAAC,CAAC,OAAO,mBAAmB,IAAI,GAC3D,kBAAkB,mBAAmB,QACvC,eAAe,SAAS,IAAI,YAAY,CAAC,CAAC,OAAO,mBAAmB,GAAG,GACvE,MAAM,UAAU,0BAA0B,SAAS,eAAe,QAAQ,EAAE;AAEhF"}

package/dist/vanillaExtract.mjs

@@ -0,0 +1,77 @@
+import path from "node:path";
+import { readFileSync } from "node:fs";
+/**
+* Normalize the `vanillaExtract` option into a consistent shape and resolve whether compatibility
+* mode is active.
+* @internal
+*/
+function resolveVanillaExtract(value) {
+	let enabled = !!value, options = value === !0 || !value ? {} : value;
+	return {
+		enabled,
+		options,
+		compatMode: enabled ? options.extract?.compatMode ?? !0 : !1
+	};
+}
+/**
+* Resolve the name of the emitted CSS file. Unlike `@sanity/pkg-utils`, tsdown produces a single
+* bundle that is shared across runtimes, so there are no runtime-suffixed defaults.
+* @internal
+*/
+function resolveVanillaExtractCssName(options) {
+	return options.extract?.name ?? "bundle.css";
+}
+/**
+* Build the conditional CSS export object that vanilla-extract compat mode expects, e.g.
+* ```json
+* {
+*   "browser": "./dist/bundle.css",
+*   "style": "./dist/bundle.css",
+*   "node": "./dist/bundle.css.js",
+*   "default": "./dist/bundle.css.js"
+* }
+* ```
+* @internal
+*/
+function createConditionalCssExport(cssName, outDir) {
+	let cssFile = `./${outDir}/${cssName}`, shimFile = `./${outDir}/${cssName}.js`;
+	return {
+		browser: cssFile,
+		style: cssFile,
+		node: shimFile,
+		default: shimFile
+	};
+}
+/**
+* Insert (or replace) the `"./<cssName>"` export in an `exports`-shaped map, preserving the
+* existing order and placing it before `./package.json` when present. Used with tsdown's
+* `exports.customExports` so both `exports` and `publishConfig.exports` receive the entry.
+* @internal
+*/
+function insertCssExport(exports, exportKey, conditionalExport) {
+	let nextExports = {}, inserted = !1;
+	for (let [key, value] of Object.entries(exports)) key !== exportKey && (key === "./package.json" && !inserted && (nextExports[exportKey] = conditionalExport, inserted = !0), nextExports[key] = value);
+	return inserted || (nextExports[exportKey] = conditionalExport), nextExports;
+}
+const RE_DTS = /\.d\.[cm]?ts$/;
+/**
+* Build an `intro` function that prepends `autoImport` to the `index` entry chunk only. The
+* `.d.ts` chunks generated by tsdown share the build, so they are explicitly excluded.
+* @internal
+*/
+function composeIntro(autoImport) {
+	return (chunk) => chunk.isEntry && chunk.name === "index" && !RE_DTS.test(chunk.fileName) ? `${autoImport}\n` : "";
+}
+/**
+* Resolve the package name from `package.json`, required by compat mode to inject the
+* self-referential CSS import.
+* @internal
+*/
+function readPackageName(cwd) {
+	let pkgPath = path.resolve(cwd, "package.json"), pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+	if (typeof pkg.name != "string" || !pkg.name) throw Error(`Unable to resolve the package name from ${pkgPath}, which is required by \`vanillaExtract\` compat mode to inject the self-referential CSS import. Set \`vanillaExtract: {extract: {compatMode: false}}\` to wire up the CSS export manually.`);
+	return pkg.name;
+}
+export { composeIntro, createConditionalCssExport, insertCssExport, readPackageName, resolveVanillaExtract, resolveVanillaExtractCssName };
+
+//# sourceMappingURL=vanillaExtract.mjs.map

package/dist/vanillaExtract.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"vanillaExtract.mjs","names":[],"sources":["../src/vanillaExtract.ts"],"sourcesContent":["import {readFileSync} from 'node:fs'\nimport path from 'node:path'\nimport type {Options as VanillaExtractPluginOptions} from '@vanilla-extract/rollup-plugin'\nimport type {Rolldown} from 'tsdown'\n\n/** The default name of the extracted CSS file. */\nconst DEFAULT_VANILLA_EXTRACT_CSS_NAME = 'bundle.css'\n\n/**\n * Options for the `@vanilla-extract/rollup-plugin` integration, including the same extensions as\n * `@sanity/pkg-utils` (`minify`, `browserslist`, and `extract.compatMode`).\n * @public\n */\nexport interface PackageVanillaExtractOptions extends Omit<VanillaExtractPluginOptions, 'extract'> {\n  /**\n   * Minify the extracted CSS with `lightningcss`.\n   * @defaultValue true\n   */\n  minify?: boolean\n  /**\n   * Browserslist query passed to `lightningcss` when optimizing the extracted CSS.\n   * @defaultValue `@sanity/browserslist-config`\n   */\n  browserslist?: string | string[]\n  /**\n   * Different formatting of identifiers (e.g. class names, keyframes, CSS Vars, etc).\n   * @defaultValue \"short\"\n   */\n  identifiers?: VanillaExtractPluginOptions['identifiers']\n  /**\n   * Extract the CSS into a separate file. The CSS is always extracted, so this configures _how_.\n   */\n  extract?: {\n    /**\n     * Name of the emitted `.css` file (and, with `compatMode`, the `exports` subpath + shim base).\n     * @defaultValue \"bundle.css\"\n     */\n    name?: string\n    /**\n     * Generate a `.css.map` sourcemap file.\n     * @defaultValue true\n     */\n    sourcemap?: boolean\n    /**\n     * Compatibility mode automatically wires up the conditional CSS export pattern so userland does\n     * not have to. When enabled, the config:\n     *\n     * - injects `import \"<pkg-name>/<name>\"` into the `index` entry chunk,\n     * - emits a no-op `<name>.js` shim for runtimes that cannot import `.css` files, and\n     * - writes the conditional `\"./<name>\"` export to `package.json`\n     *   (`browser`/`style` → the real CSS, `node`/`default` → the shim).\n     *\n     * The result is that `import \"<pkg>/<name>\"` resolves to the real CSS in bundlers/browsers and\n     * to the no-op shim in Node and similar runtimes. Disable it to wire these up yourself.\n     * @defaultValue true\n     */\n    compatMode?: boolean\n  }\n}\n\n/** @internal */\nexport interface ResolvedVanillaExtract {\n  enabled: boolean\n  /** Normalized options (the object form, or `{}` when `vanillaExtract: true`). */\n  options: PackageVanillaExtractOptions\n  /**\n   * Whether to automatically wire up the conditional CSS export pattern (intro import, JS shim, and\n   * the `package.json` export). Only `true` when vanilla-extract is enabled.\n   */\n  compatMode: boolean\n}\n\n/**\n * Normalize the `vanillaExtract` option into a consistent shape and resolve whether compatibility\n * mode is active.\n * @internal\n */\nexport function resolveVanillaExtract(\n  value: boolean | PackageVanillaExtractOptions | undefined,\n): ResolvedVanillaExtract {\n  const enabled = Boolean(value)\n  const options: PackageVanillaExtractOptions = value === true || !value ? {} : value\n  const compatMode = enabled ? (options.extract?.compatMode ?? true) : false\n\n  return {enabled, options, compatMode}\n}\n\n/**\n * Resolve the name of the emitted CSS file. Unlike `@sanity/pkg-utils`, tsdown produces a single\n * bundle that is shared across runtimes, so there are no runtime-suffixed defaults.\n * @internal\n */\nexport function resolveVanillaExtractCssName(options: PackageVanillaExtractOptions): string {\n  return options.extract?.name ?? DEFAULT_VANILLA_EXTRACT_CSS_NAME\n}\n\n/**\n * Build the conditional CSS export object that vanilla-extract compat mode expects, e.g.\n * ```json\n * {\n *   \"browser\": \"./dist/bundle.css\",\n *   \"style\": \"./dist/bundle.css\",\n *   \"node\": \"./dist/bundle.css.js\",\n *   \"default\": \"./dist/bundle.css.js\"\n * }\n * ```\n * @internal\n */\nexport function createConditionalCssExport(\n  cssName: string,\n  outDir: string,\n): Record<string, string> {\n  const cssFile = `./${outDir}/${cssName}`\n  const shimFile = `./${outDir}/${cssName}.js`\n  return {browser: cssFile, style: cssFile, node: shimFile, default: shimFile}\n}\n\n/**\n * Insert (or replace) the `\"./<cssName>\"` export in an `exports`-shaped map, preserving the\n * existing order and placing it before `./package.json` when present. Used with tsdown's\n * `exports.customExports` so both `exports` and `publishConfig.exports` receive the entry.\n * @internal\n */\nexport function insertCssExport(\n  exports: Record<string, unknown>,\n  exportKey: string,\n  conditionalExport: Record<string, string>,\n): Record<string, unknown> {\n  const nextExports: Record<string, unknown> = {}\n  let inserted = false\n  for (const [key, value] of Object.entries(exports)) {\n    if (key === exportKey) continue\n    if (key === './package.json' && !inserted) {\n      nextExports[exportKey] = conditionalExport\n      inserted = true\n    }\n    nextExports[key] = value\n  }\n  if (!inserted) {\n    nextExports[exportKey] = conditionalExport\n  }\n  return nextExports\n}\n\nconst RE_DTS = /\\.d\\.[cm]?ts$/\n\n/**\n * Build an `intro` function that prepends `autoImport` to the `index` entry chunk only. The\n * `.d.ts` chunks generated by tsdown share the build, so they are explicitly excluded.\n * @internal\n */\nexport function composeIntro(autoImport: string): (chunk: Rolldown.RenderedChunk) => string {\n  return (chunk) =>\n    chunk.isEntry && chunk.name === 'index' && !RE_DTS.test(chunk.fileName) ? `${autoImport}\\n` : ''\n}\n\n/**\n * Resolve the package name from `package.json`, required by compat mode to inject the\n * self-referential CSS import.\n * @internal\n */\nexport function readPackageName(cwd: string): string {\n  const pkgPath = path.resolve(cwd, 'package.json')\n  // oxlint-disable-next-line no-unsafe-type-assertion\n  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as {name?: unknown}\n  if (typeof pkg.name !== 'string' || !pkg.name) {\n    throw new Error(\n      `Unable to resolve the package name from ${pkgPath}, which is required by \\`vanillaExtract\\` compat mode to inject the self-referential CSS import. Set \\`vanillaExtract: {extract: {compatMode: false}}\\` to wire up the CSS export manually.`,\n    )\n  }\n  return pkg.name\n}\n"],"mappings":";;;;;;;AA6EA,SAAgB,sBACd,OACwB;CACxB,IAAM,UAAU,EAAQ,OAClB,UAAwC,UAAU,MAAQ,CAAC,QAAQ,CAAC,IAAI;CAG9E,OAAO;EAAC;EAAS;EAAS,YAFP,UAAW,QAAQ,SAAS,cAAc,KAAQ;CAEjC;AACtC;;;;;;AAOA,SAAgB,6BAA6B,SAA+C;CAC1F,OAAO,QAAQ,SAAS,QAAQ;AAClC;;;;;;;;;;;;;AAcA,SAAgB,2BACd,SACA,QACwB;CACxB,IAAM,UAAU,KAAK,OAAO,GAAG,WACzB,WAAW,KAAK,OAAO,GAAG,QAAQ;CACxC,OAAO;EAAC,SAAS;EAAS,OAAO;EAAS,MAAM;EAAU,SAAS;CAAQ;AAC7E;;;;;;;AAQA,SAAgB,gBACd,SACA,WACA,mBACyB;CACzB,IAAM,cAAuC,CAAC,GAC1C,WAAW;CACf,KAAK,IAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,GAC3C,QAAQ,cACR,QAAQ,oBAAoB,CAAC,aAC/B,YAAY,aAAa,mBACzB,WAAW,KAEb,YAAY,OAAO;CAKrB,OAHK,aACH,YAAY,aAAa,oBAEpB;AACT;AAEA,MAAM,SAAS;;;;;;AAOf,SAAgB,aAAa,YAA+D;CAC1F,QAAQ,UACN,MAAM,WAAW,MAAM,SAAS,WAAW,CAAC,OAAO,KAAK,MAAM,QAAQ,IAAI,GAAG,WAAW,MAAM;AAClG;;;;;;AAOA,SAAgB,gBAAgB,KAAqB;CACnD,IAAM,UAAU,KAAK,QAAQ,KAAK,cAAc,GAE1C,MAAM,KAAK,MAAM,aAAa,SAAS,MAAM,CAAC;CACpD,IAAI,OAAO,IAAI,QAAS,YAAY,CAAC,IAAI,MACvC,MAAU,MACR,2CAA2C,QAAQ,4LACrD;CAEF,OAAO,IAAI;AACb"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sanity/tsdown-config",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Shared configuration for tsdown",
   "keywords": [
     "sanity-io",
@@ -35,21 +35,36 @@
     "dist"
   ],
   "dependencies": {
+    "@babel/core": "^7.29.7",
+    "@rolldown/plugin-babel": "^0.2.3",
+    "@sanity/browserslist-config": "^1.0.5",
+    "@vanilla-extract/rollup-plugin": "^1.5.3",
+    "@vitejs/plugin-react": "^6.0.3",
+    "browserslist": "^4.28.4",
+    "lightningcss": "^1.32.0",
     "publint": "^0.3.21"
   },
   "devDependencies": {
+    "@types/babel__core": "^7.20.5",
     "@typescript/native-preview": "7.0.0-dev.20260421.2",
+    "babel-plugin-react-compiler": "^1.0.0",
     "tinyexec": "^1.2.4",
     "tsdown": "^0.22.3",
     "typescript": "6.0.3",
     "vitest": "^4.1.9",
-    "@sanity/tsconfig": "^2.1.0",
-    "@sanity/pkg-utils": "^10.9.0"
+    "@sanity/pkg-utils": "^10.9.0",
+    "@sanity/tsconfig": "^2.2.0"
   },
   "peerDependencies": {
+    "babel-plugin-react-compiler": "*",
     "tsdown": "0.22.x",
     "typescript": "5.8.x || 5.9.x || 6.0.x"
   },
+  "peerDependenciesMeta": {
+    "babel-plugin-react-compiler": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=20.19 <22 || >=22.12"
   },