@bamboocss/config 1.30.1 → 1.31.0

package/dist/index.cjs

@@ -28,14 +28,14 @@ let escalade_sync = require("escalade/sync");
 escalade_sync = __toESM(escalade_sync);
 let path = require("path");
 path = __toESM(path);
+let _bamboocss_preset_base = require("@bamboocss/preset-base");
+let _bamboocss_preset_bamboo = require("@bamboocss/preset-bamboo");
 let microdiff = require("microdiff");
 microdiff = __toESM(microdiff);
 let fs = require("fs");
 fs = __toESM(fs);
 let typescript = require("typescript");
 typescript = __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([
@@ -86,6 +86,25 @@ async function bundleConfig(options) {
 	};
 }
 //#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;
+};
+/**
+* What `presets` loads when a config does not list any.
+*
+* Exported so a config that adds a preset can keep them without restating them:
+* `presets: [...defaultPresets, myPreset]`. Spread it — the array is shared.
+*/
+const defaultPresets = [_bamboocss_preset_base.preset, _bamboocss_preset_bamboo.preset];
+//#endregion
 //#region src/create-matcher.ts
 /**
 * Acts like a .gitignore matcher
@@ -505,18 +524,35 @@ const tryCatch = (name, fn) => {
 };
 //#endregion
 //#region src/validation/utils.ts
-const REFERENCE_REGEX = /({([^}]*)})/g;
-const curlyBracketRegex = /[{}]/g;
+/**
+* A reference to another token: `token(colors.red.300)`.
+*
+* Deliberately a copy of the regex in `@bamboocss/token-dictionary`, which this package does not
+* depend on. The two must agree: validation is what reports a missing or circular reference, so a
+* spelling only the dictionary understands is one this never checks — which is silence, not an
+* error, and exactly what a spelling change here is most likely to cause.
+*/
+const REFERENCE_REGEX = /token\(([^(),]+)\)/g;
 const isValidToken = (token) => (0, _bamboocss_shared.isObject)(token) && Object.hasOwnProperty.call(token, "value");
