@bamboocss/config 1.11.1 → 1.11.3

package/dist/index.mjs

@@ -1,630 +1,561 @@
-import {
-  diffConfigs
-} from "./chunk-6TQW6KOI.mjs";
-import {
-  SEP,
-  formatPath,
-  getReferences,
-  isTokenReference,
-  isValidToken,
-  mergeConfigs,
-  mergeHooks,
-  serializeTokenValue
-} from "./chunk-RIBK22OM.mjs";
-import {
-  resolveTsPathPattern
-} from "./chunk-RPIVZP2I.mjs";
-
-// src/bundle-config.ts
+import { t as diffConfigs } from "./diff-config-KDQWMnQN.mjs";
+import { resolveTsPathPattern } from "./resolve-ts-path-pattern.mjs";
+import { a as isValidToken, i as isTokenReference, n as formatPath, o as serializeTokenValue, r as getReferences, s as mergeHooks, t as mergeConfigs } from "./merge-config-DI__LOWx.mjs";
 import { logger } from "@bamboocss/logger";
-import { BambooError as BambooError2 } from "@bamboocss/shared";
+import { BAMBOO_CONFIG_NAME, BambooError, getUnit, isObject, isString, omit, parseJson, pick, stringifyJson, traverse, walkObject } from "@bamboocss/shared";
 import { bundleNRequire } from "bundle-n-require";
-
-// src/find-config.ts
-import { BambooError } from "@bamboocss/shared";
 import findUp from "escalade/sync";
-import { resolve } from "path";
-
-// src/is-bamboo-config.ts
-var configName = "bamboo";
-var bambooConfigFiles = /* @__PURE__ */ new Set([
-  `${configName}.config.ts`,
-  `${configName}.config.js`,
-  `${configName}.config.mts`,
-  `${configName}.config.mjs`,
-  `${configName}.config.cts`,
-  `${configName}.config.cjs`
+import path, { resolve } from "path";
+import fs from "fs";
+import ts from "typescript";
+import { preset as presetBase } from "@bamboocss/preset-base";
+import { preset as presetBamboo } from "@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`
 ]);
-var isBambooConfig = (file) => bambooConfigFiles.has(file);
-
-// src/find-config.ts
+const isBambooConfig = (file) => bambooConfigFiles.has(file);
+//#endregion
+//#region src/find-config.ts
 function findConfig(options) {
-  const { cwd = process.cwd(), file } = options;
-  if (file) {
-    return resolve(cwd, file);
-  }
-  const configPath = findUp(cwd, (_dir, paths) => paths.find(isBambooConfig));
-  if (!configPath) {
-    throw new BambooError(
-      "CONFIG_NOT_FOUND",
-      `Cannot find config file \`bamboo.config.{ts,js,mjs,mts}\`. Did you forget to run \`bamboo init\`?`
-    );
-  }
-  return configPath;
+	const { cwd = process.cwd(), file } = options;
+	if (file) return resolve(cwd, file);
+	const configPath = findUp(cwd, (_dir, paths) => paths.find(isBambooConfig));
+	if (!configPath) throw new BambooError("CONFIG_NOT_FOUND", `Cannot find config file \`bamboo.config.{ts,js,mjs,mts}\`. Did you forget to run \`bamboo init\`?`);
+	return configPath;
 }
-
-// src/bundle-config.ts
+//#endregion
+//#region src/bundle-config.ts
 async function bundle(filepath, cwd) {
-  const { mod, dependencies } = await bundleNRequire(filepath, {
-    cwd,
-    interopDefault: true
-  });
-  const config = mod?.default ?? mod;
-  return {
-    config,
-    dependencies
-  };
+	const { mod, dependencies } = await bundleNRequire(filepath, {
+		cwd,
+		interopDefault: true
+	});
+	return {
+		config: mod?.default ?? mod,
+		dependencies
+	};
 }
 async function bundleConfig(options) {
-  const { cwd, file } = options;
-  const filePath = findConfig({ cwd, file });
-  logger.debug("config:path", filePath);
-  const result = await bundle(filePath, cwd);
-  if (typeof result.config !== "object") {
-    throw new BambooError2("CONFIG_ERROR", `\u{1F4A5} Config must export or return an object.`);
-  }
-  result.config.outdir ??= "styled-system";
-  result.config.validation ??= "warn";
-  return {
-    ...result,
-    config: result.config,
-    path: filePath
-  };
+	const { cwd, file } = options;
+	const filePath = findConfig({
+		cwd,
+		file
+	});
+	logger.debug("config:path", filePath);
+	const result = await bundle(filePath, cwd);
+	if (typeof result.config !== "object") throw new 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
+	};
 }
