@likec4/styles 1.47.0 → 1.49.0

package/preset/_chunks/libs/pandacss-preset-radix-colors.mjs

@@ -0,0 +1,147 @@
+import { r as colors_exports } from "./@radix-ui/colors.mjs";
+import { definePreset } from "@pandacss/dev";
+var SCALE_TAGS_REGEX = new RegExp(`(${["P3"].join("|")})|(?=[A-Z0-9])`, "g");
+function getScaleTags(fullName) {
+	return fullName.split(SCALE_TAGS_REGEX).filter(Boolean).map((x) => x.toLowerCase());
+}
+function getScalePath(tags) {
+	return tags.join(".");
+}
+function isScaleAlpha(tags) {
+	return tags.includes("a");
+}
+function isScaleDark(tags) {
+	return tags.includes("dark");
+}
+function isScaleP3(tags) {
+	return tags.includes("p3");
+}
+function getScaleName(tags) {
+	return tags[0];
+}
+function getScaleShades(value) {
+	return Object.assign({}, ...Object.values(value).map((shade, i) => ({ [++i]: shade })));
+}
+function getScales(lightPrefix) {
+	return Object.entries(colors_exports).map(([fullName, value]) => {
+		const tags = getScaleTags(fullName);
+		const dark = isScaleDark(tags);
+		if (!dark && lightPrefix) tags.splice(1, 0, "light");
+		return {
+			fullName,
+			tags,
+			name: getScaleName(tags),
+			path: getScalePath(tags),
+			dark,
+			alpha: isScaleAlpha(tags),
+			p3: isScaleP3(tags),
+			shades: getScaleShades(value)
+		};
+	});
+}
+function keysToObj(keys, value) {
+	if (keys.length === 0) return value;
+	const key = keys[0];
+	const obj = keysToObj(keys.slice(1), value);
+	return { [key]: obj };
+}
+function isObject(value) {
+	return value !== null && value !== void 0 && typeof value === "object" && !Array.isArray(value);
+}
+function mergeObjs(target, ...sources) {
+	if (!sources.length) return target;
+	const source = sources.shift();
+	if (isObject(target) && isObject(source)) for (const key in source) if (isObject(source[key])) {
+		if (!target[key]) Object.assign(target, { [key]: {} });
+		mergeObjs(target[key], source[key]);
+	} else Object.assign(target, { [key]: source[key] });
+	return mergeObjs(target, ...sources);
+}
+function findDarkScale(scale, scales) {
+	return scales.find((x) => x.name === scale.name && x.alpha === scale.alpha && x.p3 === scale.p3 && x.dark);
+}
+function findP3Scale(scale, scales) {
+	return scales.find((x) => x.name === scale.name && x.alpha === scale.alpha && x.dark === scale.dark && x.p3);
+}
+function findLightScale(scale, scales) {
+	return scales.find((x) => x.name === scale.name && x.alpha === scale.alpha && x.dark === scale.dark && x.p3 === scale.p3 && x.tags.includes("light"));
+}
+function findRelatedScales(scale, scales, enableDarkMode, enableAutoP3) {
+	const result = { current: scale };
+	if (enableDarkMode && !scale.dark && !scale.tags.includes("light")) result.dark = findDarkScale(scale, scales);
+	if (!result.dark && enableAutoP3 && !scale.p3) result.p3 = findP3Scale(scale, scales);
+	if (result.dark) result.light = scale.tags.includes("light") ? scale : findLightScale(scale, scales);
+	return result;
+}
+function buildTokenValue(shade, shadeIndex, relatedScales) {
+	if (relatedScales.dark) return {
+		base: `{colors.${relatedScales.light?.path}.${shadeIndex}}`,
+		_dark: `{colors.${relatedScales.dark.path}.${shadeIndex}}`
+	};
+	if (relatedScales.p3) return {
+		base: shade,
+		_p3: `{colors.${relatedScales.p3.path}.${shadeIndex}}`
+	};
+	return shade;
+}
+function getSemanticTokens(darkMode, autoP3, colorScales = []) {
+	let scales = getScales(darkMode);
+	if (darkMode) scales = scales.concat(getScales(false).filter((x) => !x.dark));
+	const filteredScales = scales.filter((scale) => shouldIncludeScale(scale, colorScales));
+	return mergeObjs({}, ...filteredScales.map((scale) => generateScaleTokens(scale, filteredScales, darkMode, autoP3)));
+}
+function shouldIncludeScale(scale, colorScales) {
+	if (colorScales.length === 0) return true;
+	return colorScales.some((colorScale) => {
+		return scale.path === colorScale || scale.path.startsWith(colorScale + ".");
+	});
+}
+function generateScaleTokens(scale, allScales, enableDarkMode = false, enableAutoP3 = false) {
+	const relatedScales = findRelatedScales(scale, allScales, enableDarkMode, enableAutoP3);
+	const mergedShades = mergeObjs({}, ...Object.entries(scale.shades).map(([shadeIndex, color]) => {
+		const tokenValue = buildTokenValue(color, shadeIndex, relatedScales);
+		return { [shadeIndex]: { value: tokenValue } };
+	}));
+	return keysToObj(scale.tags, mergedShades);
+}
+var name = "pandacss-preset-radix-colors";
+var DEFAULT_DARK_MODE_CONDITION = ".dark &";
+function getConditions(darkModeCondition) {
+	const conditions = {};
+	if (darkModeCondition) conditions["dark"] = darkModeCondition;
+	conditions["p3"] = "@media (color-gamut: p3)";
+	return conditions;
+}
+function normalizeDarkMode(darkModeOption) {
+	if (!darkModeOption) return { enabled: false };
+	if (typeof darkModeOption === "boolean") return {
+		enabled: true,
+		condition: DEFAULT_DARK_MODE_CONDITION
+	};
+	return {
+		enabled: darkModeOption.enabled ?? true,
+		condition: darkModeOption.condition
+	};
+}
+function validateColorScales(colorScales) {
+	if (!colorScales || colorScales.length === 0) return;
+	const scales = getScales();
+	const unmatchedScales = colorScales.filter((colorScale) => {
+		return !scales.some((scale) => scale.path === colorScale || scale.path.startsWith(colorScale + "."));
+	});
+	if (unmatchedScales.length > 0) console.warn(`[pandacss-preset-radix-colors] Color scale paths don't match any available scales: ${unmatchedScales.join(", ")}. Valid examples: "amber", "blue.dark", "gray.p3", "red.dark.a". Available base colors: ${Array.from(new Set(scales.map((s) => s.name))).join(", ")}.`);
+}
+function createPreset(options) {
+	const darkModeConfig = normalizeDarkMode(options?.darkMode);
+	validateColorScales(options?.colorScales);
+	return definePreset({
+		name,
+		conditions: { extend: getConditions(darkModeConfig.enabled ? darkModeConfig.condition : void 0) },
+		theme: { extend: { semanticTokens: { colors: getSemanticTokens(darkModeConfig.enabled, options?.autoP3, options?.colorScales) } } }
+	});
+}
+function transformScaleName(scale) {
+	return scale.split(/(Dark|P3|A)/).map((x) => x.toLowerCase()).filter(Boolean).join(".");
+}
+Object.keys(colors_exports).filter((scale) => !scale.includes("default")).map(transformScaleName);
+export { createPreset as t };