-const isTokenReference = (value) => typeof value === "string" && REFERENCE_REGEX.test(value);
+const isTokenReference = (value) => typeof value === "string" && getReferences(value).length > 0;
+/**
+* The retired curly reference — `{colors.red.300}`, or `{$spacing-2}` under a custom
+* `formatTokenName`. A copy of the regex in `@bamboocss/token-dictionary`, which this package
+* does not depend on.
+*
+* Reported here as well as there because a *token* value carrying one is the worse case: the
+* text is emitted into the stylesheet rather than dropped, and validation is the only thing that
+* can name which token it came from.
+*/
+const CURLY_REFERENCE = /\{[^{}\s:;"']+\}/;
+const findCurlyReference = (value) => value.includes("{") ? CURLY_REFERENCE.exec(value)?.[0] ?? void 0 : void 0;
+/** The retired `token(path, fallback)` form. See `findCurlyReference` for why these fail. */
+const FALLBACK_REFERENCE = /token\([^(),]+,[^()]*\)/;
+const findFallbackReference = (value) => value.includes("token(") ? FALLBACK_REFERENCE.exec(value)?.[0] ?? void 0 : void 0;
 const formatPath = (path) => path;
 function getReferences(value) {
 	if (typeof value !== "string") return [];
-	const matches = value.match(REFERENCE_REGEX);
-	if (!matches) return [];
-	return matches.map((match) => match.replace(curlyBracketRegex, "")).map((value) => {
-		return value.trim().split("/")[0];
-	});
+	return [...value.matchAll(REFERENCE_REGEX)].map((match) => match[1].trim().split("/")[0]).filter(Boolean);
 }
 const serializeTokenValue = (value) => {
 	if ((0, _bamboocss_shared.isString)(value)) return value;
@@ -573,6 +609,46 @@ const tokenKeys = [
 	"deprecated"
 ];
 /**
+* Options whose scalar form is shorthand for setting every member of their object form.
+*
+* `hash: true` says both `cssVar` and `className`; `prefix: 'bb'` says both; `preflight: true`
+* says "on, with the defaults". Expanding them is what lets the object forms compose: a preset
+* that sets `prefix.className` and an app that sets `prefix.cssVar` should end up with both,
+* and before this the app's object replaced the preset's wholesale — silently, since the two
+* name different members. `hash`'s members are optional, so writing the partial form that
+* triggered it is the natural thing to do.
+*
+* `preflight: false` has no object form — there is no member meaning "off" — so it stays a
+* scalar and wins outright when it is the value the winning config states.
+*/
+const SCALAR_SHORTHANDS = {
+	hash: (value) => typeof value === "boolean" ? {
+		cssVar: value,
+		className: value
+	} : value,
+	prefix: (value) => typeof value === "string" ? {
+		cssVar: value,
+		className: value
+	} : value,
+	preflight: (value) => value === true ? {} : value
+};
+/**
+* Merge one of those, winner-first per member.
+*
+* `records` arrives in precedence order — the user's config, then each preset — which is the
+* order `assign` wants, since it only fills keys the target does not already have.
+*/
+function mergeScalarShorthand(key, records) {
+	const normalize = SCALAR_SHORTHANDS[key];
+	const values = records.map((record) => record[key]).filter((value) => value !== void 0);
+	if (!values.length) return void 0;
+	if (values[0] === false) return false;
+	const objects = values.map(normalize).filter((value) => value !== null && typeof value === "object");
+	if (!objects.length) return values[0];
+	const merged = objects.reduce((acc, object) => (0, _bamboocss_shared.assign)(acc, object), {});
+	return isEmptyObject(merged) ? values[0] : merged;
+}
+/**
 * Merge all configs into a single config
 */
 function mergeConfigs(configs) {
@@ -583,17 +659,27 @@ function mergeConfigs(configs) {
 		hooks: userConfig.hooks
 	});
 	const reversed = Array.from(configs).reverse();
+	const theme = mergeExtensions(reversed.map((config) => config.theme ?? {}));
+	const themeVariants = mergeExtensions(reversed.map((config) => config.theme?.variants ?? {}));
+	if (isEmptyObject(themeVariants)) delete theme.variants;
+	else theme.variants = themeVariants;
+	const global = compact({
+		css: mergeExtensions(reversed.map((config) => config.global?.css ?? {})),
+		vars: mergeExtensions(reversed.map((config) => config.global?.vars ?? {})),
+		fontface: mergeExtensions(reversed.map((config) => config.global?.fontface ?? {})),
+		positionTry: mergeExtensions(reversed.map((config) => config.global?.positionTry ?? {}))
+	});
 	const withoutEmpty = compact((0, _bamboocss_shared.assign)({
 		conditions: mergeExtensions(reversed.map((config) => config.conditions ?? {})),
-		theme: mergeExtensions(reversed.map((config) => config.theme ?? {})),
+		theme,
 		patterns: mergeExtensions(reversed.map((config) => config.patterns ?? {})),
 		utilities: mergeExtensions(reversed.map((config) => config.utilities ?? {})),
-		globalCss: mergeExtensions(reversed.map((config) => config.globalCss ?? {})),
-		globalVars: mergeExtensions(reversed.map((config) => config.globalVars ?? {})),
-		globalFontface: mergeExtensions(reversed.map((config) => config.globalFontface ?? {})),
-		globalPositionTry: mergeExtensions(reversed.map((config) => config.globalPositionTry ?? {})),
+		global,
 		staticCss: mergeExtensions(reversed.map((config) => config.staticCss ?? {})),
-		themes: mergeExtensions(reversed.map((config) => config.themes ?? {})),
+		prune: mergeExtensions(reversed.map((config) => config.prune ?? {})),
+		hash: mergeScalarShorthand("hash", reversed),
+		prefix: mergeScalarShorthand("prefix", reversed),
+		preflight: mergeScalarShorthand("preflight", reversed),
 		hooks: mergeHooks(pluginHooks)
 	}, ...reversed));
 	/**
@@ -679,18 +765,6 @@ async function getResolvedConfig(config, cwd, hooks) {
 	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) => {
@@ -785,6 +859,109 @@ const validateRecipes = (options) => {
 	return artifacts;
 };
 //#endregion
+//#region src/validation/validate-removed.ts
+/**
+* Config options that no longer exist, and what replaced them.
+*
+* An unknown key is otherwise *silently ignored* — nothing walks the config for keys it does not
+* recognise. So removing an option without this leaves the worst possible upgrade: the build
+* reverts to the default and says nothing, and an assertion the user asked for simply stops being
+* enforced. That is exactly the shape a renamed prune flag would have taken.
+*
+* Keyed by the removed name so the message can say what to write instead, rather than reporting a
+* bare "unknown option". Entries can be dropped a release or two after removal, once nobody is
+* upgrading across them.
+*/
+const REMOVED = {
+	pruneUnusedTokens: (value) => value === "strict" ? `\`pruneUnusedTokens: 'strict'\` is now \`prune: { tokens: 'accounted', unresolvedPath: 'error' }\`.` : `\`pruneUnusedTokens\` is now \`prune: { tokens: '${value === false ? "off" : "reachable"}' }\`.`,
+	pruneUnusedKeyframes: (value) => `\`pruneUnusedKeyframes\` is now \`prune: { keyframes: ${value === false ? "false" : "true"} }\`.`,
+	prunePreflight: (value) => `\`prunePreflight\` is now \`prune: { preflight: ${value === false ? "false" : "true"} }\`.`,
+	globalCss: () => `\`globalCss\` is now \`global: { css }\`.`,
+	globalFontface: () => `\`globalFontface\` is now \`global: { fontface }\`.`,
+	globalPositionTry: () => `\`globalPositionTry\` is now \`global: { positionTry }\`.`,
+	globalVars: () => `\`globalVars\` is now \`global: { vars }\`.`,
+	themes: () => `\`themes\` is now \`theme.variants\`. One character from \`theme\`, both spellings valid, so the typo resolved to a different feature instead of an error.`,
+	eject: (value) => value ? `\`eject: true\` is now \`presets: []\`. \`presets\` is the complete list — an unset \`presets\` loads \`defaultPresets\`, and listing your own no longer keeps a default underneath it.` : `\`eject: false\` is the default and can be removed. \`presets\` is now the complete list.`,
+	lightningcss: (value) => value ? `\`lightningcss: true\` is now \`plugins: [pluginLightningcss()]\` from \`@bamboocss/plugin-lightningcss\`, which you install yourself. The flag forced a static import, so every project carried the native binary whether or not it was on.` : `\`lightningcss: false\` is the default and can be removed.`
+};
+/** Values that no longer exist for an option that does. Keyed by option, then by old value. */
+const RETIRED_VALUES = { validation: { none: `\`validation: 'none'\` is now \`validation: 'off'\`, matching \`prune.unresolvedPath\`.` } };
+/** Removed keys nested one level down, keyed by their parent. */
+const REMOVED_NESTED = { prune: { unresolved: (value) => `\`prune.unresolved\` is now \`prune.unresolvedPath\`, and the accounting pass it used to switch on is now \`prune.tokens: 'accounted'\` — write \`prune: { tokens: 'accounted', unresolvedPath: '${value === "error" ? "error" : "warn"}' }\`. They are separate because \`'off'\` used to mean two things at once: no accounting, and no report.` } };
+function validateRemovedOptions(config, addError) {
+	const dict = config;
+	for (const [name, describe] of Object.entries(REMOVED)) {
+		if (!Object.hasOwn(config, name)) continue;
+		addError("config", describe(dict[name]));
+	}
+	for (const [parent, removed] of Object.entries(REMOVED_NESTED)) {
+		const value = dict[parent];
+		if (value == null || typeof value !== "object") continue;
+		for (const [name, describe] of Object.entries(removed)) {
+			if (!Object.hasOwn(value, name)) continue;
+			addError("config", describe(value[name]));
+		}
+	}
+	for (const [name, retired] of Object.entries(RETIRED_VALUES)) {
+		const value = dict[name];
+		if (typeof value !== "string") continue;
+		const message = retired[value];
+		if (message) addError("config", message);
+	}
+	if (typeof dict.prune?.tokens === "boolean") addError("config", `\`prune.tokens\` takes a strategy now, not a boolean — write \`'${dict.prune.tokens ? "reachable" : "off"}'\`. \`'accounted'\` is the new one: keeps computed from the token paths in your source rather than from what the css reaches.`);
+	for (const [name, pattern] of Object.entries(config.patterns ?? {})) {
+		const dictPattern = pattern;
+		if (!dictPattern) continue;
+		if (Object.hasOwn(dictPattern, "strict")) addError("patterns", `\`${name}.strict\` is now \`${name}.cssProps: '${dictPattern.strict ? "none" : "all"}'\`.`);
+		if (Object.hasOwn(dictPattern, "blocklist")) addError("patterns", `\`${name}.blocklist\` is now \`${name}.cssProps: { except: [...] }\`, which is no longer experimental and no longer silently dropped when the pattern also set \`strict\`.`);
+	}
+}
+//#endregion
+//#region src/validation/validate-retired-syntax.ts
+/**
+* Token values still written in a retired reference syntax.
+*
+* A hard error, and one that runs ahead of `validation` rather than under it. The rest of
+* `validateConfig` reports opinions about a config that will still build; this reports a spelling
+* that no longer means anything, whose output is broken either way — in a token value the text is
+* emitted into the stylesheet as-is, and nothing downstream reports it. `validation: 'off'` is an
+* opt-out of opinions, not of that.
+*
+* Safe to throw on because the spelling was never available for anything else: until it was
+* removed, `{…}` in a value was consumed unconditionally — braces stripped, unresolved paths
+* emitted bare — so no literal `{a.b}` could have survived to mean itself.
+*
+* Every occurrence is collected before throwing, because the point is to fix a config once rather
+* than to be told about it one token at a time. Delete this a release or two after removal, along
+* with `validate-removed.ts`.
+*/
+function assertNoRetiredSyntax(config) {
+	const found = [];
+	const collect = (source, label) => {
+		if (!source) return;
+		(0, _bamboocss_shared.walkObject)(source, (token, path) => {
+			if (!isValidToken(token)) return;
+			const value = serializeTokenValue(token.value ?? token);
+			const at = `${label}.${formatPath(path.join("."))}`;
+			const curly = findCurlyReference(value);
+			if (curly) found.push(`- \`${at}\`: \`${curly}\` → \`token(${curly.slice(1, -1)})\``);
+			const fallback = findFallbackReference(value);
+			if (fallback) {
+				const path = fallback.slice(6, fallback.lastIndexOf(",")).trim();
+				found.push(`- \`${at}\`: \`${fallback}\` → \`token(${path})\``);
+			}
+		}, { stop: isValidToken });
+	};
+	collect(config.theme?.tokens, "theme.tokens");
+	collect(config.theme?.semanticTokens, "theme.semanticTokens");
+	for (const [name, variant] of Object.entries(config.theme?.variants ?? {})) {
+		collect(variant?.tokens, `theme.variants.${name}.tokens`);
+		collect(variant?.semanticTokens, `theme.variants.${name}.semanticTokens`);
+	}
+	if (!found.length) return;
+	throw new _bamboocss_shared.BambooError("CONFIG_ERROR", `${found.length} token value(s) use a retired reference syntax:\n\n${found.join("\n")}\n\n\`{colors.red.300}\` and \`token(colors.red.300, fallback)\` were both removed so a token is referenced one way. Neither is ignored quietly — the text is emitted into the stylesheet as-is.`);
+}
+//#endregion
 //#region src/validation/validate-token-references.ts
 const validateTokenReferences = (props) => {
 	const { valueAtPath, refsByPath, addError, typeByPath } = props;
@@ -905,13 +1082,24 @@ const validateTokens = (options) => {
 * - Check for missing tokens references
 * - Check for conditions selectors (must contain '&')
 * - Check for breakpoints units (must be the same)
+* - Check for options that have been removed, which are otherwise ignored in silence
+* - Throw on token values still written in the retired curly reference syntax
 */
 const validateConfig = (config) => {
-	if (config.validation === "none") return;
+	assertNoRetiredSyntax(config);
 	const warnings = /* @__PURE__ */ new Set();
 	const addError = (scope, message) => {
 		warnings.add(`[${scope}] ` + message);
 	};
+	validateRemovedOptions(config, addError);
+	const report = () => {
+		if (!warnings.size) return;
+		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;
+	};
+	if (config.validation === "off") return report();
 	validateBreakpoints(config.theme?.breakpoints, addError);
 	validateConditions(config.conditions, addError);
 	const artifacts = {
@@ -941,12 +1129,7 @@ const validateConfig = (config) => {
 	}
 	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;
-	}
+	return report();
 };
 //#endregion
 //#region src/resolve-config.ts
@@ -956,18 +1139,37 @@ const hookUtils = {
 	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
+* The one way this rename can break a config without saying so.
+*
+* `presets` still exists and still takes a list, so nothing in `validate-removed` notices
+* that its meaning changed. A config that listed `[myPreset]` used to get `preset-base`
+* underneath it and now does not — and what `preset-base` carries is the utility table, so
+* the failure is every class name silently changing (`c_red_300` becomes `color_red_300`)
+* rather than an error. That is the shape this codebase treats as the worst upgrade there
+* is, so it gets a message.
+*
+* Skipped for an empty list, which is a deliberate eject and the replacement for
+* `eject: true`. Drop this a release or two after the rename.
+*/
+function warnIfBaseDropped(listed, resolved) {
+	if (!listed?.length) return;
+	if (resolved.some((preset) => preset?.name === "@bamboocss/preset-base")) return;
+	_bamboocss_logger.logger.warn("config", "`presets` is now the complete list, and this one does not include `@bamboocss/preset-base` — so its utilities, conditions and patterns are not loaded, and generated class names change. Listing a preset used to keep `preset-base` underneath it.\n\n  import { defaultPresets } from '@bamboocss/dev/presets'\n  presets: [...defaultPresets, yourPreset]\n\nIf dropping it is deliberate, this is the intended behaviour and the warning goes away once `preset-base` is listed explicitly.");
+}
+/**
+* Resolve the final config (including presets).
+*
+* `presets` is authoritative: what the config lists is what is loaded, and an unset
+* `presets` loads `defaultPresets`. There is no implicit preset a listed one sits on top
+* of — `eject` used to control that, badly. Under it, listing any preset kept
+* `@bamboocss/preset-base` and silently dropped `@bamboocss/preset-bamboo`, so `presets`
+* was neither additive nor replacing, and `presets: []` meant "base only" rather than
+* "none". Both of those had to be discovered by reading this function.
 */
 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 listed = result.config.presets;
+	result.config.presets = listed ? Array.from(new Set(listed.map((preset) => getBundledPreset(preset) ?? preset))) : [...defaultPresets];
+	warnIfBaseDropped(listed, result.config.presets);
 	const userConfig = result.config;
 	const pluginHooks = userConfig.plugins ?? [];
 	if (userConfig.hooks) pluginHooks.push({
@@ -978,6 +1180,7 @@ async function resolveConfig(result, cwd) {
 	const mergedConfig = await getResolvedConfig(result.config, cwd, earlyHooks);
 	const hooks = mergedConfig.hooks ?? {};
 	if (mergedConfig.logLevel) _bamboocss_logger.logger.level = mergedConfig.logLevel;
+	if (mergedConfig.logFilter) _bamboocss_logger.logger.filter = mergedConfig.logFilter;
 	validateConfig(mergedConfig);
 	const loadConfigResult = {
 		...result,
@@ -1015,6 +1218,7 @@ async function loadConfig(options) {
 //#endregion
 exports.bundleConfig = bundleConfig;
 exports.convertTsPathsToRegexes = convertTsPathsToRegexes;
+exports.defaultPresets = defaultPresets;
 exports.diffConfigs = diffConfigs;
 exports.findConfig = findConfig;
 exports.getConfigDependencies = getConfigDependencies;
@@ -1022,4 +1226,6 @@ exports.getResolvedConfig = getResolvedConfig;
 exports.loadConfig = loadConfig;
 exports.mergeConfigs = mergeConfigs;
 exports.mergeHooks = mergeHooks;
+exports.presetBamboo = _bamboocss_preset_bamboo.preset;
+exports.presetBase = _bamboocss_preset_base.preset;
 exports.resolveConfig = resolveConfig;