-
-// src/get-mod-deps.ts
-import fs from "fs";
-import path from "path";
-import ts from "typescript";
-
-// src/ts-config-paths.ts
-import { resolve as resolve2 } from "path";
+//#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) => resolve2(baseUrl, relativePath))
-    });
-  }
-  return resolved;
+	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) => resolve(baseUrl, relativePath))
+		});
+	}
+	return resolved;
 }
 function getPrefixLength(pattern) {
-  const prefixLength = pattern.indexOf("*");
-  return pattern.substr(0, prefixLength).length;
+	const prefixLength = pattern.indexOf("*");
+	return pattern.substr(0, prefixLength).length;
 }
 function escapeStringRegexp(string) {
-  return string.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/-/g, "\\x2d");
+	return string.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/-/g, "\\x2d");
 }
-
-// src/get-mod-deps.ts
-var jsExtensions = [".js", ".cjs", ".mjs"];
-var jsResolutionOrder = ["", ".js", ".cjs", ".mjs", ".ts", ".cts", ".mts", ".jsx", ".tsx"];
-var tsResolutionOrder = ["", ".ts", ".cts", ".mts", ".tsx", ".js", ".cjs", ".mjs", ".jsx"];
+//#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.existsSync(full) && fs.statSync(full).isFile()) {
-      return full;
-    }
-  }
-  for (const ext of extensions) {
-    const full = `${file}/index${ext}`;
-    if (fs.existsSync(full)) {
-      return full;
-    }
-  }
-  return null;
+	for (const ext of extensions) {
+		const full = `${file}${ext}`;
+		if (fs.existsSync(full) && fs.statSync(full).isFile()) return full;
+	}
+	for (const ext of extensions) {
+		const full = `${file}/index${ext}`;
+		if (fs.existsSync(full)) return full;
+	}
+	return null;
 }
-var importRegex = /import[\s\S]*?['"](.{3,}?)['"]/gi;
-var importFromRegex = /import[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi;
-var requireRegex = /require\(['"`](.+)['"`]\)/gi;
-var exportRegex = /export[\s\S]*from[\s\S]*?['"](.{3,}?)['"]/gi;
+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.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.readFileSync(absoluteFile, "utf-8");
-  const fileDeps = [
-    ...contents.matchAll(importRegex),
-    ...contents.matchAll(importFromRegex),
-    ...contents.matchAll(requireRegex),
-    ...contents.matchAll(exportRegex)
-  ];
-  if (!fileDeps.length) return;
-  const nextOpts = {
-    // Resolve new base for new imports/requires
-    cwd: path.dirname(absoluteFile),
-    ext: path.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 = ts.resolveModuleName(mod, absoluteFile, compilerOptions, ts.sys).resolvedModule;
-      if (found && found.extension.endsWith("ts")) {
-        getDeps(Object.assign({}, nextOpts, { filename: found.resolvedFileName }));
-        return;
-      }
-      if (!opts.pathMappings) return;
-      const filename2 = resolveTsPathPattern(opts.pathMappings, mod);
-      if (!filename2) return;
-      getDeps(Object.assign({}, nextOpts, { filename: filename2 }), mod);
-    } catch {
-    }
-  });
+	const { filename, seen } = opts;
+	const { moduleResolution: _, ...compilerOptions } = opts.compilerOptions ?? {};
+	const absoluteFile = resolveWithExtension(path.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.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.dirname(absoluteFile),
+		ext: path.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 = ts.resolveModuleName(mod, absoluteFile, compilerOptions, ts.sys).resolvedModule;
+			if (found && found.extension.endsWith("ts")) {
+				getDeps(Object.assign({}, nextOpts, { filename: found.resolvedFileName }));
+				return;
+			}
+			if (!opts.pathMappings) return;
+			const filename = 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.extname(filePath),
-    cwd: path.dirname(filePath),
-    seen: deps,
-    baseUrl: tsOptions.baseUrl,
-    pathMappings: tsOptions.pathMappings ?? [],
-    foundModuleAliases,
-    compilerOptions
-  });
-  return { deps, aliases: foundModuleAliases };
+	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.extname(filePath),
+		cwd: path.dirname(filePath),
+		seen: deps,
+		baseUrl: tsOptions.baseUrl,
+		pathMappings: tsOptions.pathMappings ?? [],
+		foundModuleAliases,
+		compilerOptions
+	});
+	return {
+		deps,
+		aliases: foundModuleAliases
+	};
 }
