@bamboocss/config 1.11.1 → 1.11.2

package/dist/index.cjs

@@ -0,0 +1,575 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_diff_config = require("./diff-config-Co_3mDXE.cjs");
+const require_resolve_ts_path_pattern = require("./resolve-ts-path-pattern.cjs");
+const require_merge_config = require("./merge-config-CcNpHJit.cjs");
+let _bamboocss_logger = require("@bamboocss/logger");
+let _bamboocss_shared = require("@bamboocss/shared");
+let bundle_n_require = require("bundle-n-require");
+let escalade_sync = require("escalade/sync");
+escalade_sync = require_diff_config.__toESM(escalade_sync);
+let path = require("path");
+path = require_diff_config.__toESM(path);
+let fs = require("fs");
+fs = require_diff_config.__toESM(fs);
+let typescript = require("typescript");
+typescript = require_diff_config.__toESM(typescript);
+let _bamboocss_preset_base = require("@bamboocss/preset-base");
+let _bamboocss_preset_bamboo = require("@bamboocss/preset-bamboo");
+//#region src/is-bamboo-config.ts
+const configName = "bamboo";
+const bambooConfigFiles = new Set([
+	`${configName}.config.ts`,
+	`${configName}.config.js`,
+	`${configName}.config.mts`,
+	`${configName}.config.mjs`,
+	`${configName}.config.cts`,
+	`${configName}.config.cjs`
+]);
+const isBambooConfig = (file) => bambooConfigFiles.has(file);
+//#endregion
+//#region src/find-config.ts
+function findConfig(options) {
+	const { cwd = process.cwd(), file } = options;
+	if (file) return (0, path.resolve)(cwd, file);
+	const configPath = (0, escalade_sync.default)(cwd, (_dir, paths) => paths.find(isBambooConfig));
+	if (!configPath) throw new _bamboocss_shared.BambooError("CONFIG_NOT_FOUND", `Cannot find config file \`bamboo.config.{ts,js,mjs,mts}\`. Did you forget to run \`bamboo init\`?`);
+	return configPath;
+}
+//#endregion
+//#region src/bundle-config.ts
+async function bundle(filepath, cwd) {
+	const { mod, dependencies } = await (0, bundle_n_require.bundleNRequire)(filepath, {
+		cwd,
+		interopDefault: true
+	});
+	return {
+		config: mod?.default ?? mod,
+		dependencies
+	};
+}
+async function bundleConfig(options) {
+	const { cwd, file } = options;
+	const filePath = findConfig({
+		cwd,
+		file
+	});
+	_bamboocss_logger.logger.debug("config:path", filePath);
+	const result = await bundle(filePath, cwd);
+	if (typeof result.config !== "object") throw new _bamboocss_shared.BambooError("CONFIG_ERROR", `💥 Config must export or return an object.`);
+	result.config.outdir ??= "styled-system";
+	result.config.validation ??= "warn";
+	return {
+		...result,
+		config: result.config,
+		path: filePath
+	};
+}
+//#endregion
+//#region src/ts-config-paths.ts
+/**
+* @see https://github.com/aleclarson/vite-tsconfig-paths/blob/e8f0acf7adfcfbf77edbe937f64b4e5d39557ad0/src/mappings.ts
+*/
+function convertTsPathsToRegexes(paths, baseUrl) {
+	const sortedPatterns = Object.keys(paths).sort((a, b) => getPrefixLength(b) - getPrefixLength(a));
+	const resolved = [];
+	for (let pattern of sortedPatterns) {
+		const relativePaths = paths[pattern];
+		pattern = escapeStringRegexp(pattern).replace(/\*/g, "(.+)");
+		resolved.push({
+			pattern: new RegExp("^" + pattern + "$"),
+			paths: relativePaths.map((relativePath) => (0, path.resolve)(baseUrl, relativePath))
+		});
+	}
+	return resolved;
+}
+function getPrefixLength(pattern) {
+	const prefixLength = pattern.indexOf("*");
+	return pattern.substr(0, prefixLength).length;
+}
+function escapeStringRegexp(string) {
+	return string.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/-/g, "\\x2d");
+}
+//#endregion
+//#region src/get-mod-deps.ts
+const jsExtensions = [
+	".js",
+	".cjs",
+	".mjs"
+];
+const jsResolutionOrder = [
+	"",
+	".js",
+	".cjs",
+	".mjs",
+	".ts",
+	".cts",
+	".mts",
+	".jsx",
+	".tsx"
+];
+const tsResolutionOrder = [
+	"",
+	".ts",
+	".cts",
+	".mts",
+	".tsx",
+	".js",
+	".cjs",
+	".mjs",
+	".jsx"
+];
+function resolveWithExtension(file, extensions) {
+	for (const ext of extensions) {
+		const full = `${file}${ext}`;
+		if (fs.default.existsSync(full) && fs.default.statSync(full).isFile()) return full;
+	}
+	for (const ext of extensions) {
+		const full = `${file}/index${ext}`;
+		if (fs.default.existsSync(full)) return full;
+	}
+	return null;
+}
+const importRegex = /import[\s\S]*?['"](.{3,}?)['"]/gi;
+const importFromRegex = /import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi;
+const requireRegex = /require\(['"`](.+)['"`]\)/gi;
+const exportRegex = /export[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi;
+function getDeps(opts, fromAlias) {
+	const { filename, seen } = opts;
+	const { moduleResolution: _, ...compilerOptions } = opts.compilerOptions ?? {};
+	const absoluteFile = resolveWithExtension(path.default.resolve(opts.cwd, filename), jsExtensions.includes(opts.ext) ? jsResolutionOrder : tsResolutionOrder);
+	if (absoluteFile === null) return;
+	if (fromAlias) opts.foundModuleAliases.set(fromAlias, absoluteFile);
+	if (seen.size > 1 && seen.has(absoluteFile)) return;
+	seen.add(absoluteFile);
+	const contents = fs.default.readFileSync(absoluteFile, "utf-8");
+	const fileDeps = [
+		...contents.matchAll(importRegex),
+		...contents.matchAll(importFromRegex),
+		...contents.matchAll(requireRegex),
+		...contents.matchAll(exportRegex)
+	];
+	if (!fileDeps.length) return;
+	const nextOpts = {
+		cwd: path.default.dirname(absoluteFile),
+		ext: path.default.extname(absoluteFile),
+		seen,
+		baseUrl: opts.baseUrl,
+		pathMappings: opts.pathMappings,
+		foundModuleAliases: opts.foundModuleAliases
+	};
+	fileDeps.forEach((match) => {
+		const mod = match[1];
+		if (mod[0] === ".") {
+			getDeps(Object.assign({}, nextOpts, { filename: mod }));
+			return;
+		}
+		try {
+			const found = typescript.default.resolveModuleName(mod, absoluteFile, compilerOptions, typescript.default.sys).resolvedModule;
+			if (found && found.extension.endsWith("ts")) {
+				getDeps(Object.assign({}, nextOpts, { filename: found.resolvedFileName }));
+				return;
+			}
+			if (!opts.pathMappings) return;
+			const filename = require_resolve_ts_path_pattern.resolveTsPathPattern(opts.pathMappings, mod);
+			if (!filename) return;
+			getDeps(Object.assign({}, nextOpts, { filename }), mod);
+		} catch {}
+	});
+}
+function getConfigDependencies(filePath, tsOptions = { pathMappings: [] }, compilerOptions) {
+	if (filePath === null) return {
+		deps: /* @__PURE__ */ new Set(),
+		aliases: /* @__PURE__ */ new Map()
+	};
+	const foundModuleAliases = /* @__PURE__ */ new Map();
+	const deps = /* @__PURE__ */ new Set();
+	deps.add(filePath);
+	getDeps({
+		filename: filePath,
+		ext: path.default.extname(filePath),
+		cwd: path.default.dirname(filePath),
+		seen: deps,
+		baseUrl: tsOptions.baseUrl,
+		pathMappings: tsOptions.pathMappings ?? [],
+		foundModuleAliases,
+		compilerOptions
+	});
+	return {
+		deps,
+		aliases: foundModuleAliases
+	};
+}
+//#endregion
+//#region src/get-resolved-config.ts
+const hookUtils$1 = {
+	omit: _bamboocss_shared.omit,
+	pick: _bamboocss_shared.pick,
+	traverse: _bamboocss_shared.traverse
+};
+/**
+* Recursively merge all presets into a single config (depth-first using stack)
+*/
+async function getResolvedConfig(config, cwd, hooks) {
+	const stack = [config];
+	const configs = [];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		const subPresets = current.presets ?? [];
+		for (const subPreset of subPresets) {
+			let presetConfig;
+			let presetName;
+			if (typeof subPreset === "string") {
+				presetConfig = (await bundle(subPreset, cwd)).config;
+				presetName = subPreset;
+			} else {
+				presetConfig = await subPreset;
+				presetName = presetConfig.name || "unknown-preset";
+			}
+			if (hooks?.["preset:resolved"]) {
+				const resolvedPreset = await hooks["preset:resolved"]({
+					preset: presetConfig,
+					name: presetName,
+					utils: hookUtils$1
+				});
+				if (resolvedPreset !== void 0) presetConfig = resolvedPreset;
+			}
+			stack.push(presetConfig);
+		}
+		configs.unshift(current);
+	}
+	const merged = require_merge_config.mergeConfigs(configs);
+	merged.presets = configs.slice(0, -1);
+	return merged;
+}
+//#endregion
+//#region src/bundled-preset.ts
+const bundledPresets = {
+	"@bamboocss/preset-base": _bamboocss_preset_base.preset,
+	"@bamboocss/preset-bamboo": _bamboocss_preset_bamboo.preset,
+	"@bamboocss/dev/presets": _bamboocss_preset_bamboo.preset
+};
+const bundledPresetsNames = Object.keys(bundledPresets);
+const isBundledPreset = (preset) => bundledPresetsNames.includes(preset);
+const getBundledPreset = (preset) => {
+	return typeof preset === "string" && isBundledPreset(preset) ? bundledPresets[preset] : void 0;
+};
+//#endregion
+//#region src/validation/validate-artifact.ts
+const validateArtifactNames = (names, addError) => {
+	names.recipes.forEach((recipeName) => {
+		if (names.slotRecipes.has(recipeName)) addError("recipes", `This recipe name is already used in \`theme.slotRecipes\`: ${recipeName}`);
+		if (names.patterns.has(recipeName)) addError("recipes", `This recipe name is already used in \`patterns\`: \`${recipeName}\``);
+	});
+	names.slotRecipes.forEach((recipeName) => {
+		if (names.patterns.has(recipeName)) addError("recipes", `This recipe name is already used in \`patterns\`: ${recipeName}`);
+	});
+};
+//#endregion
+//#region src/validation/validate-breakpoints.ts
+const validateBreakpoints = (breakpoints, addError) => {
+	if (!breakpoints) return;
+	const units = /* @__PURE__ */ new Set();
+	const values = Object.values(breakpoints);
+	for (const value of values) {
+		const unit = (0, _bamboocss_shared.getUnit)(value) ?? "px";
+		units.add(unit);
+	}
+	if (units.size > 1) addError("breakpoints", `All breakpoints must use the same unit: \`${values.join(", ")}\``);
+};
+//#endregion
+//#region src/validation/validate-condition.ts
+const validateObjectCondition = (obj, addError) => {
+	let hasSlot = false;
+	for (const [key, value] of Object.entries(obj)) {
+		if (!key.startsWith("@") && !key.includes("&")) addError("conditions", `Selectors should contain the \`&\` character: \`${key}\``);
+		if (value === "@slot") {
+			hasSlot = true;
+			continue;
+		}
+		if (typeof value === "string") {
+			addError("conditions", `Object condition leaves must be the literal string \`'@slot'\`, got \`${JSON.stringify(value)}\` at \`${key}\``);
+			continue;
+		}
+		if (typeof value === "object" && value !== null) {
+			if (validateObjectCondition(value, addError).hasSlot) hasSlot = true;
+		}
+	}
+	return { hasSlot };
+};
+const validateConditions = (conditions, addError) => {
+	if (!conditions) return;
+	Object.values(conditions).forEach((condition) => {
+		if ((0, _bamboocss_shared.isString)(condition)) {
+			if (!condition.startsWith("@") && !condition.includes("&")) addError("conditions", `Selectors should contain the \`&\` character: \`${condition}\``);
+			return;
+		}
+		if (Array.isArray(condition)) {
+			condition.forEach((c) => {
+				if (!c.startsWith("@") && !c.includes("&")) addError("conditions", `Selectors should contain the \`&\` character: \`${c}\``);
+			});
+			return;
+		}
+		const { hasSlot } = validateObjectCondition(condition, addError);
+		if (!hasSlot) addError("conditions", `Object conditions must contain at least one \`'@slot'\` marker`);
+	});
+};
+//#endregion
+//#region src/validation/validate-patterns.ts
+const validatePatterns = (patterns, names) => {
+	if (!patterns) return;
+	Object.keys(patterns).forEach((patternName) => {
+		names.patterns.add(patternName);
+	});
+};
+//#endregion
+//#region src/validation/validate-recipes.ts
+const validateRecipes = (options) => {
+	const { config: { theme }, artifacts } = options;
+	if (!theme) return;
+	if (theme.recipes) Object.keys(theme.recipes).forEach((recipeName) => {
+		artifacts.recipes.add(recipeName);
+	});
+	if (theme.slotRecipes) Object.keys(theme.slotRecipes).forEach((recipeName) => {
+		artifacts.slotRecipes.add(recipeName);
+	});
+	return artifacts;
+};
+//#endregion
+//#region src/validation/validate-token-references.ts
+const validateTokenReferences = (props) => {
+	const { valueAtPath, refsByPath, addError, typeByPath } = props;
+	refsByPath.forEach((refs, path) => {
+		if (refs.has(path)) addError("tokens", `Self token reference: \`${path}\``);
+		const stack = [path];
+		while (stack.length > 0) {
+			let currentPath = stack.pop();
+			if (currentPath.includes("/")) {
+				const [tokenPath] = currentPath.split("/");
+				currentPath = tokenPath;
+			}
+			const value = valueAtPath.get(currentPath);
+			if (!value) {
+				const configKey = typeByPath.get(path);
+				addError("tokens", `Missing token: \`${currentPath}\` used in \`theme.${configKey}.${path}\``);
+			}
+			if (require_merge_config.isTokenReference(value) && !refsByPath.has(value)) addError("tokens", `Unknown token reference: \`${currentPath}\` used in \`${value}\``);
+			const deps = refsByPath.get(currentPath);
+			if (!deps) continue;
+			for (const transitiveDep of deps) {
+				if (path === transitiveDep) {
+					addError("tokens", `Circular token reference: \`${transitiveDep}\` -> \`${currentPath}\` -> ... -> \`${path}\``);
+					break;
+				}
+				stack.push(transitiveDep);
+			}
+		}
+	});
+};
+//#endregion
+//#region src/validation/validate-tokens.ts
+const validateTokens = (options) => {
+	const { config: { theme }, tokens, addError } = options;
+	if (!theme) return;
+	const { tokenNames, semanticTokenNames, valueAtPath, refsByPath, typeByPath } = tokens;
+	if (theme.tokens) {
+		const tokenPaths = /* @__PURE__ */ new Set();
+		(0, _bamboocss_shared.walkObject)(theme.tokens, (value, paths) => {
+			const path = paths.join(".");
+			tokenNames.add(path);
+			tokenPaths.add(path);
+			valueAtPath.set(path, value);
+			if (path.includes("DEFAULT")) valueAtPath.set(path.replace(".DEFAULT", ""), value);
+		}, { stop: require_merge_config.isValidToken });
+		tokenPaths.forEach((path) => {
+			const itemValue = valueAtPath.get(path);
+			const formattedPath = require_merge_config.formatPath(path);
+			typeByPath.set(formattedPath, "tokens");
+			if (!require_merge_config.isValidToken(itemValue)) {
+				addError("tokens", `Token must contain 'value': \`theme.tokens.${formattedPath}\``);
+				return;
+			}
+			if (path.includes(" ")) {
+				addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
+				return;
+			}
+			const valueStr = require_merge_config.serializeTokenValue(itemValue.value || itemValue);
+			if (require_merge_config.isTokenReference(valueStr)) refsByPath.set(formattedPath, /* @__PURE__ */ new Set([]));
+			const references = refsByPath.get(formattedPath);
+			if (!references) return;
+			require_merge_config.getReferences(valueStr).forEach((reference) => {
+				references.add(reference);
+			});
+		});
+	}
+	if (theme.semanticTokens) {
+		const tokenPaths = /* @__PURE__ */ new Set();
+		(0, _bamboocss_shared.walkObject)(theme.semanticTokens, (value, paths) => {
+			const path = paths.join(".");
+			semanticTokenNames.add(path);
+			valueAtPath.set(path, value);
+			tokenPaths.add(path);
+			if (path.includes("DEFAULT")) valueAtPath.set(path.replace(".DEFAULT", ""), value);
+			if (!require_merge_config.isValidToken(value)) return;
+			(0, _bamboocss_shared.walkObject)(value, (itemValue, paths) => {
+				const valuePath = paths.join(".");
+				const formattedPath = require_merge_config.formatPath(path);
+				typeByPath.set(formattedPath, "semanticTokens");
+				const fullPath = formattedPath + "." + paths.join(".");
+				if (valuePath.includes("value.value")) addError("tokens", `You used \`value\` twice resulting in an invalid token \`theme.tokens.${fullPath}\``);
+				const valueStr = require_merge_config.serializeTokenValue(itemValue.value || itemValue);
+				if (require_merge_config.isTokenReference(valueStr)) {
+					if (!refsByPath.has(formattedPath)) refsByPath.set(formattedPath, /* @__PURE__ */ new Set());
+					const references = refsByPath.get(formattedPath);
+					if (!references) return;
+					require_merge_config.getReferences(valueStr).forEach((reference) => {
+						references.add(reference);
+					});
+				}
+			});
+		}, { stop: require_merge_config.isValidToken });
+		tokenPaths.forEach((path) => {
+			const formattedPath = require_merge_config.formatPath(path);
+			const value = valueAtPath.get(path);
+			if (path.includes(" ")) {
+				addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
+				return;
+			}
+			if (!(0, _bamboocss_shared.isObject)(value) && !path.includes("value")) addError("tokens", `Token must contain 'value': \`theme.semanticTokens.${formattedPath}\``);
+		});
+	}
+	validateTokenReferences({
+		valueAtPath,
+		refsByPath,
+		addError,
+		typeByPath
+	});
+};
+//#endregion
+//#region src/validate-config.ts
+/**
+* Validate the config
+* - Check for duplicate between token & semanticTokens names
+* - Check for duplicate between recipes/patterns/slots names
+* - Check for token / semanticTokens paths (must end/contain 'value')
+* - Check for self/circular token references
+* - Check for missing tokens references
+* - Check for conditions selectors (must contain '&')
+* - Check for breakpoints units (must be the same)
+*/
+const validateConfig = (config) => {
+	if (config.validation === "none") return;
+	const warnings = /* @__PURE__ */ new Set();
+	const addError = (scope, message) => {
+		warnings.add(`[${scope}] ` + message);
+	};
+	validateBreakpoints(config.theme?.breakpoints, addError);
+	validateConditions(config.conditions, addError);
+	const artifacts = {
+		recipes: /* @__PURE__ */ new Set(),
+		slotRecipes: /* @__PURE__ */ new Set(),
+		patterns: /* @__PURE__ */ new Set()
+	};
+	const tokens = {
+		tokenNames: /* @__PURE__ */ new Set(),
+		semanticTokenNames: /* @__PURE__ */ new Set(),
+		valueAtPath: /* @__PURE__ */ new Map(),
+		refsByPath: /* @__PURE__ */ new Map(),
+		typeByPath: /* @__PURE__ */ new Map()
+	};
+	if (config.theme) {
+		validateTokens({
+			config,
+			tokens,
+			addError
+		});
+		validateRecipes({
+			config,
+			tokens,
+			artifacts,
+			addError
+		});
+	}
+	validatePatterns(config.patterns, artifacts);
+	validateArtifactNames(artifacts, addError);
+	if (warnings.size) {
+		const errors = `⚠️ Invalid config:\n${Array.from(warnings).map((err) => "- " + err).join("\n")}\n`;
+		if (config.validation === "error") throw new _bamboocss_shared.BambooError("CONFIG_ERROR", errors);
+		_bamboocss_logger.logger.warn("config", errors);
+		return warnings;
+	}
+};
+//#endregion
+//#region src/resolve-config.ts
+const hookUtils = {
+	omit: _bamboocss_shared.omit,
+	pick: _bamboocss_shared.pick,
+	traverse: _bamboocss_shared.traverse
+};
+/**
+* Resolve the final config (including presets)
+* @bamboocss/preset-base: ALWAYS included if NOT using eject: true
+* @bamboocss/preset-bamboo: only included by default if no presets
+*/
+async function resolveConfig(result, cwd) {
+	const presets = /* @__PURE__ */ new Set();
+	if (!result.config.eject) presets.add(_bamboocss_preset_base.preset);
+	if (result.config.presets) result.config.presets.forEach((preset) => {
+		presets.add(getBundledPreset(preset) ?? preset);
+	});
+	else if (!result.config.eject) presets.add(_bamboocss_preset_bamboo.preset);
+	result.config.presets = Array.from(presets);
+	const userConfig = result.config;
+	const pluginHooks = userConfig.plugins ?? [];
+	if (userConfig.hooks) pluginHooks.push({
+		name: _bamboocss_shared.BAMBOO_CONFIG_NAME,
+		hooks: userConfig.hooks
+	});
+	const earlyHooks = require_merge_config.mergeHooks(pluginHooks);
+	const mergedConfig = await getResolvedConfig(result.config, cwd, earlyHooks);
+	const hooks = mergedConfig.hooks ?? {};
+	if (mergedConfig.logLevel) _bamboocss_logger.logger.level = mergedConfig.logLevel;
+	validateConfig(mergedConfig);
+	const loadConfigResult = {
+		...result,
+		config: mergedConfig
+	};
+	if (hooks["config:resolved"]) {
+		const result = await hooks["config:resolved"]({
+			config: loadConfigResult.config,
+			path: loadConfigResult.path,
+			dependencies: loadConfigResult.dependencies,
+			utils: hookUtils
+		});
+		if (result) loadConfigResult.config = result;
+	}
+	const serialized = (0, _bamboocss_shared.stringifyJson)(Object.assign({}, loadConfigResult.config, {
+		name: _bamboocss_shared.BAMBOO_CONFIG_NAME,
+		presets: []
+	}));
+	const deserialize = () => (0, _bamboocss_shared.parseJson)(serialized);
+	return {
+		...loadConfigResult,
+		serialized,
+		deserialize,
+		hooks
+	};
+}
+//#endregion
+//#region src/load-config.ts
+/**
+* Find, load and resolve the final config (including presets)
+*/
+async function loadConfig(options) {
+	return resolveConfig(await bundleConfig(options), options.cwd);
+}
+//#endregion
+exports.bundleConfig = bundleConfig;
+exports.convertTsPathsToRegexes = convertTsPathsToRegexes;
+exports.diffConfigs = require_diff_config.diffConfigs;
+exports.findConfig = findConfig;
+exports.getConfigDependencies = getConfigDependencies;
+exports.getResolvedConfig = getResolvedConfig;
+exports.loadConfig = loadConfig;
+exports.mergeConfigs = require_merge_config.mergeConfigs;
+exports.mergeHooks = require_merge_config.mergeHooks;
+exports.resolveConfig = resolveConfig;

package/dist/index.d.cts

@@ -0,0 +1,84 @@
+import { diffConfigs } from "./diff-config.cjs";
+import { n as convertTsPathsToRegexes, t as PathMapping } from "./ts-config-paths-wVx39QZ0.cjs";
+import { n as mergeHooks, t as mergeConfigs } from "./merge-config-DVOlBQJY.cjs";
+import { BambooHooks, Config, ConfigTsOptions, LoadConfigResult as LoadConfigResult$1 } from "@bamboocss/types";
+import { CompilerOptions, TypeAcquisition } from "typescript";
+
+//#region src/types.d.ts
+interface ConfigFileOptions {
+  cwd: string;
+  file?: string;
+}
+interface BundleConfigResult<T = Config> {
+  config: T;
+  dependencies: string[];
+  path: string;
+}
+//#endregion
+//#region src/bundle-config.d.ts
+declare function bundleConfig(options: ConfigFileOptions): Promise<BundleConfigResult>;
+//#endregion
+//#region src/find-config.d.ts
+declare function findConfig(options: Partial<ConfigFileOptions>): string;
+//#endregion
+//#region ../../node_modules/.pnpm/pkg-types@2.3.0/node_modules/pkg-types/dist/index.d.mts
+type StripEnums<T extends Record<string, any>> = { [K in keyof T]: T[K] extends boolean ? T[K] : T[K] extends string ? T[K] : T[K] extends object ? T[K] : T[K] extends Array<any> ? T[K] : T[K] extends undefined ? undefined : any };
+interface TSConfig {
+  compilerOptions?: StripEnums<CompilerOptions>;
+  exclude?: string[];
+  compileOnSave?: boolean;
+  extends?: string | string[];
+  files?: string[];
+  include?: string[];
+  typeAcquisition?: TypeAcquisition;
+  references?: {
+    path: string;
+  }[];
+}
+/**
+ * Defines a TSConfig structure.
+ * @param tsconfig - The contents of `tsconfig.json` as an object. See {@link TSConfig}.
+ * @returns the same `tsconfig.json` object.
+ */
+//#endregion
+//#region src/get-mod-deps.d.ts
+interface GetDepsOptions {
+  filename: string;
+  ext: string;
+  cwd: string;
+  seen: Set<string>;
+  baseUrl: string | undefined;
+  pathMappings: PathMapping[];
+  foundModuleAliases: Map<string, string>;
+  compilerOptions?: TSConfig['compilerOptions'];
+}
+declare function getConfigDependencies(filePath: string, tsOptions?: ConfigTsOptions, compilerOptions?: TSConfig['compilerOptions']): {
+  deps: Set<string>;
+  aliases: Map<string, string>;
+};
+//#endregion
+//#region src/get-resolved-config.d.ts
+type Extendable<T> = T & {
+  extend?: T;
+};
+type ExtendableConfig = Extendable<Config>;
+/**
+ * Recursively merge all presets into a single config (depth-first using stack)
+ */
+declare function getResolvedConfig(config: ExtendableConfig, cwd: string, hooks?: Partial<BambooHooks>): Promise<Config>;
+//#endregion
+//#region src/load-config.d.ts
+/**
+ * Find, load and resolve the final config (including presets)
+ */
+declare function loadConfig(options: ConfigFileOptions): Promise<LoadConfigResult>;
+//#endregion
+//#region src/resolve-config.d.ts
+/**
+ * Resolve the final config (including presets)
+ * @bamboocss/preset-base: ALWAYS included if NOT using eject: true
+ * @bamboocss/preset-bamboo: only included by default if no presets
+ */
+declare function resolveConfig(result: BundleConfigResult, cwd: string): Promise<LoadConfigResult$1>;
+//#endregion
+export { type BundleConfigResult, type GetDepsOptions, bundleConfig, convertTsPathsToRegexes, diffConfigs, findConfig, getConfigDependencies, getResolvedConfig, loadConfig, mergeConfigs, mergeHooks, resolveConfig };