package/preset/_chunks/libs/remeda.mjs

@@ -0,0 +1,120 @@
+function e$3(e, t, n) {
+	let r = (n) => e(n, ...t);
+	return n === void 0 ? r : Object.assign(r, {
+		lazy: n,
+		lazyArgs: t
+	});
+}
+function t$9(t, n, r) {
+	let i = t.length - n.length;
+	if (i === 0) return t(...n);
+	if (i === 1) return e$3(t, n, r);
+	throw Error(`Wrong number of arguments`);
+}
+function t$8(...t) {
+	return t$9(n$6, t);
+}
+const n$6 = (e) => `${e[0]?.toUpperCase() ?? ``}${e.slice(1)}`, t$7 = {
+	done: !1,
+	hasNext: !1
+};
+function t$6(e, ...t) {
+	let a = e, o = t.map((e) => `lazy` in e ? r(e) : void 0), s = 0;
+	for (; s < t.length;) {
+		if (o[s] === void 0 || !i(a)) {
+			let e = t[s];
+			a = e(a), s += 1;
+			continue;
+		}
+		let e = [];
+		for (let n = s; n < t.length; n++) {
+			let t = o[n];
+			if (t === void 0 || (e.push(t), t.isSingle)) break;
+		}
+		let r = [];
+		for (let t of a) if (n$4(t, r, e)) break;
+		let { isSingle: c } = e.at(-1);
+		a = c ? r[0] : r, s += e.length;
+	}
+	return a;
+}
+function n$4(t, r, i) {
+	if (i.length === 0) return r.push(t), !1;
+	let a = t, o = t$7, s = !1;
+	for (let [e, t] of i.entries()) {
+		let { index: c, items: l } = t;
+		if (l.push(a), o = t(a, c, l), t.index += 1, o.hasNext) {
+			if (o.hasMany ?? !1) {
+				for (let t of o.next) if (n$4(t, r, i.slice(e + 1))) return !0;
+				return s;
+			}
+			a = o.next;
+		}
+		if (!o.hasNext) break;
+		o.done && (s = !0);
+	}
+	return o.hasNext && r.push(a), s;
+}
+function r(e) {
+	let { lazy: t, lazyArgs: n } = e, r = t(...n);
+	return Object.assign(r, {
+		isSingle: t.single ?? !1,
+		index: 0,
+		items: []
+	});
+}
+function i(e) {
+	return typeof e == `string` || typeof e == `object` && !!e && Symbol.iterator in e;
+}
+function t$5(...t) {
+	return t$9(n$3, t);
+}
+const n$3 = (e, t) => e.length >= t;
+function e$1(e) {
+	return typeof e == `string`;
+}
+function t$4(...t) {
+	return t$9(Object.keys, t);
+}
+function t$3(...t) {
+	return t$9(n$2, t);
+}
+function n$2(e, t) {
+	let n = {};
+	for (let [r, i] of Object.entries(e)) {
+		let a = t(r, i, e);
+		n[a] = i;
+	}
+	return n;
+}
+function t$2(...t) {
+	return t$9(n$1, t);
+}
+function n$1(e, t) {
+	let n = {};
+	for (let [r, i] of e.entries()) {
+		let [a, o] = t(i, r, e);
+		n[a] = o;
+	}
+	return n;
+}
+function t$1(...t) {
+	return t$9(n, t);
+}
+function n(e, t) {
+	let n = {};
+	for (let [r, i] of Object.entries(e)) n[r] = t(i, r, e);
+	return n;
+}
+function e(e, ...n) {
+	return typeof e == `string` || typeof e == `number` || typeof e == `symbol` ? (r) => t(r, e, ...n) : t(e, ...n);
+}
+function t(e, ...t) {
+	let n = e;
+	for (let e of t) {
+		if (n == null) return;
+		n = n[e];
+	}
+	return n;
+}
+export { t$4 as a, t$6 as c, t$3 as i, t$8 as l, t$1 as n, e$1 as o, t$2 as r, t$5 as s, e as t };

package/preset/_chunks/rolldown-runtime.mjs

@@ -0,0 +1,11 @@
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+export { __exportAll as t };

package/preset/package.json

@@ -1,4 +1,4 @@
 {
-  "types": "../dist/preset.d.mts",
-  "module": "../dist/preset.mjs"
+  "types": "preset.d.mts",
+  "module": "preset.mjs"
 }