-
-// src/get-resolved-config.ts
-import { omit, pick, traverse } from "@bamboocss/shared";
-var hookUtils = {
-  omit,
-  pick,
-  traverse
+//#endregion
+//#region src/get-resolved-config.ts
+const hookUtils$1 = {
+	omit,
+	pick,
+	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") {
-        const presetModule = await bundle(subPreset, cwd);
-        presetConfig = presetModule.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
-        });
-        if (resolvedPreset !== void 0) {
-          presetConfig = resolvedPreset;
-        }
-      }
-      stack.push(presetConfig);
-    }
-    configs.unshift(current);
-  }
-  const merged = mergeConfigs(configs);
-  merged.presets = configs.slice(0, -1);
-  return merged;
+	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 = mergeConfigs(configs);
+	merged.presets = configs.slice(0, -1);
+	return merged;
 }
-
-// src/resolve-config.ts
-import { logger as logger3 } from "@bamboocss/logger";
-import { BAMBOO_CONFIG_NAME, omit as omit2, parseJson, pick as pick2, stringifyJson, traverse as traverse2 } from "@bamboocss/shared";
-
-// src/bundled-preset.ts
-import { preset as presetBase } from "@bamboocss/preset-base";
-import { preset as presetBamboo } from "@bamboocss/preset-bamboo";
-var bundledPresets = {
-  "@bamboocss/preset-base": presetBase,
-  "@bamboocss/preset-bamboo": presetBamboo,
-  "@bamboocss/dev/presets": presetBamboo
+//#endregion
+//#region src/bundled-preset.ts
+const bundledPresets = {
+	"@bamboocss/preset-base": presetBase,
+	"@bamboocss/preset-bamboo": presetBamboo,
+	"@bamboocss/dev/presets": presetBamboo
 };
-var bundledPresetsNames = Object.keys(bundledPresets);
-var isBundledPreset = (preset) => bundledPresetsNames.includes(preset);
-var getBundledPreset = (preset) => {
-  return typeof preset === "string" && isBundledPreset(preset) ? bundledPresets[preset] : void 0;
+const bundledPresetsNames = Object.keys(bundledPresets);
+const isBundledPreset = (preset) => bundledPresetsNames.includes(preset);
+const getBundledPreset = (preset) => {
+	return typeof preset === "string" && isBundledPreset(preset) ? bundledPresets[preset] : void 0;
 };
-
-// src/validate-config.ts
-import { logger as logger2 } from "@bamboocss/logger";
-import { BambooError as BambooError3 } from "@bamboocss/shared";
-
-// src/validation/validate-artifact.ts
-var 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-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}`);
+	});
 };
-
-// src/validation/validate-breakpoints.ts
-import { getUnit } from "@bamboocss/shared";
-var validateBreakpoints = (breakpoints, addError) => {
-  if (!breakpoints) return;
-  const units = /* @__PURE__ */ new Set();
-  const values = Object.values(breakpoints);
-  for (const value of values) {
-    const unit = 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-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 = getUnit(value) ?? "px";
+		units.add(unit);
+	}
+	if (units.size > 1) addError("breakpoints", `All breakpoints must use the same unit: \`${values.join(", ")}\``);
 };
