@bamboocss/config 1.11.4 → 1.12.0

package/dist/index.d.mts

@@ -1,8 +1,5 @@
-import { diffConfigs } from "./diff-config.mjs";
-import { n as convertTsPathsToRegexes, t as PathMapping } from "./ts-config-paths-CvGId8kq.mjs";
-import { n as mergeHooks, t as mergeConfigs } from "./merge-config-oEiBYbfB.mjs";
 import { CompilerOptions, TypeAcquisition } from "typescript";
-import { BambooHooks, Config, ConfigTsOptions, LoadConfigResult as LoadConfigResult$1 } from "@bamboocss/types";
+import { BambooHooks as BambooHooks$1, BambooPlugin, Config, ConfigTsOptions, DiffConfigResult, LoadConfigResult as LoadConfigResult$1 } from "@bamboocss/types";
 
 //#region src/types.d.ts
 interface ConfigFileOptions {
@@ -18,6 +15,13 @@ interface BundleConfigResult<T = Config> {
 //#region src/bundle-config.d.ts
 declare function bundleConfig(options: ConfigFileOptions): Promise<BundleConfigResult>;
 //#endregion
+//#region src/diff-config.d.ts
+type ConfigOrFn = Config | (() => Config);
+/**
+ * Diff the two config objects and return the list of affected properties
+ */
+declare function diffConfigs(config: ConfigOrFn, prevConfig: Config | undefined): DiffConfigResult;
+//#endregion
 //#region src/find-config.d.ts
 declare function findConfig(options: Partial<ConfigFileOptions>): string;
 //#endregion
@@ -41,6 +45,16 @@ interface TSConfig {
  * @returns the same `tsconfig.json` object.
  */
 //#endregion
+//#region src/ts-config-paths.d.ts
+interface PathMapping {
+  pattern: RegExp;
+  paths: string[];
+}
+/**
+ * @see https://github.com/aleclarson/vite-tsconfig-paths/blob/e8f0acf7adfcfbf77edbe937f64b4e5d39557ad0/src/mappings.ts
+ */
+declare function convertTsPathsToRegexes(paths: Record<string, string[]>, baseUrl: string): PathMapping[];
+//#endregion
 //#region src/get-mod-deps.d.ts
 interface GetDepsOptions {
   filename: string;
@@ -58,14 +72,14 @@ declare function getConfigDependencies(filePath: string, tsOptions?: ConfigTsOpt
 };
 //#endregion
 //#region src/get-resolved-config.d.ts
-type Extendable<T> = T & {
+type Extendable$1<T> = T & {
   extend?: T;
 };
-type ExtendableConfig = Extendable<Config>;
+type ExtendableConfig$1 = Extendable$1<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>;
+declare function getResolvedConfig(config: ExtendableConfig$1, cwd: string, hooks?: Partial<BambooHooks$1>): Promise<Config>;
 //#endregion
 //#region src/load-config.d.ts
 /**
@@ -81,4 +95,17 @@ declare function loadConfig(options: ConfigFileOptions): Promise<LoadConfigResul
  */
 declare function resolveConfig(result: BundleConfigResult, cwd: string): Promise<LoadConfigResult$1>;
 //#endregion
+//#region src/merge-hooks.d.ts
+declare const mergeHooks: (plugins: BambooPlugin[]) => BambooHooks;
+//#endregion
+//#region src/merge-config.d.ts
+type Extendable<T> = T & {
+  extend?: T;
+};
+type ExtendableConfig = Extendable<Config>;
+/**
+ * Merge all configs into a single config
+ */
+declare function mergeConfigs(configs: ExtendableConfig[]): any;
+//#endregion
 export { type BundleConfigResult, type GetDepsOptions, bundleConfig, convertTsPathsToRegexes, diffConfigs, findConfig, getConfigDependencies, getResolvedConfig, loadConfig, mergeConfigs, mergeHooks, resolveConfig };

package/dist/index.mjs

@@ -1,11 +1,9 @@
-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 { BAMBOO_CONFIG_NAME, BambooError, getUnit, isObject, isString, omit, parseJson, pick, stringifyJson, traverse, walkObject } from "@bamboocss/shared";
+import { BAMBOO_CONFIG_NAME, BambooError, assign, dashCase, getUnit, isObject, isString, mergeAndConcat, mergeWith, omit, parseJson, pick, stringifyJson, traverse, walkObject } from "@bamboocss/shared";
 import { bundleNRequire } from "bundle-n-require";
 import findUp from "escalade/sync";
-import path, { resolve } from "path";
+import path, { posix, resolve, sep } from "path";
+import microdiff from "microdiff";
 import fs from "fs";
 import ts from "typescript";
 import { preset as presetBase } from "@bamboocss/preset-base";
@@ -60,6 +58,183 @@ async function bundleConfig(options) {
 	};
 }
 //#endregion
+//#region src/create-matcher.ts
+/**
+* Acts like a .gitignore matcher
+* e.g a list of string to search for nested path with glob and exclusion allowed
+* ["outdir", "theme.recipes", '*.css', '!aaa.*.bbb']
+*/
+function createMatcher(id, patterns) {
+	if (!patterns?.length) return () => void 0;
+	const includePatterns = [];
+	const excludePatterns = [];
+	new Set(patterns).forEach((pattern) => {
+		const regexString = pattern.replace(/\*/g, ".*");
+		if (pattern.startsWith("!")) excludePatterns.push(regexString.slice(1));
+		else includePatterns.push(regexString);
+	});
+	const include = new RegExp(includePatterns.join("|"));
+	const exclude = new RegExp(excludePatterns.join("|"));
+	return (path) => {
+		if (excludePatterns.length && exclude.test(path)) return;
+		return include.test(path) ? id : void 0;
+	};
+}
+//#endregion
+//#region src/config-deps.ts
+const all = [
+	"clean",
+	"cwd",
+	"eject",
+	"outdir",
+	"forceConsistentTypeExtension",
+	"outExtension",
+	"emitTokensOnly",
+	"presets",
+	"plugins",
+	"hooks"
+];
+const format = [
+	"syntax",
+	"hash",
+	"prefix",
+	"separator",
+	"strictTokens",
+	"strictPropertyValues",
+	"shorthands"
+];
+const tokens = [
+	"utilities",
+	"conditions",
+	"theme.tokens",
+	"theme.semanticTokens",
+	"theme.breakpoints",
+	"theme.containerNames",
+	"theme.containerSizes"
+];
+const jsx = [
+	"jsxFramework",
+	"jsxFactory",
+	"jsxStyleProps",
+	"syntax"
+];
+const common = tokens.concat(jsx, format);
+const artifactConfigDeps = {
+	helpers: ["syntax", "jsxFramework"],
+	keyframes: ["theme.keyframes", "layers"],
+	"design-tokens": ["layers", "!utilities.*.className"].concat(tokens),
+	types: ["!utilities.*.className"].concat(common),
+	"css-fn": common,
+	cva: ["syntax"],
+	sva: ["syntax"],
+	cx: [],
+	"create-recipe": [
+		"separator",
+		"prefix",
+		"hash"
+	],
+	"recipes-index": ["theme.recipes", "theme.slotRecipes"],
+	recipes: ["theme.recipes", "theme.slotRecipes"],
+	"patterns-index": ["syntax", "patterns"],
+	patterns: ["syntax", "patterns"],
+	"jsx-is-valid-prop": common,
+	"jsx-factory": jsx,
+	"jsx-helpers": jsx,
+	"jsx-patterns": jsx.concat("patterns"),
+	"jsx-patterns-index": jsx.concat("patterns"),
+	"jsx-create-style-context": jsx,
+	"css-index": ["syntax"],
+	"package.json": ["forceConsistentTypeExtension", "outExtension"],
+	"types-styles": ["shorthands"],
+	"types-conditions": ["conditions"],
+	"types-jsx": jsx,
+	"types-entry": [],
+	"types-gen": [],
+	"types-gen-system": [],
+	themes: ["themes"].concat(tokens),
+	"static-css": [
+		"staticCss",
+		"patterns",
+		"theme.recipes",
+		"theme.slotRecipes"
+	].concat(tokens),
+	styles: [],
+	"styles.css": []
+};
+const artifactMatchers = Object.entries(artifactConfigDeps).map(([key, paths]) => {
+	if (!paths.length) return () => void 0;
+	return createMatcher(key, paths.concat(all));
+});
+//#endregion
+//#region src/diff-config.ts
+const runIfFn = (fn) => typeof fn === "function" ? fn() : fn;
+/**
+* Check if recipes were empty before and non-empty now (or vice versa)
+*/
+const hasRecipeStateTransition = (prevConfig, nextConfig) => {
+	const prevRecipes = prevConfig.theme?.recipes ?? {};
+	const prevSlotRecipes = prevConfig.theme?.slotRecipes ?? {};
+	const prevHasRecipes = Object.keys(prevRecipes).length > 0 || Object.keys(prevSlotRecipes).length > 0;
+	const nextRecipes = nextConfig.theme?.recipes ?? {};
+	const nextSlotRecipes = nextConfig.theme?.slotRecipes ?? {};
+	return prevHasRecipes !== (Object.keys(nextRecipes).length > 0 || Object.keys(nextSlotRecipes).length > 0);
+};
+/**
+* Diff the two config objects and return the list of affected properties
+*/
+function diffConfigs(config, prevConfig) {
+	const affected = {
+		artifacts: /* @__PURE__ */ new Set(),
+		hasConfigChanged: false,
+		diffs: []
+	};
+	if (!prevConfig) {
+		affected.hasConfigChanged = true;
+		return affected;
+	}
+	const configDiff = microdiff(prevConfig, runIfFn(config));
+	if (!configDiff.length) return affected;
+	affected.hasConfigChanged = true;
+	affected.diffs = configDiff;
+	configDiff.forEach((change) => {
+		const changePath = change.path.join(".");
+		artifactMatchers.forEach((matcher) => {
+			const id = matcher(changePath);
+			if (!id) return;
+			if (id === "recipes") {
+				const name = dashCase(change.path.slice(1, 3).join("."));
+				affected.artifacts.add(name);
+			}
+			if (id === "patterns") {
+				const name = dashCase(change.path.slice(0, 2).join("."));
+				affected.artifacts.add(name);
+			}
+			affected.artifacts.add(id);
+		});
+	});
+	if (affected.artifacts.has("recipes") || affected.artifacts.has("recipes-index")) {
+		if (hasRecipeStateTransition(prevConfig, runIfFn(config))) affected.artifacts.add("create-recipe");
+	}
+	return affected;
+}
+//#endregion
+//#region src/resolve-ts-path-pattern.ts
+/**
+* @see https://github.com/aleclarson/vite-tsconfig-paths/blob/e8f0acf7adfcfbf77edbe937f64b4e5d39557ad0/src/index.ts#LL231C57-L231C57
+*/
+const resolveTsPathPattern = (pathMappings, moduleSpecifier) => {
+	for (const mapping of pathMappings) {
+		const match = moduleSpecifier.match(mapping.pattern);
+		if (!match) continue;
+		for (const pathTemplate of mapping.paths) {
+			let starCount = 0;
+			return pathTemplate.replace(/\*/g, () => {
+				return match[Math.min(++starCount, match.length - 1)];
+			}).split(sep).join(posix.sep);
+		}
+	}
+};
+//#endregion
 //#region src/ts-config-paths.ts
 /**
 * @see https://github.com/aleclarson/vite-tsconfig-paths/blob/e8f0acf7adfcfbf77edbe937f64b4e5d39557ad0/src/mappings.ts
@@ -195,6 +370,273 @@ function getConfigDependencies(filePath, tsOptions = { pathMappings: [] }, compi
 	};
 }
 //#endregion
+//#region src/merge-hooks.ts
+const mergeHooks = (plugins) => {
+	const hooksFns = {};
+	plugins.forEach(({ name, hooks }) => {
+		Object.entries(hooks ?? {}).forEach(([key, value]) => {
+			if (!hooksFns[key]) hooksFns[key] = [];
+			hooksFns[key].push([name, value]);
+		});
+	});
+	return Object.fromEntries(Object.entries(hooksFns).map(([key, entries]) => {
+		const fns = entries.map(([name, fn]) => tryCatch(name, fn));
+		const reducer = key in reducers ? reducers[key] : void 0;
+		if (reducer) return [key, reducer(fns)];
+		return [key, syncHooks.includes(key) ? callAll(...fns) : callAllAsync(...fns)];
+	}));
+};
+const createReducer = (reducer) => reducer;
+const reducers = {
+	"config:resolved": createReducer((fns) => async (_args) => {
+		const args = Object.assign({}, _args);
+		const original = _args.config;
+		let config = args.config;
+		for (const hookFn of fns) {
+			const result = await hookFn(Object.assign(args, {
+				config,
+				original
+			}));
+			if (result !== void 0) config = result;
+		}
+		return config;
+	}),
+	"parser:before": createReducer((fns) => (_args) => {
+		const args = Object.assign({}, _args);
+		const original = _args.content;
+		let content = args.content;
+		for (const hookFn of fns) {
+			const result = hookFn(Object.assign(args, {
+				content,
+				original
+			}));
+			if (result !== void 0) content = result;
+		}
+		return content;
+	}),
+	"parser:preprocess": createReducer((fns) => (_args) => {
+		const args = Object.assign({}, _args);
+		const original = _args.data;
+		let data = args.data;
+		for (const hookFn of fns) {
+			const result = hookFn(Object.assign(args, {
+				data,
+				original
+			}));
+			if (result !== void 0) data = result;
+		}
+		return data;
+	}),
+	"cssgen:done": createReducer((fns) => (_args) => {
+		const args = Object.assign({}, _args);
+		const original = _args.content;
+		let content = args.content;
+		for (const hookFn of fns) {
+			const result = hookFn(Object.assign(args, {
+				content,
+				original
+			}));
+			if (result !== void 0) content = result;
+		}
+		return content;
+	}),
+	"codegen:prepare": createReducer((fns) => async (_args) => {
+		const args = Object.assign({}, _args);
+		const original = _args.artifacts;
+		let artifacts = args.artifacts;
+		for (const hookFn of fns) {
+			const result = await hookFn(Object.assign(args, {
+				artifacts,
+				original
+			}));
+			if (result) artifacts = result;
+		}
+		return artifacts;
+	}),
+	"preset:resolved": createReducer((fns) => async (_args) => {
+		const args = Object.assign({}, _args);
+		const original = _args.preset;
+		let preset = args.preset;
+		for (const hookFn of fns) {
+			const result = await hookFn(Object.assign(args, {
+				preset,
+				original
+			}));
+			if (result !== void 0) preset = result;
+		}
+		return preset;
+	}),
+	"css:optimize": createReducer((fns) => (_args) => {
+		const args = Object.assign({}, _args);
+		const original = _args.css;
+		let css = args.css;
+		for (const hookFn of fns) {
+			const result = hookFn(Object.assign(args, {
+				css,
+				original
+			}));
+			if (result !== void 0) css = result;
+		}
+		return css;
+	})
+};
+const syncHooks = [
+	"context:created",
+	"parser:before",
+	"parser:preprocess",
+	"parser:after",
+	"cssgen:done",
+	"css:optimize"
+];
+const callAllAsync = (...fns) => async (...a) => {
+	for (const fn of fns) await fn?.(...a);
+};
+const callAll = (...fns) => (...a) => {
+	fns.forEach((fn) => fn?.(...a));
+};
+const tryCatch = (name, fn) => {
+	return (...args) => {
+		try {
+			return fn(...args);
+		} catch (e) {
+			logger.caughtError("hooks", `Error in plugin "${name}"`, e);
+		}
+	};
+};
+//#endregion
+//#region src/validation/utils.ts
+const REFERENCE_REGEX = /({([^}]*)})/g;
+const curlyBracketRegex = /[{}]/g;
+const isValidToken = (token) => isObject(token) && Object.hasOwnProperty.call(token, "value");
+const isTokenReference = (value) => typeof value === "string" && REFERENCE_REGEX.test(value);
+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];
+	});
+}
+const serializeTokenValue = (value) => {
+	if (isString(value)) return value;
+	if (isObject(value)) return Object.values(value).map((v) => serializeTokenValue(v)).join(" ");
+	if (Array.isArray(value)) return value.map((v) => serializeTokenValue(v)).join(" ");
+	return value.toString();
+};
+//#endregion
+//#region src/merge-config.ts
+/**
+* Collect all `extend` properties into an array (to avoid mutation)
+*/
+function getExtends(items) {
+	return items.reduce((merged, { extend }) => {
+		if (!extend) return merged;
+		return mergeWith(merged, extend, (originalValue, newValue) => {
+			if (newValue === void 0) return originalValue ?? [];
+			if (originalValue === void 0) return [newValue];
+			if (Array.isArray(originalValue)) return [newValue, ...originalValue];
+			return [newValue, originalValue];
+		});
+	}, {});
+}
+/**
+* Separate the `extend` properties from the rest of the object
+*/
+function mergeRecords(records) {
+	return {
+		...records.reduce((acc, record) => assign(acc, record), {}),
+		extend: getExtends(records)
+	};
+}
+/**
+* Merge all `extend` properties into the rest of the object
+*/
+function mergeExtensions(records) {
+	const { extend = [], ...restProps } = mergeRecords(records);
+	return mergeWith(restProps, extend, (obj, extensions) => {
+		return mergeAndConcat({}, obj, ...extensions);
+	});
+}
+const isEmptyObject = (obj) => typeof obj === "object" && Object.keys(obj).length === 0;
+const compact = (obj) => {
+	return Object.keys(obj).reduce((acc, key) => {
+		if (obj[key] !== void 0 && !isEmptyObject(obj[key])) acc[key] = obj[key];
+		return acc;
+	}, {});
+};
+const tokenKeys = [
+	"description",
+	"extensions",
+	"type",
+	"value",
+	"deprecated"
+];
+/**
+* Merge all configs into a single config
+*/
+function mergeConfigs(configs) {
+	const userConfig = configs.at(-1);
+	const pluginHooks = userConfig.plugins ?? [];
+	if (userConfig.hooks) pluginHooks.push({
+		name: BAMBOO_CONFIG_NAME,
+		hooks: userConfig.hooks
+	});
+	const reversed = Array.from(configs).reverse();
+	const withoutEmpty = compact(assign({
+		conditions: mergeExtensions(reversed.map((config) => config.conditions ?? {})),
+		theme: mergeExtensions(reversed.map((config) => config.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 ?? {})),
+		staticCss: mergeExtensions(reversed.map((config) => config.staticCss ?? {})),
+		themes: mergeExtensions(reversed.map((config) => config.themes ?? {})),
+		hooks: mergeHooks(pluginHooks)
+	}, ...reversed));
+	/**
+	* Properly merge tokens between flat/nested forms by setting the flat form as the default
+	* preset:
+	* ```
+	* tokens: {
+	*   black: {
+	*     value: "black"
+	*   }
+	* }
+	* // color: "black"
+	* ```
+	*
+	* config:
+	* ```
+	* tokens: {
+	*   black: {
+	*     0: { value: "black" },
+	*     10: { value: "black/10" },
+	*     20: { value: "black/20" },
+	*     // ...
+	*   }
+	* }
+	*
+	* // color: "black.20"
+	* ```
+	*/
+	if (withoutEmpty.theme?.tokens) walkObject(withoutEmpty.theme.tokens, (args) => args, { stop(token) {
+		if (!isValidToken(token)) return false;
+		if (Object.keys(token).filter((k) => !tokenKeys.includes(k)).length > 0) {
+			token.DEFAULT ||= {};
+			tokenKeys.forEach((key) => {
+				if (token[key] == null) return;
+				token.DEFAULT[key] ||= token[key];
+				delete token[key];
+			});
+		}
+		return true;
+	} });
+	return withoutEmpty;
+}
+//#endregion
 //#region src/get-resolved-config.ts
 const hookUtils$1 = {
 	omit,