@sanity/pkg-utils 11.0.17 → 12.0.1

package/dist/resolveBuildContext-CbwvYKj1.js

@@ -0,0 +1,714 @@
+import { i as fileExists, r as isRecord } from "./handleError-83GwKIFM.js";
+import { t as __exportAll } from "./initAction-CmOO8eod.js";
+import { existsSync } from "node:fs";
+import path, { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { tsImport } from "tsx/esm/api";
+import findConfig from "find-config";
+import { ZodError, _typoMap, parseExports, parsePackage } from "@sanity/parse-package-json";
+import chalk from "chalk";
+import fs from "node:fs/promises";
+import browserslistToEsbuild from "browserslist-to-esbuild";
+import config from "@sanity/browserslist-config";
+import ts from "@typescript/typescript6";
+import { errorMap } from "zod-validation-error/v3";
+import { z } from "zod/v3";
+const CONFIG_FILE_NAMES = [
+	"package.config.ts",
+	"package.config.js",
+	"package.config.cjs",
+	"package.config.mts",
+	"package.config.mjs"
+];
+/** @internal */
+function findConfigFile(cwd) {
+	let pkgJsonPath = findConfig("package.json", { cwd });
+	if (!pkgJsonPath) return;
+	let pkgPath = path.dirname(pkgJsonPath);
+	for (let fileName of CONFIG_FILE_NAMES) {
+		let configPath = path.resolve(pkgPath, fileName);
+		if (fileExists(configPath)) return configPath;
+	}
+}
+/**
+* Migration checks for `package.config.ts` options that were removed or deprecated in v12,
+* when `@sanity/pkg-utils` moved from its rollup/rolldown stack onto `tsdown` +
+* `@sanity/tsdown-config`.
+*
+* Removed options are "tombstoned": they stay declared on `PkgConfigOptions` (typed `never`,
+* tagged `@deprecated`) so editors surface the migration path, and the checks below throw a
+* runtime error with copy-pasteable migration instructions when they are set anyway — JS
+* configs bypass the types, and the error text is written to be actionable for humans and
+* agents alike.
+*
+* The checks are gated by the `legacyChecks` option, defaulting to on outside production
+* builds (`process.env.NODE_ENV !== 'production'`) so they add no overhead where migration
+* mistakes can no longer surface.
+*/
+const MIGRATION_GUIDE_URL = "https://github.com/sanity-io/pkg-utils/blob/main/packages/@sanity/pkg-utils/MIGRATE.md", tombstones = [
+	{
+		option: "tsgo",
+		migration: [
+			"The `dts` option is now passed through to tsdown as-is. Move the flag into it:",
+			"",
+			"  // package.config.ts",
+			"  export default defineConfig({",
+			"    dts: {tsgo: true},",
+			"  })"
+		]
+	},
+	{
+		option: "extract",
+		migration: [
+			"TSDoc/release-tag checking is configured with the top-level `tsdoc` option:",
+			"",
+			"  // extract: {enabled: false}          -> tsdoc: false",
+			"  // extract: {rules: {...}}            -> tsdoc: {rules: {...}}",
+			"  // extract: {customTags: [...]}       -> tsdoc: {customTags: [...]}",
+			"",
+			"Type inlining (`extract.bundledPackages`) follows the bundling decisions now:",
+			"devDependencies that are imported are inlined automatically (types included), and",
+			"`deps: {alwaysBundle: [...]}` forces inlining a dependency/peerDependency.",
+			"",
+			"`extract.checkTypes` has no successor: type generation no longer type-checks",
+			"(run `tsc --noEmit` for type checking)."
+		]
+	},
+	{
+		option: "babel",
+		migration: [
+			"The Babel options moved to the top level:",
+			"",
+			"  // babel: {reactCompiler: true}       -> reactCompiler: true",
+			"  // babel: {styledComponents: true}    -> styledComponents: true",
+			"",
+			"`styledComponents` now uses oxc’s native port of `babel-plugin-styled-components`,",
+			"so `babel-plugin-styled-components` can be uninstalled.",
+			"",
+			"Custom Babel plugins (`babel.plugins`) run through the `plugins` option instead,",
+			"with a self-installed `@rolldown/plugin-babel`:",
+			"",
+			"  import pluginBabel from \"@rolldown/plugin-babel\"",
+			"  export default defineConfig({",
+			"    plugins: [await pluginBabel({plugins: [\"babel-plugin-example\"]})],",
+			"  })"
+		]
+	},
+	{
+		option: "rollup",
+		migration: [
+			"The rollup stack was replaced with tsdown:",
+			"",
+			"  // rollup: {vanillaExtract: true}     -> vanillaExtract: true",
+			"  // rollup: {plugins: [...]}           -> plugins: [...] (rolldown plugins; most",
+			"  //                                       Rollup plugins are compatible)",
+			"",
+			"`rollup.output`, `rollup.treeshake`, `rollup.experimentalLogSideEffects` and",
+			"`rollup.hashChunkFileNames` have no successor (chunk filenames are content-hashed now).",
+			"",
+			"`rollup.optimizeLodash` has no successor either — and neither does the implicit",
+			"lodash-import optimization that was applied whenever `lodash` was a dependency.",
+			"Preferably drop lodash altogether (see https://e18e.dev for module replacements like",
+			"`es-toolkit`), or import from `lodash-es`, which tree-shakes in consumers without",
+			"build-time rewriting."
+		]
+	},
+	{
+		option: "reactCompilerOptions",
+		migration: [
+			"Pass the compiler options to `reactCompiler` instead:",
+			"",
+			"  // babel: {reactCompiler: true}, reactCompilerOptions: {target: \"18\"}",
+			"  // becomes:",
+			"  reactCompiler: {target: \"18\"}"
+		]
+	},
+	{
+		option: "jsx",
+		migration: [
+			"Configure JSX through `tsconfig.json` — the bundler reads it from there:",
+			"",
+			"  // tsconfig.json",
+			"  {\"compilerOptions\": {\"jsx\": \"react-jsx\"}}"
+		]
+	},
+	{
+		option: "jsxFactory",
+		migration: ["Configure JSX through `tsconfig.json` (`compilerOptions.jsxFactory`)."]
+	},
+	{
+		option: "jsxFragment",
+		migration: ["Configure JSX through `tsconfig.json` (`compilerOptions.jsxFragmentFactory`)."]
+	},
+	{
+		option: "jsxImportSource",
+		migration: ["Configure JSX through `tsconfig.json` (`compilerOptions.jsxImportSource`)."]
+	}
+];
+/**
+* Throws for tombstoned options and warns for grandfathered ones. `config` is the raw loaded
+* config object (before it is narrowed to `PkgConfigOptions`), so removed options are still
+* observable.
+* @internal
+*/
+function runLegacyConfigChecks(config) {
+	if (!(typeof config.legacyChecks == "boolean" ? config.legacyChecks : process.env.NODE_ENV !== "production")) return;
+	for (let { option, migration } of tombstones) if (config[option] !== void 0) throw Error([
+		`package.config.ts: the \`${option}\` option was removed in @sanity/pkg-utils v12.`,
+		"",
+		...migration,
+		"",
+		`Full migration guide: ${MIGRATION_GUIDE_URL}`,
+		"Set `legacyChecks: false` in package.config.ts to skip this validation (it is also",
+		"skipped when NODE_ENV=production)."
+	].join("\n"));
+	let dts = config.dts;
+	if (typeof dts == "string") throw Error([
+		`package.config.ts: \`dts: '${dts}'\` was removed in @sanity/pkg-utils v12 — the \`dts\``,
+		"option is now passed through to tsdown as-is (an options object, or `false`).",
+		"",
+		...dts === "rolldown" ? ["`dts: 'rolldown'` is the default behavior now: delete the option. Options that", "accompanied it move into the object, e.g. `tsgo: true` becomes `dts: {tsgo: true}`."] : [
+			"`dts: 'api-extractor'` type generation was removed. Types are generated with",
+			"tsdown (rolldown-plugin-dts); api-extractor remains as the TSDoc/release-tag",
+			"checking that runs during `pkg check` — configure it with the `tsdoc` option."
+		],
+		"",
+		`Full migration guide: ${MIGRATION_GUIDE_URL}`,
+		"Set `legacyChecks: false` in package.config.ts to skip this validation (it is also",
+		"skipped when NODE_ENV=production)."
+	].join("\n"));
+	config.external !== void 0 && console.warn([
+		"package.config.ts: `external` is deprecated. Use `deps: {neverBundle: [...]}` to mark",
+		"dependencies as external, and `deps: {alwaysBundle: [...]}` to bundle a dependency",
+		"(the callback pattern that filtered entries out of the defaults)."
+	].join("\n"));
+}
+/** @alpha */
+async function loadConfig(options) {
+	let { cwd, pkgPath } = options, configFile = findConfigFile(path.dirname(pkgPath));
+	if (!configFile || !configFile.startsWith(cwd)) return;
+	let mod = await tsImport(pathToFileURL(configFile).toString(), import.meta.url), config = mod?.default || mod || void 0;
+	return config && typeof config == "object" && runLegacyConfigChecks(config), config;
+}
+/**
+* The set of dependency placement rules enforced in `--strict` mode.
+*/
+const dependencyPlacementRules = [
+	{
+		name: "react-is",
+		option: "noReactIsPeerDependency",
+		disallowedIn: ["peerDependencies"],
+		allowedIn: ["dependencies", "devDependencies"]
+	},
+	{
+		name: "@sanity/ui",
+		option: "noSanityUiPeerDependency",
+		disallowedIn: ["peerDependencies"],
+		allowedIn: ["dependencies", "devDependencies"]
+	},
+	{
+		name: "@sanity/icons",
+		option: "noSanityIconsPeerDependency",
+		disallowedIn: ["peerDependencies"],
+		allowedIn: ["dependencies", "devDependencies"]
+	},
+	{
+		name: "sanity",
+		option: "noSanityDependency",
+		disallowedIn: ["dependencies"],
+		allowedIn: ["devDependencies", "peerDependencies"]
+	},
+	{
+		name: "styled-components",
+		option: "noStyledComponentsDependency",
+		disallowedIn: ["dependencies"],
+		allowedIn: ["devDependencies", "peerDependencies"]
+	},
+	{
+		name: "react",
+		option: "noReactDependency",
+		disallowedIn: ["dependencies"],
+		allowedIn: ["devDependencies", "peerDependencies"]
+	},
+	{
+		name: "react-dom",
+		option: "noReactDomDependency",
+		disallowedIn: ["dependencies"],
+		allowedIn: ["devDependencies", "peerDependencies"]
+	},
+	{
+		name: "@types/react",
+		option: "noReactTypesDependency",
+		disallowedIn: ["dependencies"],
+		allowedIn: ["devDependencies", "peerDependencies"],
+		requiredPeerVersion: "*"
+	},
+	{
+		name: "@types/react-dom",
+		option: "noReactDomTypesDependency",
+		disallowedIn: ["dependencies"],
+		allowedIn: ["devDependencies", "peerDependencies"],
+		requiredPeerVersion: "*"
+	},
+	{
+		name: "@types/node",
+		option: "noNodeTypesDependency",
+		disallowedIn: ["dependencies"],
+		allowedIn: ["devDependencies", "peerDependencies"],
+		requiredPeerVersion: "*"
+	},
+	{
+		name: "rxjs",
+		option: "noRxjsPeerDependency",
+		disallowedIn: ["peerDependencies"],
+		allowedIn: ["dependencies", "devDependencies"]
+	},
+	{
+		name: "@sanity/client",
+		option: "noSanityClientPeerDependency",
+		disallowedIn: ["peerDependencies"],
+		allowedIn: ["dependencies", "devDependencies"]
+	}
+];
+function formatFields(fields) {
+	let labels = fields.map((field) => `\`${field}\``);
+	return labels.length <= 1 ? labels.join("") : `${labels.slice(0, -1).join(", ")} or ${labels[labels.length - 1]}`;
+}
+/**
+* Validates that well-known packages are declared in the correct `package.json` dependency
+* fields. Returns `true` if any rule with severity `error` was violated.
+* @internal
+*/
+function checkDependencyPlacement(options) {
+	let { pkg, logger, strictOptions } = options, shouldError = !1, report = (level, message) => {
+		level === "error" ? (shouldError = !0, logger.error(message)) : logger.warn(message);
+	};
+	for (let rule of dependencyPlacementRules) {
+		let level = strictOptions[rule.option];
+		if (level !== "off") {
+			for (let field of rule.disallowedIn) Object.hasOwn(pkg[field] ?? {}, rule.name) && report(level, `package.json: \`${rule.name}\` should not be in \`${field}\`. It should be in ${formatFields(rule.allowedIn)} instead.`);
+			if (rule.requiredPeerVersion !== void 0) {
+				let peerDependencies = pkg.peerDependencies ?? {};
+				Object.hasOwn(peerDependencies, rule.name) && peerDependencies[rule.name] !== rule.requiredPeerVersion && report(level, `package.json: \`${rule.name}\` in \`peerDependencies\` should be set to "${rule.requiredPeerVersion}" (got "${peerDependencies[rule.name]}").`);
+			}
+		}
+	}
+	return shouldError;
+}
+/** @internal */
+function assertLast(a, arr) {
+	let aIdx = arr.indexOf(a);
+	return aIdx === -1 || aIdx === arr.length - 1;
+}
+/** @internal */
+function assertOrder(a, b, arr) {
+	let aIdx = arr.indexOf(a), bIdx = arr.indexOf(b);
+	return aIdx === -1 || bIdx === -1 || aIdx < bIdx;
+}
+function validatePkg(input) {
+	let pkg = parsePackage(input), invalidKey = Object.keys(input).find((key) => {
+		let needle = key.toUpperCase();
+		return _typoMap.has(needle) ? _typoMap.get(needle) !== key : !1;
+	});
+	if (invalidKey) throw TypeError(`
+- package.json: "${invalidKey}" is not a valid key. Did you mean "${_typoMap.get(invalidKey.toUpperCase())}"?`);
+	return pkg;
+}
+/** @internal */
+async function loadPkg(options) {
+	let { pkgPath } = options, raw = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+	return validatePkg(raw), raw;
+}
+/**
+* Helper function to recursively compare export values, excluding source, development, and monorepo conditions
+*/
+function areExportValuesEqual(value1, value2) {
+	if (typeof value1 == "string" && typeof value2 == "string") return value1 === value2;
+	if (typeof value1 != typeof value2) return !1;
+	if (typeof value1 == "object" && value1 && typeof value2 == "object" && value2 && !Array.isArray(value1) && !Array.isArray(value2)) {
+		let obj1 = value1, obj2 = value2, keys1 = Object.keys(obj1).filter((k) => k !== "source" && k !== "development" && k !== "monorepo"), keys2 = Object.keys(obj2).filter((k) => k !== "source" && k !== "development" && k !== "monorepo");
+		if (keys1.length !== keys2.length) return !1;
+		for (let key of keys1) {
+			if (!keys2.includes(key)) return !1;
+			let val1 = obj1[key], val2 = obj2[key];
+			if (val1 === void 0 || val2 === void 0 || !areExportValuesEqual(val1, val2)) return !1;
+		}
+		return !0;
+	}
+	return !1;
+}
+/** @alpha */
+async function loadPkgWithReporting(options) {
+	let { pkgPath, logger, strict, strictOptions } = options;
+	try {
+		let pkg = await loadPkg({ pkgPath }), shouldError = !1;
+		if (strict) {
+			if (strictOptions.preferModuleType !== "off") {
+				if (!pkg.type) {
+					let msg = "package.json: `type` field is missing. Future versions of pkg-utils will require `\"type\": \"module\"`. Consider adding `\"type\": \"module\"` to prepare for this change.";
+					strictOptions.preferModuleType === "error" ? (shouldError = !0, logger.error(msg)) : logger.warn(msg);
+				} else if (pkg.type === "commonjs") {
+					let msg = "package.json: `type` is set to \"commonjs\". Future versions of pkg-utils will require `\"type\": \"module\"`. Consider migrating to ES modules to prepare for this change.";
+					strictOptions.preferModuleType === "error" ? (shouldError = !0, logger.error(msg)) : logger.warn(msg);
+				}
+			}
+			if (strictOptions.noPackageJsonBrowser !== "off" && pkg.browser) {
+				let msg = "package.json: the `browser` field is no longer needed. Use the `browser` condition in `exports` instead for better support across modern bundlers.";
+				strictOptions.noPackageJsonBrowser === "error" ? (shouldError = !0, logger.error(msg)) : logger.warn(msg);
+			}
+			if (strictOptions.noPackageJsonTypesVersions !== "off" && pkg.typesVersions) {
+				let msg = "package.json: the `typesVersions` field is no longer needed. TypeScript has long supported conditional exports and the `types` condition. Remove the `typesVersions` field and use the `types` condition in `exports` instead.";
+				strictOptions.noPackageJsonTypesVersions === "error" ? (shouldError = !0, logger.error(msg)) : logger.warn(msg);
+			}
+			checkDependencyPlacement({
+				pkg,
+				logger,
+				strictOptions
+			}) && (shouldError = !0);
+		}
+		if (pkg.exports) {
+			let _exports = Object.entries(pkg.exports);
+			for (let [expPath, exp] of _exports) {
+				if (typeof exp == "string" || expPath.endsWith(".css") || "svelte" in exp) continue;
+				let keys = Object.keys(exp);
+				exp.types && (shouldError = !0, logger.error(`exports["${expPath}"]: the \`types\` condition shouldn't be used as dts files are generated in such a way that both CJS and ESM is supported`)), exp.module && (shouldError = !0, logger.error(`exports["${expPath}"]: the \`module\` condition shouldn't be used as it's not well supported in all bundlers.`)), exp.development && exp.source && exp.development !== exp.source && (shouldError = !0, logger.error(`exports["${expPath}"]: the \`development\` condition must have the same value as \`source\` when both are present. Expected "${exp.source}" but got "${exp.development}"`)), exp.monorepo && exp.source && exp.monorepo !== exp.source && (shouldError = !0, logger.error(`exports["${expPath}"]: the \`monorepo\` condition must have the same value as \`source\` when both are present. Expected "${exp.source}" but got "${exp.monorepo}"`)), exp.node ? (exp.import && exp.node.import && !assertOrder("node", "import", keys) && (shouldError = !0, logger.error(`exports["${expPath}"]: the \`node\` property should come before the \`import\` property`)), exp.node.module && (shouldError = !0, logger.error(`exports["${expPath}"]: the \`node.module\` condition shouldn't be used as it's not well supported in all bundlers. A better strategy is to refactor the codebase to no longer be vulnerable to the "dual package hazard"`)), !exp.node.source && exp.node.import && (exp.node.require || exp.require) && (exp.node.import.endsWith(".cjs.js") || exp.node.import.endsWith(".cjs.mjs")) && (shouldError = !0, logger.error(`exports["${expPath}"]: the \`node.import\` re-export pattern shouldn't be used as it's not well supported in all bundlers. A better strategy is to refactor the codebase to no longer be vulnerable to the "dual package hazard"`)), exp.require && exp.node.require && exp.require === exp.node.require ? (shouldError = !0, logger.error(`exports["${expPath}"]: the \`node.require\` property isn't necessary as it's identical to \`require\``)) : exp.require && exp.node.require && !assertOrder("node", "require", keys) && (shouldError = !0, logger.error(`exports["${expPath}"]: the \`node\` property should come before the \`require\` property`))) : assertOrder("import", "require", keys) || logger.warn(`exports["${expPath}"]: the \`import\` property should come before the \`require\` property`), assertLast("default", keys) || (shouldError = !0, logger.error(`exports["${expPath}"]: the \`default\` property should be the last property`));
+			}
+		}
+		if (strict && pkg.exports && Object.keys(pkg.exports).length > 0 && Object.entries(pkg.exports).some(([, exp]) => typeof exp == "string" || typeof exp == "object" && "svelte" in exp ? !1 : !!(exp.source || exp.development || exp.monorepo))) if (pkg.publishConfig?.exports) {
+			let publishExports = pkg.publishConfig.exports;
+			for (let exportPath of Object.keys(pkg.exports)) exportPath in publishExports || (shouldError = !0, logger.error(`publishConfig.exports: missing export path "${exportPath}" that exists in exports`));
+			for (let exportPath of Object.keys(publishExports)) exportPath in pkg.exports || (shouldError = !0, logger.error(`publishConfig.exports: unexpected export path "${exportPath}" that does not exist in exports`));
+			for (let [exportPath, exp] of Object.entries(pkg.exports)) {
+				if (typeof exp == "string" || "svelte" in exp) {
+					let publishExp = publishExports[exportPath];
+					typeof publishExp != "string" && (typeof publishExp != "object" || !("svelte" in publishExp)) && (shouldError = !0, logger.error(`publishConfig.exports["${exportPath}"]: should be a string matching exports["${exportPath}"]`));
+					continue;
+				}
+				let publishExp = publishExports[exportPath];
+				if (!publishExp) continue;
+				if (typeof publishExp == "string") {
+					let conditions = Object.keys(exp).filter((k) => k !== "source" && k !== "development" && k !== "monorepo");
+					if (conditions.length !== 1 || conditions[0] !== "default") shouldError = !0, logger.error(`publishConfig.exports["${exportPath}"]: is a string but exports["${exportPath}"] has multiple conditions besides source/development/monorepo: ${conditions.join(", ")}`);
+					else {
+						let expectedValue = exp.default;
+						publishExp !== expectedValue && (shouldError = !0, logger.error(`publishConfig.exports["${exportPath}"]: should be "${expectedValue}" but got "${publishExp}"`));
+					}
+					continue;
+				}
+				if ("svelte" in publishExp) continue;
+				let exportConditions = Object.keys(exp).filter((k) => k !== "source" && k !== "development" && k !== "monorepo"), publishConditions = Object.keys(publishExp);
+				"source" in publishExp && (shouldError = !0, logger.error(`publishConfig.exports["${exportPath}"]: should not contain the \`source\` condition`)), "development" in publishExp && (shouldError = !0, logger.error(`publishConfig.exports["${exportPath}"]: should not contain the \`development\` condition`)), "monorepo" in publishExp && (shouldError = !0, logger.error(`publishConfig.exports["${exportPath}"]: should not contain the \`monorepo\` condition`));
+				for (let condition of exportConditions) condition in publishExp || (shouldError = !0, logger.error(`publishConfig.exports["${exportPath}"]: missing \`${condition}\` condition that exists in exports["${exportPath}"]`));
+				for (let condition of publishConditions) exportConditions.includes(condition) || (shouldError = !0, logger.error(`publishConfig.exports["${exportPath}"]: unexpected \`${condition}\` condition that does not exist in exports["${exportPath}"]`));
+				for (let condition of exportConditions) if (condition in publishExp) {
+					let exportValue = exp[condition], publishValue = publishExp[condition];
+					if (!areExportValuesEqual(exportValue, publishValue)) {
+						let exportValueStr = typeof exportValue == "string" ? exportValue : JSON.stringify(exportValue), publishValueStr = typeof publishValue == "string" ? publishValue : JSON.stringify(publishValue);
+						shouldError = !0, logger.error(`publishConfig.exports["${exportPath}"].${condition}: should be ${exportValueStr} but got ${publishValueStr}`);
+					}
+				}
+			}
+		} else {
+			let msg = "package.json: `publishConfig.exports` is missing. Adding it helps avoid publishing to npm with the `source`, `development`, or `monorepo` condition that points to code that cannot be used by the resolver. See https://tsdown.dev/options/package-exports#dev-exports for more information.";
+			strictOptions.noPublishConfigExports === "error" ? (shouldError = !0, logger.error(msg)) : strictOptions.noPublishConfigExports !== "off" && logger.warn(msg);
+		}
+		return shouldError && process.exit(1), pkg;
+	} catch (err) {
+		if (err instanceof ZodError) for (let issue of err.issues) {
+			if (issue.code === "invalid_type") {
+				logger.error([
+					`\`${formatPath(issue.path)}\` `,
+					`in \`./package.json\` must be of type ${chalk.magenta(issue.expected)} `,
+					`(received ${chalk.magenta(issue.received)})`
+				].join(""));
+				continue;
+			}
+			logger.error(issue);
+		}
+		else logger.error(err);
+		return process.exit(1);
+	}
+}
+function formatPath(segments) {
+	return segments.map((s, idx) => idx === 0 ? s : typeof s == "number" ? `[${s}]` : s.startsWith(".") ? `["${s}"]` : `.${s}`).join("");
+}
+function isPkgConfigPropertyResolver(prop) {
+	return typeof prop == "function";
+}
+/** @internal */
+function resolveConfigProperty(prop, initialValue) {
+	return prop ? isPkgConfigPropertyResolver(prop) ? prop(initialValue) : prop : initialValue;
+}
+/** @public */
+const DEFAULT_BROWSERSLIST_QUERY = config;
+function pathContains(containerPath, itemPath) {
+	return !path.relative(containerPath, itemPath).startsWith("..");
+}
+function findCommonDirPath(filePaths) {
+	let ret;
+	for (let filePath of filePaths) {
+		let dirPath = path.dirname(filePath);
+		if (!ret) {
+			ret = dirPath;
+			continue;
+		}
+		for (; dirPath !== ret;) {
+			if (pathContains(dirPath, ret)) {
+				ret = dirPath;
+				break;
+			}
+			if (dirPath = path.dirname(dirPath), dirPath === ret) break;
+			if (dirPath === ".") return;
+		}
+	}
+	return ret;
+}
+/** Matches the JS output file endings pkg-utils emits (`.js`, `.mjs`, `.cjs`). @internal */
+const fileEnding = /\.[mc]?js$/, pkgExtMap = {
+	commonjs: {
+		commonjs: ".js",
+		esm: ".mjs"
+	},
+	module: {
+		commonjs: ".cjs",
+		esm: ".js"
+	}
+};
+function validateExports(_exports, options) {
+	let { pkg } = options, type = pkg.type || "commonjs", ext = pkgExtMap[type], errors = [];
+	for (let exp of _exports) exp._path === "." && (exp.require && pkg.main && exp.require !== pkg.main && errors.push("package.json: mismatch between \"main\" and \"exports.require\". These must be equal."), exp.import && pkg.module && exp.import !== pkg.module && errors.push("package.json: mismatch between \"module\" and \"exports.import\". These must be equal.")), exp.require && !exp.require.endsWith(ext.commonjs) && errors.push(`package.json with \`type: "${type}"\` - \`exports["${exp._path}"].require\` must end with "${ext.commonjs}"`), exp.import && !exp.import.endsWith(ext.esm) && errors.push(`package.json with \`type: "${type}"\` - \`exports["${exp._path}"].import\` must end with "${ext.esm}"`);
+	return errors;
+}
+function isTruthy$1(value) {
+	return !!value;
+}
+/** @alpha */
+function parseAndValidateExports(options) {
+	let { cwd, pkg, strict, strictOptions, logger } = options, type = pkg.type || "commonjs", errors = [], report = (kind, message) => {
+		kind === "warn" ? logger.warn(message) : errors.push(message);
+	};
+	if (!Array.isArray(pkg.files) && strict && strictOptions.alwaysPackageJsonFiles !== "off" && report(strictOptions.alwaysPackageJsonFiles, "package.json: `files` should be used over `.npmignore`"), pkg.source) {
+		if (strict && pkg.exports?.["."] && typeof pkg.exports["."] == "object" && "source" in pkg.exports["."] && pkg.exports["."].source === pkg.source) errors.push("package.json: the \"source\" property can be removed, as it is equal to exports[\".\"].source.");
+		else if (!pkg.exports && pkg.main) {
+			let extMap = pkgExtMap[type], importExport = pkg.main.replace(fileEnding, extMap.esm), requireExport = pkg.main.replace(fileEnding, extMap.commonjs), defaultExport = pkg.main.replace(fileEnding, ".js"), maybeBrowserCondition = [];
+			if (pkg.browser) {
+				let browserConditions = [];
+				pkg.module && pkg.browser?.[pkg.module] ? browserConditions.push(`      "import": ${JSON.stringify(pkg.browser[pkg.module].replace(fileEnding, extMap.esm))}`) : pkg.browser?.[pkg.main] && browserConditions.push(`      "import": ${JSON.stringify(pkg.browser[pkg.main].replace(fileEnding, extMap.esm))}`), pkg.browser?.[pkg.main] && browserConditions.push(`      "require": ${JSON.stringify(pkg.browser[pkg.main].replace(fileEnding, extMap.commonjs))}`), browserConditions.length && maybeBrowserCondition.push("    \"browser\": {", `      "source": ${JSON.stringify(pkg.browser?.[pkg.source] || pkg.source)},`, ...browserConditions, "    }");
+			}
+			errors.push(...[
+				"package.json: `exports` are missing, it should be:",
+				"\"exports\": {",
+				"  \".\": {",
+				`    "source": ${JSON.stringify(pkg.source)},`,
+				...maybeBrowserCondition.length > 0 ? maybeBrowserCondition : [],
+				type === "commonjs" && `    "import": ${JSON.stringify(importExport)},`,
+				type === "module" && `    "require": ${JSON.stringify(requireExport)},`,
+				`    "default": ${JSON.stringify(defaultExport)}`,
+				"  },",
+				"  \"./package.json\": \"./package.json\"",
+				"}"
+			].filter(isTruthy$1));
+		}
+	}
+	if (errors.length) throw Error("\n- " + errors.join("\n- "));
+	if (!pkg.exports) throw Error("\n- " + [
+		"package.json: `exports` are missing, please set a minimal configuration, for example:",
+		"\"exports\": {",
+		"  \".\": {",
+		"    \"source\": \"./src/index.js\",",
+		"    \"default\": \"./dist/index.js\"",
+		"  },",
+		"  \"./package.json\": \"./package.json\"",
+		"}"
+	].join("\n- "));
+	let _exports = parseExports({ pkg });
+	strict && strictOptions.noPackageJsonTypings !== "off" && "typings" in pkg && report(strictOptions.noPackageJsonTypings, "package.json: `typings` should be `types`"), strict && strictOptions.alwaysPackageJsonTypes !== "off" && !pkg.types && typeof pkg.exports?.["."] == "object" && "source" in pkg.exports["."] && pkg.exports["."].source?.endsWith(".ts") && report(strictOptions.alwaysPackageJsonTypes, "package.json: `types` must be declared for the npm listing to show as a TypeScript module."), strict && !pkg.exports["./package.json"] && errors.push("package.json: `exports[\"./package.json\"] must be declared.");
+	for (let [exportPath, exportEntry] of Object.entries(pkg.exports)) if (exportPath.endsWith(".json") || typeof exportEntry == "string" && exportEntry.endsWith(".json")) exportPath === "./package.json" && exportEntry !== "./package.json" && errors.push("package.json: `exports[\"./package.json\"]` must be \"./package.json\".");
+	else if (exportPath.endsWith(".css")) if (typeof exportEntry == "string") existsSync(resolve(cwd, exportEntry)) || errors.push(`package.json: \`exports[${JSON.stringify(exportPath)}]\`: file does not exist.`);
+	else if (isRecord(exportEntry)) for (let [condition, target] of Object.entries(exportEntry)) typeof target != "string" && errors.push(`package.json: \`exports[${JSON.stringify(exportPath)}][${JSON.stringify(condition)}]\`: must be a string path.`);
+	else errors.push(`package.json: \`exports[${JSON.stringify(exportPath)}]\`: must be a string path or an object of export conditions.`);
+	else if (!(isRecord(exportEntry) && "svelte" in exportEntry)) if (isPkgExport(exportEntry)) {
+		let exp = {
+			_exported: !0,
+			_path: exportPath,
+			...exportEntry
+		};
+		if (!exp.default) {
+			let fallback = type === "module" ? exp.import : exp.require;
+			fallback && (exp.default = fallback);
+		}
+		!exp.require && type === "commonjs" && exp.default && (exp.require = exp.default), !exp.import && type === "module" && exp.default && (exp.import = exp.default), exportPath === "." && (exportEntry.require && pkg.main && exportEntry.require !== pkg.main && errors.push("package.json: mismatch between \"main\" and \"exports.require\". These must be equal."), exportEntry.import && pkg.module && exportEntry.import !== pkg.module && errors.push("package.json: mismatch between \"module\" and \"exports.import\" These must be equal."));
+	} else isRecord(exportEntry) || errors.push("package.json: exports must be an object");
+	if (errors.push(...validateExports(_exports, { pkg })), errors.length) throw Error("\n- " + errors.join("\n- "));
+	return _exports;
+}
+function isPkgExport(value) {
+	return isRecord(value) && "source" in value && typeof value.source == "string";
+}
+/** @internal */
+async function loadTSConfig(options) {
+	let { cwd, tsconfigPath } = options, configPath = ts.findConfigFile(cwd, ts.sys.fileExists, tsconfigPath);
+	if (!configPath) return;
+	let configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+	return ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd);
+}
+function resolveBrowserTarget(versions) {
+	let target = versions.filter((version) => version.startsWith("chrome") || version.startsWith("edge") || version.startsWith("firefox") || version.startsWith("ios") || version.startsWith("safari") || version.startsWith("opera"));
+	if (target.length !== 0) return target;
+}
+function resolveNodeTarget(versions) {
+	let target = versions.filter((version) => version.startsWith("node"));
+	if (target.length !== 0) return target;
+}
+var strict_exports = /* @__PURE__ */ __exportAll({ parseStrictOptions: () => parseStrictOptions });
+const toggle = z.union([
+	z.literal("error"),
+	z.literal("warn"),
+	z.literal("off")
+]), strictOptions = z.object({
+	noPackageJsonTypings: toggle.default("error"),
+	noImplicitSideEffects: toggle.default("warn"),
+	noImplicitBrowsersList: toggle.default("warn"),
+	alwaysPackageJsonTypes: toggle.default("error"),
+	alwaysPackageJsonFiles: toggle.default("error"),
+	noCheckTypes: toggle.default("warn"),
+	noPackageJsonBrowser: toggle.default("warn"),
+	noPackageJsonTypesVersions: toggle.default("warn"),
+	preferModuleType: toggle.default("warn"),
+	noPublishConfigExports: toggle.default("warn"),
+	noReactIsPeerDependency: toggle.default("error"),
+	noSanityUiPeerDependency: toggle.default("error"),
+	noSanityIconsPeerDependency: toggle.default("error"),
+	noSanityDependency: toggle.default("error"),
+	noStyledComponentsDependency: toggle.default("error"),
+	noReactDependency: toggle.default("error"),
+	noReactDomDependency: toggle.default("error"),
+	noReactTypesDependency: toggle.default("error"),
+	noReactDomTypesDependency: toggle.default("error"),
+	noNodeTypesDependency: toggle.default("error"),
+	noRxjsPeerDependency: toggle.default("error"),
+	noSanityClientPeerDependency: toggle.default("error")
+}).strict(), validationSchema = z.object({ strictOptions: strictOptions.default({}) });
+/** @alpha */
+function parseStrictOptions(input) {
+	return validationSchema.parse({ strictOptions: input }, { errorMap }).strictOptions;
+}
+function isTruthy(value) {
+	return !!value;
+}
+async function resolveBuildContext(options) {
+	let { config, cwd, emitDeclarationOnly = !1, logger, pkg, strict, tsconfig: tsconfigPath } = options, tsconfig = await loadTSConfig({
+		cwd,
+		tsconfigPath
+	}), strictOptions = parseStrictOptions(config?.strictOptions ?? {}), browserslist = pkg.browserslist;
+	if (!browserslist) {
+		if (strict && strictOptions.noImplicitBrowsersList !== "off") {
+			if (strictOptions.noImplicitBrowsersList === "error") throw Error("\n- package.json: \"browserslist\" is missing, set it to `\"browserslist\": \"extends @sanity/browserslist-config\"`");
+			logger.warn("Could not detect a `browserslist` property in `package.json`, using default configuration. Add `\"browserslist\": \"extends @sanity/browserslist-config\"` to silence this warning.");
+		}
+		browserslist = DEFAULT_BROWSERSLIST_QUERY;
+	}
+	let targetVersions = browserslistToEsbuild(browserslist);
+	if (strict && strictOptions.noImplicitSideEffects !== "off" && pkg.sideEffects === void 0) {
+		let msg = "package.json: `sideEffects` is missing, see https://webpack.js.org/guides/tree-shaking/#clarifying-tree-shaking-and-sideeffects for how to define `sideEffects`";
+		if (strictOptions.noImplicitSideEffects === "error") throw Error(msg);
+		logger.warn(msg);
+	}
+	let nodeTarget = resolveNodeTarget(targetVersions), webTarget = resolveBrowserTarget(targetVersions);
+	if (!nodeTarget) throw Error("no matching `node` target");
+	if (!webTarget) throw Error("no matching `web` target");
+	let target = {
+		"*": webTarget.concat(nodeTarget),
+		browser: webTarget,
+		node: nodeTarget
+	}, parsedExports = parseAndValidateExports({
+		cwd,
+		pkg,
+		strict,
+		strictOptions,
+		logger
+	}).reduce((acc, { _path: exportPath, ...exportEntry }) => Object.assign(acc, { [exportPath]: exportEntry }), {}), exports = resolveConfigProperty(config?.exports, parsedExports), parsedExternal = [...pkg.dependencies ? Object.keys(pkg.dependencies) : [], ...pkg.peerDependencies ? Object.keys(pkg.peerDependencies) : []], external = config && Array.isArray(config.external) ? [...parsedExternal, ...config.external] : resolveConfigProperty(config?.external, parsedExternal), packagePattern = (name) => RegExp(`^${escapeRegExp(name)}(/|$)`), neverBundleAdditions = external.filter((name) => !parsedExternal.includes(name)).map(packagePattern);
+	neverBundleAdditions.push(packagePattern(pkg.name));
+	let alwaysBundleNames = parsedExternal.filter((name) => !external.includes(name)), deps = mergeDeps(config?.deps, {
+		neverBundle: neverBundleAdditions,
+		alwaysBundle: alwaysBundleNames.map(packagePattern)
+	}), externalWithTypes = /* @__PURE__ */ new Set([
+		pkg.name,
+		...external,
+		...external.map(transformPackageName)
+	]), bundledPackages = [
+		...(pkg.devDependencies ? Object.keys(pkg.devDependencies) : []).filter((_) => !externalWithTypes.has(_)),
+		...alwaysBundleNames,
+		...Array.isArray(config?.deps?.alwaysBundle) ? config.deps.alwaysBundle.filter((entry) => typeof entry == "string") : typeof config?.deps?.alwaysBundle == "string" ? [config.deps.alwaysBundle] : []
+	], commonDistPath = findCommonDirPath(Object.values(exports).flatMap((exportEntry) => [
+		exportEntry.import,
+		exportEntry.require,
+		exportEntry.browser?.import,
+		exportEntry.browser?.require,
+		exportEntry.node?.source && exportEntry.node.import,
+		exportEntry.node?.source && exportEntry.node.require
+	].filter(isTruthy)).map((p) => path.resolve(cwd, p)));
+	if (commonDistPath === cwd) throw Error("all output files must share a common parent directory which is not the root package directory");
+	if (commonDistPath && !pathContains(cwd, commonDistPath)) throw Error("all output files must be located within the package");
+	let configDistPath = config?.dist ? path.resolve(cwd, config.dist) : void 0;
+	if (configDistPath && commonDistPath && configDistPath !== commonDistPath && !pathContains(configDistPath, commonDistPath)) throw logger.log(`did you mean to configure \`dist: './${path.relative(cwd, commonDistPath)}'\`?`), Error("all output files must be located with the configured `dist` path");
+	let distPath = configDistPath || commonDistPath;
+	if (!distPath) throw Error("could not detect `dist` path");
+	return {
+		config,
+		cwd,
+		deps,
+		distPath,
+		emitDeclarationOnly,
+		exports,
+		external,
+		bundledPackages,
+		logger,
+		pkg,
+		runtime: config?.runtime ?? "*",
+		strict,
+		target,
+		ts: {
+			config: tsconfig,
+			configPath: tsconfigPath
+		}
+	};
+}
+/**
+* Merges the `deps` additions derived from the deprecated `external` option (and the
+* self-reference external) into the userland `deps` passthrough. Array forms concatenate, a
+* userland function is composed with the derived additions (the additions carry pipeline
+* invariants like the self-reference external, which must survive customization — the same
+* composition `@sanity/tsdown-config` applies to its `/^node:/` default), and a blanket
+* `true` (externalize all of `node_modules`) wins as the broadest request.
+* @internal Exported for tests.
+*/
+function mergeDeps(configDeps, additions) {
+	let userNeverBundle = configDeps?.neverBundle, neverBundle;
+	if (userNeverBundle === void 0) neverBundle = additions.neverBundle;
+	else if (userNeverBundle === !0) neverBundle = userNeverBundle;
+	else if (typeof userNeverBundle == "function") {
+		let patterns = additions.neverBundle;
+		neverBundle = (id, importer, isResolved) => patterns.some((pattern) => typeof pattern == "string" ? pattern === id : pattern.test(id)) || userNeverBundle(id, importer, isResolved);
+	} else neverBundle = Array.isArray(userNeverBundle) ? [...additions.neverBundle, ...userNeverBundle] : [...additions.neverBundle, userNeverBundle];
+	let userAlwaysBundle = configDeps?.alwaysBundle, alwaysBundle;
+	return alwaysBundle = userAlwaysBundle === void 0 ? additions.alwaysBundle.length ? additions.alwaysBundle : void 0 : typeof userAlwaysBundle == "function" ? userAlwaysBundle : Array.isArray(userAlwaysBundle) ? [...additions.alwaysBundle, ...userAlwaysBundle] : [...additions.alwaysBundle, userAlwaysBundle], {
+		...configDeps,
+		neverBundle,
+		...alwaysBundle === void 0 ? {} : { alwaysBundle }
+	};
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function transformPackageName(packageName) {
+	if (packageName.startsWith("@types/")) return packageName;
+	if (packageName.startsWith("@")) {
+		let [scope, name] = packageName.split("/");
+		return `@types/${scope?.slice(1)}__${name}`;
+	}
+	return `@types/${packageName}`;
+}
+export { loadPkgWithReporting as a, pkgExtMap as i, strict_exports as n, loadConfig as o, fileEnding as r, resolveBuildContext as t };
+
+//# sourceMappingURL=resolveBuildContext-CbwvYKj1.js.map