-
-// src/validation/validate-condition.ts
-import { isString } from "@bamboocss/shared";
-var 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) {
-      const nested = validateObjectCondition(value, addError);
-      if (nested.hasSlot) hasSlot = true;
-    }
-  }
-  return { hasSlot };
+//#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 };
 };
-var validateConditions = (conditions, addError) => {
-  if (!conditions) return;
-  Object.values(conditions).forEach((condition) => {
-    if (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`);
-    }
-  });
+const validateConditions = (conditions, addError) => {
+	if (!conditions) return;
+	Object.values(conditions).forEach((condition) => {
+		if (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`);
+	});
 };
-
-// src/validation/validate-patterns.ts
-var validatePatterns = (patterns, names) => {
-  if (!patterns) return;
-  Object.keys(patterns).forEach((patternName) => {
-    names.patterns.add(patternName);
-  });
+//#endregion
+//#region src/validation/validate-patterns.ts
+const validatePatterns = (patterns, names) => {
+	if (!patterns) return;
+	Object.keys(patterns).forEach((patternName) => {
+		names.patterns.add(patternName);
+	});
 };
-
-// src/validation/validate-recipes.ts
-var 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-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;
 };
-
-// src/validation/validate-tokens.ts
-import { isObject, walkObject } from "@bamboocss/shared";
-
-// src/validation/validate-token-references.ts
-var validateTokenReferences = (props) => {
-  const { valueAtPath, refsByPath, addError, typeByPath } = props;
-  refsByPath.forEach((refs, path2) => {
-    if (refs.has(path2)) {
-      addError("tokens", `Self token reference: \`${path2}\``);
-    }
-    const stack = [path2];
-    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(path2);
-        addError("tokens", `Missing token: \`${currentPath}\` used in \`theme.${configKey}.${path2}\``);
-      }
-      if (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 (path2 === transitiveDep) {
-          addError(
-            "tokens",
-            `Circular token reference: \`${transitiveDep}\` -> \`${currentPath}\` -> ... -> \`${path2}\``
-          );
-          break;
-        }
-        stack.push(transitiveDep);
-      }
-    }
-  });
+//#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 (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);
+			}
+		}
+	});
 };
-
-// src/validation/validate-tokens.ts
-var 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();
-    walkObject(
-      theme.tokens,
-      (value, paths) => {
-        const path2 = paths.join(SEP);
-        tokenNames.add(path2);
-        tokenPaths.add(path2);
-        valueAtPath.set(path2, value);
-        if (path2.includes("DEFAULT")) {
-          valueAtPath.set(path2.replace(SEP + "DEFAULT", ""), value);
-        }
-      },
-      {
-        stop: isValidToken
-      }
-    );
-    tokenPaths.forEach((path2) => {
-      const itemValue = valueAtPath.get(path2);
-      const formattedPath = formatPath(path2);
-      typeByPath.set(formattedPath, "tokens");
-      if (!isValidToken(itemValue)) {
-        addError("tokens", `Token must contain 'value': \`theme.tokens.${formattedPath}\``);
-        return;
-      }
-      if (path2.includes(" ")) {
-        addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
-        return;
-      }
-      const valueStr = serializeTokenValue(itemValue.value || itemValue);
-      if (isTokenReference(valueStr)) {
-        refsByPath.set(formattedPath, /* @__PURE__ */ new Set([]));
-      }
-      const references = refsByPath.get(formattedPath);
-      if (!references) return;
-      getReferences(valueStr).forEach((reference) => {
-        references.add(reference);
-      });
-    });
-  }
-  if (theme.semanticTokens) {
-    const tokenPaths = /* @__PURE__ */ new Set();
-    walkObject(
-      theme.semanticTokens,
-      (value, paths) => {
-        const path2 = paths.join(SEP);
-        semanticTokenNames.add(path2);
-        valueAtPath.set(path2, value);
-        tokenPaths.add(path2);
-        if (path2.includes("DEFAULT")) {
-          valueAtPath.set(path2.replace(SEP + "DEFAULT", ""), value);
-        }
-        if (!isValidToken(value)) return;
-        walkObject(value, (itemValue, paths2) => {
-          const valuePath = paths2.join(SEP);
-          const formattedPath = formatPath(path2);
-          typeByPath.set(formattedPath, "semanticTokens");
-          const fullPath = formattedPath + "." + paths2.join(SEP);
-          if (valuePath.includes("value" + SEP + "value")) {
-            addError("tokens", `You used \`value\` twice resulting in an invalid token \`theme.tokens.${fullPath}\``);
-          }
-          const valueStr = serializeTokenValue(itemValue.value || itemValue);
-          if (isTokenReference(valueStr)) {
-            if (!refsByPath.has(formattedPath)) {
-              refsByPath.set(formattedPath, /* @__PURE__ */ new Set());
-            }
-            const references = refsByPath.get(formattedPath);
-            if (!references) return;
-            getReferences(valueStr).forEach((reference) => {
-              references.add(reference);
-            });
-          }
-        });
-      },
-      {
-        stop: isValidToken
-      }
-    );
-    tokenPaths.forEach((path2) => {
-      const formattedPath = formatPath(path2);
-      const value = valueAtPath.get(path2);
-      if (path2.includes(" ")) {
-        addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
-        return;
-      }
-      if (!isObject(value) && !path2.includes("value")) {
-        addError("tokens", `Token must contain 'value': \`theme.semanticTokens.${formattedPath}\``);
-      }
-    });
-  }
-  validateTokenReferences({ valueAtPath, refsByPath, addError, typeByPath });
+//#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();
+		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: isValidToken });
+		tokenPaths.forEach((path) => {
+			const itemValue = valueAtPath.get(path);
+			const formattedPath = formatPath(path);
+			typeByPath.set(formattedPath, "tokens");
+			if (!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 = serializeTokenValue(itemValue.value || itemValue);
+			if (isTokenReference(valueStr)) refsByPath.set(formattedPath, /* @__PURE__ */ new Set([]));
+			const references = refsByPath.get(formattedPath);
+			if (!references) return;
+			getReferences(valueStr).forEach((reference) => {
+				references.add(reference);
+			});
+		});
+	}
+	if (theme.semanticTokens) {
+		const tokenPaths = /* @__PURE__ */ new Set();
+		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 (!isValidToken(value)) return;
+			walkObject(value, (itemValue, paths) => {
+				const valuePath = paths.join(".");
+				const formattedPath = 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 = serializeTokenValue(itemValue.value || itemValue);
+				if (isTokenReference(valueStr)) {
+					if (!refsByPath.has(formattedPath)) refsByPath.set(formattedPath, /* @__PURE__ */ new Set());
+					const references = refsByPath.get(formattedPath);
+					if (!references) return;
+					getReferences(valueStr).forEach((reference) => {
+						references.add(reference);
+					});
+				}
+			});
+		}, { stop: isValidToken });
+		tokenPaths.forEach((path) => {
+			const formattedPath = formatPath(path);
+			const value = valueAtPath.get(path);
+			if (path.includes(" ")) {
+				addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
+				return;
+			}
+			if (!isObject(value) && !path.includes("value")) addError("tokens", `Token must contain 'value': \`theme.semanticTokens.${formattedPath}\``);
+		});
+	}
+	validateTokenReferences({
+		valueAtPath,
+		refsByPath,
+		addError,
+		typeByPath
+	});
 };
-
-// src/validate-config.ts
-var 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 = `\u26A0\uFE0F Invalid config:
-${Array.from(warnings).map((err) => "- " + err).join("\n")}
-`;
-    if (config.validation === "error") {
-      throw new BambooError3("CONFIG_ERROR", errors);
-    }
-    logger2.warn("config", errors);
-    return warnings;
-  }
+//#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 BambooError("CONFIG_ERROR", errors);
+		logger.warn("config", errors);
+		return warnings;
+	}
 };
-
-// src/resolve-config.ts
-var hookUtils2 = {
-  omit: omit2,
-  pick: pick2,
-  traverse: traverse2
+//#endregion
+//#region src/resolve-config.ts
+const hookUtils = {
+	omit,
+	pick,
+	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(presetBase);
-  }
-  if (result.config.presets) {
-    result.config.presets.forEach((preset) => {
-      presets.add(getBundledPreset(preset) ?? preset);
-    });
-  } else if (!result.config.eject) {
-    presets.add(presetBamboo);
-  }
-  result.config.presets = Array.from(presets);
-  const userConfig = result.config;
-  const pluginHooks = userConfig.plugins ?? [];
-  if (userConfig.hooks) {
-    pluginHooks.push({ name: BAMBOO_CONFIG_NAME, hooks: userConfig.hooks });
-  }
-  const earlyHooks = mergeHooks(pluginHooks);
-  const mergedConfig = await getResolvedConfig(result.config, cwd, earlyHooks);
-  const hooks = mergedConfig.hooks ?? {};
-  if (mergedConfig.logLevel) {
-    logger3.level = mergedConfig.logLevel;
-  }
-  validateConfig(mergedConfig);
-  const loadConfigResult = {
-    ...result,
-    config: mergedConfig
-  };
-  if (hooks["config:resolved"]) {
-    const result2 = await hooks["config:resolved"]({
-      config: loadConfigResult.config,
-      path: loadConfigResult.path,
-      dependencies: loadConfigResult.dependencies,
-      utils: hookUtils2
-    });
-    if (result2) {
-      loadConfigResult.config = result2;
-    }
-  }
-  const serialized = stringifyJson(
-    Object.assign({}, loadConfigResult.config, { name: BAMBOO_CONFIG_NAME, presets: [] })
-  );
-  const deserialize = () => parseJson(serialized);
-  return { ...loadConfigResult, serialized, deserialize, hooks };
+	const presets = /* @__PURE__ */ new Set();
+	if (!result.config.eject) presets.add(presetBase);
+	if (result.config.presets) result.config.presets.forEach((preset) => {
+		presets.add(getBundledPreset(preset) ?? preset);
+	});
+	else if (!result.config.eject) presets.add(presetBamboo);
+	result.config.presets = Array.from(presets);
+	const userConfig = result.config;
+	const pluginHooks = userConfig.plugins ?? [];
+	if (userConfig.hooks) pluginHooks.push({
+		name: BAMBOO_CONFIG_NAME,
+		hooks: userConfig.hooks
+	});
+	const earlyHooks = mergeHooks(pluginHooks);
+	const mergedConfig = await getResolvedConfig(result.config, cwd, earlyHooks);
+	const hooks = mergedConfig.hooks ?? {};
+	if (mergedConfig.logLevel) 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 = stringifyJson(Object.assign({}, loadConfigResult.config, {
+		name: BAMBOO_CONFIG_NAME,
+		presets: []
+	}));
+	const deserialize = () => parseJson(serialized);
+	return {
+		...loadConfigResult,
+		serialized,
+		deserialize,
+		hooks
+	};
 }
-
-// src/load-config.ts
+//#endregion
+//#region src/load-config.ts
+/**
+* Find, load and resolve the final config (including presets)
+*/
 async function loadConfig(options) {
-  const result = await bundleConfig(options);
-  return resolveConfig(result, options.cwd);
+	return resolveConfig(await bundleConfig(options), options.cwd);
 }
-export {
-  bundleConfig,
-  convertTsPathsToRegexes,
-  diffConfigs,
-  findConfig,
-  getConfigDependencies,
-  getResolvedConfig,
-  loadConfig,
-  mergeConfigs,
-  mergeHooks,
-  resolveConfig
-};
+//#endregion
+export { bundleConfig, convertTsPathsToRegexes, diffConfigs, findConfig, getConfigDependencies, getResolvedConfig, loadConfig, mergeConfigs, mergeHooks, resolveConfig };