@plitzi/sdk-style 0.30.19

package/dist/helpers/calculateInheriting.d.ts

@@ -0,0 +1,121 @@
+import { ComponentDefinition, DisplayMode, Element, Schema, Style, StyleItem, StyleState, StyleValue } from '@plitzi/sdk-shared';
+export type InheritData = {
+    tree: {
+        name: string;
+        displayMode: DisplayMode;
+        attributes: StyleItem['attributes'];
+        componentType?: string;
+        isDefault?: boolean;
+        isParent: boolean;
+        isAncestor: boolean;
+    }[];
+    style: Record<string, {
+        key: string;
+        value: StyleValue;
+        displayMode: DisplayMode;
+    }[]>;
+    parentStyle: Record<string, string>;
+};
+/**
+ * ============================================================
+ * 🧠 STYLE INHERITANCE FLOW (calculateInheriting)
+ * ============================================================
+ *
+ * 🌳 HIERARCHY (top → bottom priority)
+ *
+ *   Ancestors
+ *      ↓
+ *   Parent
+ *      ↓
+ *   Current Element
+ *      ↓
+ *   DefaultStyle (componentDefinition fallback)
+ *
+ *
+ * 🎯 SOURCE RESOLUTION (per node)
+ *
+ *   styleSelectors (e.g. "btn card")
+ *          ↓
+ *   StyleItem.attributes
+ *          ↓
+ *   resolveStyleBlock()
+ *
+ *
+ * 🔥 STYLE LAYERING (inside a single StyleBlock)
+ *
+ *   base.default
+ *        ↓
+ *   variant.default
+ *        ↓
+ *   state
+ *        ↓
+ *   variant.state
+ *
+ *   Final:
+ *
+ *   {
+ *     ...base,
+ *     ...variant,
+ *     ...state,
+ *     ...variantState
+ *   }
+ *
+ *
+ * 🧩 FINAL MERGE (global result)
+ *
+ *   for each node in tree:
+ *
+ *     style = resolveNodeStyle(node)
+ *
+ *     if node.isAncestor:
+ *       style = pick(inheritableAttributesBase)
+ *
+ *     for each key in style:
+ *       finalStyle[key].push({
+ *         value,
+ *         source: node.name,
+ *         displayMode
+ *       })
+ *
+ *
+ * ⚠️ PRIORITY RULES
+ *
+ *   Between nodes:
+ *     ancestor < parent < current
+ *
+ *   Inside a node:
+ *     base < variant < state < variant+state
+ *
+ *
+ * 📱 DISPLAY MODES
+ *
+ *   Current order:
+ *     desktop → tablet → mobile
+ *
+ *   (Can be extended to support:
+ *     mobile-first or desktop-first)
+ *
+ *
+ * 🚀 RESULT
+ *
+ *   finalStyle = {
+ *     color: [
+ *       { value: 'red', source: 'btn', displayMode: 'desktop' },
+ *       { value: 'blue', source: 'btn', displayMode: 'tablet' }
+ *     ]
+ *   }
+ *
+ *   parentStyle = merged styles from direct parent only
+ *
+ * ============================================================
+ */
+declare const calculateInheriting: (element: Element | undefined, componentType: string | undefined, flat: Schema["flat"], platform: Style["platform"], componentDefinitions?: Record<string, ComponentDefinition>, params?: {
+    componentSubType?: string;
+    styleSelector?: string;
+    styleState?: StyleState;
+    styleVariant?: string;
+    includeSelf?: boolean;
+    skipSelectors?: string[];
+    addSelectors?: string[];
+}) => InheritData;
+export default calculateInheriting;

package/dist/helpers/calculateInheriting.mjs

@@ -0,0 +1,141 @@
+import { get as e, pick as t } from "@plitzi/plitzi-ui/helpers";
+import { inheritableAttributesBase as n } from "@plitzi/sdk-shared/style";
+//#region src/helpers/calculateInheriting.ts
+var r = (e, t) => {
+	let n = [], r = t;
+	for (; r;) {
+		n.push(r);
+		let t = r.definition.parentId;
+		r = t ? e[t] : void 0;
+	}
+	return n;
+}, i = (e, t, n, r, i) => {
+	let a = [], o = /* @__PURE__ */ new Set(), { definition: { styleSelectors: s, type: c }, attributes: { subType: l } } = e, u = (s[r] || "").split(" ").filter(Boolean);
+	for (let e of [...u, ...i]) {
+		if (o.has(e)) continue;
+		let t = n[e];
+		t?.name && (o.add(e), a.push(t));
+	}
+	if (t) {
+		for (let e of Object.values(n)) if (e.type === "element" && e.componentType === t && e.name) {
+			if (o.has(e.name)) continue;
+			o.add(e.name), a.push(e);
+		}
+	}
+	let d = n[c];
+	if (d && d.name && !["class", "element"].includes(d.type) && (o.has(d.name) || (o.add(d.name), a.push(d))), l) {
+		let e = n[l];
+		e && e.name && !["class", "element"].includes(e.type) && (o.has(e.name) || (o.add(e.name), a.push(e)));
+	}
+	return a;
+}, a = (t, n, r, i) => {
+	let a = e(i, `${t}.defaultStyle`, void 0);
+	if (a) return a.subTypes && !n && (n = Object.keys(a.subTypes)[0]), n && a.subTypes?.[n] && (a = a.subTypes[n]), {
+		name: "defaultStyle",
+		attributes: { [r]: e(a, `style.${r}`, {}) },
+		componentType: t,
+		isParent: !1,
+		isAncestor: !1,
+		isDefault: !0
+	};
+}, o = (e, t, n, r) => {
+	let i = e[t];
+	if (!i) return {};
+	let a = i.default ?? {}, o = r ? i.variants?.[r]?.default ?? {} : {}, s = n ? i.states?.[n] ?? {} : {}, c = r && n ? i.variants?.[r]?.states?.[n] ?? {} : {};
+	return {
+		...a,
+		...o,
+		...s,
+		...c
+	};
+}, s = (e, t, n, r) => o(e.attributes, t, n, r), c = (e, o, c, l, u = {}, d = {}) => {
+	let { componentSubType: f, styleSelector: p = "base", styleState: m, styleVariant: h, includeSelf: g = !1, skipSelectors: _ = [], addSelectors: v = [] } = d, y = {
+		tree: [],
+		style: {},
+		parentStyle: {}
+	}, b = e ? r(c, e) : [], x = /* @__PURE__ */ new Set();
+	for (let t of Object.keys(l)) {
+		let n = l[t];
+		if (n) {
+			if (!e && !o) {
+				for (let e of v) {
+					let r = n[e];
+					r && y.tree.push({
+						name: e,
+						displayMode: t,
+						attributes: r.attributes,
+						isParent: !1,
+						isAncestor: !1
+					});
+				}
+				continue;
+			}
+			if (!e && o) {
+				let e = i({
+					definition: {
+						type: o,
+						styleSelectors: {},
+						parentId: void 0
+					},
+					attributes: {}
+				}, o, n, p, v);
+				for (let n of e) _.includes(n.name) || y.tree.push({
+					name: n.name,
+					displayMode: t,
+					attributes: n.attributes,
+					isParent: !1,
+					isAncestor: !1
+				});
+				let r = a(o, f, p, u);
+				r && y.tree.push({
+					...r,
+					displayMode: t
+				});
+				continue;
+			}
+			for (let r of b) {
+				let s = e?.definition.parentId === r.id, c = r.id !== e?.id, l = i(r, r.definition.type === o ? o : void 0, n, p, v);
+				!g && !c && !m && !h && Object.keys(l).length && (l = l.filter((e) => e.type === "element"));
+				for (let e of l) _.includes(e.name) && !c || y.tree.push({
+					name: e.name,
+					displayMode: t,
+					attributes: e.attributes,
+					componentType: e.componentType,
+					isParent: s,
+					isAncestor: c,
+					isDefault: !1
+				});
+				let d = a(r.definition.type, r.attributes.subType, p, u);
+				d && !x.has(r.definition.type) && (x.add(r.definition.type), y.tree.push({
+					...d,
+					displayMode: t,
+					isParent: s,
+					isAncestor: !1
+				}));
+			}
+		}
+	}
+	let S = {};
+	for (let e of y.tree) {
+		let r = s(e, p, m, h);
+		if (r) {
+			e.isAncestor && (r = t(r, n));
+			for (let t of Object.keys(r)) e.isAncestor && !n.includes(t) || (S[t] || (S[t] = []), S[t].push({
+				key: e.name,
+				value: r[t],
+				displayMode: e.displayMode
+			}));
+		}
+	}
+	let C = y.tree.filter((e) => e.isParent).reduce((e, t) => ({
+		...e,
+		...s(t, p, m, h)
+	}), {});
+	return {
+		...y,
+		style: S,
+		parentStyle: C
+	};
+};
+//#endregion
+export { c as default };

package/dist/helpers/formatCssFromSelector.d.ts

@@ -0,0 +1,8 @@
+import { StyleItem } from '@plitzi/sdk-shared';
+type StyleBasicItem = Omit<StyleItem, 'type' | 'cache'>;
+export declare function cssToSelectors(css?: string): Record<string, StyleBasicItem>;
+export declare const getReadOnlyRangesFromContent: (doc?: string) => {
+    from: number;
+    to: number;
+}[];
+export {};

package/dist/helpers/formatCssFromSelector.mjs

@@ -0,0 +1,54 @@
+import { set as e } from "@plitzi/plitzi-ui/helpers";
+import { styleConstants as t } from "@plitzi/sdk-shared";
+//#region src/helpers/formatCssFromSelector.ts
+var n = /@media[^{]*\{(?:[^{}]*|\{[^{}]*\})*\}/gim, r = /(?<selector>\.|#|)(?<selectorName>[a-z0-9_-]+)([ ]+|){(?<selectorData>[a-z0-9:; (),.%\n*/#+"'_-]+|)}/gim, i = /(?<propName>[a-z-]+):([ ]+|)(?<propValue>([a-z-]+\([^;]\)|".*"|[a-z0-9 (),.%\n*/#+"':_-]+));/gim, a = /(\/\*.*\*\/)/gim, o = Object.values(t);
+function s(t = "") {
+	return [...t.replace(n, "").replaceAll("\n", "").matchAll(r)].reduce((t, n) => {
+		let { selectorName: r, selectorData: s } = n.groups, c = {
+			name: r.trim(),
+			variables: {},
+			attributes: {}
+		};
+		return s && [...s.replaceAll(a, "").trim().matchAll(i)].filter((e) => o.includes(e.groups.propName)).forEach((t) => {
+			let { propName: n, propValue: r } = t.groups;
+			e(c, `attributes.${n.trim()}`, r.trim());
+		}), {
+			...t,
+			[r]: c
+		};
+	}, {});
+}
+var c = (e, t) => e.some((e) => t >= e.from && t < e.to), l = (e = "") => {
+	let t = [], a, o;
+	n.lastIndex = 0;
+	let s = [];
+	for (; o = n.exec(e);) t.push({
+		from: o.index,
+		to: n.lastIndex
+	}), s.push({
+		from: o.index,
+		to: n.lastIndex
+	});
+	let l = 0;
+	for (i.lastIndex = 0; a = r.exec(e);) {
+		let n = a.index, i = r.lastIndex;
+		if (c(s, n)) continue;
+		let o = a.groups?.selectorData || "", u = e.indexOf(o, n), d = u + o.length;
+		l < n && t.push({
+			from: l,
+			to: n
+		}), n < u && t.push({
+			from: n,
+			to: u
+		}), d < i && t.push({
+			from: d,
+			to: i
+		}), l = i;
+	}
+	return t.push({
+		from: l,
+		to: e.length
+	}), t;
+};
+//#endregion
+export { s as cssToSelectors, l as getReadOnlyRangesFromContent };

package/dist/helpers/generateStyleSelector.d.ts

@@ -0,0 +1,9 @@
+import { StyleItem, TagType } from '@plitzi/sdk-shared';
+declare const generateStyleSelector: (selector: string | undefined, selectorType: TagType | undefined, values: StyleItem["attributes"] | undefined, variables: StyleItem["variables"]) => {
+    name: string;
+    type: TagType;
+    attributes: import('@plitzi/sdk-shared').StyleAttributes;
+    variables: Partial<import('@plitzi/sdk-shared').StyleVariables> | undefined;
+    cache: string;
+} | undefined;
+export default generateStyleSelector;

package/dist/helpers/generateStyleSelector.mjs

@@ -0,0 +1,19 @@
+import e from "./processSelector.mjs";
+//#region src/helpers/generateStyleSelector.ts
+var t = (t = "", n = "class", r = {}, i) => {
+	if (!(!t || typeof r != "object")) return {
+		name: t,
+		type: n,
+		attributes: r,
+		variables: i,
+		cache: e({
+			name: t,
+			type: n,
+			attributes: r,
+			variables: i,
+			cache: ""
+		})
+	};
+};
+//#endregion
+export { t as default };

package/dist/helpers/index.d.ts

@@ -0,0 +1,10 @@
+import { default as calculateInheriting } from './calculateInheriting';
+import { default as generateStyleSelector } from './generateStyleSelector';
+import { default as processCssTokens } from './processCssTokens';
+import { default as processSelector } from './processSelector';
+export * from './calculateInheriting';
+export * from './formatCssFromSelector';
+export * from './generateStyleSelector';
+export * from './processCssTokens';
+export * from './processSelector';
+export { calculateInheriting, processCssTokens, generateStyleSelector, processSelector };

package/dist/helpers/index.mjs

@@ -0,0 +1,18 @@
+import { __exportAll as e } from "../_virtual/_rolldown/runtime.mjs";
+import t, { processSelectors as n } from "./processSelector.mjs";
+import r from "./calculateInheriting.mjs";
+import i from "./generateStyleSelector.mjs";
+import a from "./processCssTokens.mjs";
+import { cssToSelectors as o, getReadOnlyRangesFromContent as s } from "./formatCssFromSelector.mjs";
+//#region src/helpers/index.ts
+var c = /* @__PURE__ */ e({
+	calculateInheriting: () => r,
+	cssToSelectors: () => o,
+	generateStyleSelector: () => i,
+	getReadOnlyRangesFromContent: () => s,
+	processCssTokens: () => a,
+	processSelector: () => t,
+	processSelectors: () => n
+});
+//#endregion
+export { r as calculateInheriting, o as cssToSelectors, i as generateStyleSelector, s as getReadOnlyRangesFromContent, c as helpers_exports, a as processCssTokens, t as processSelector, n as processSelectors };

package/dist/helpers/processCssTokens.d.ts

@@ -0,0 +1,8 @@
+type TokenMapValue = string | number | boolean;
+interface TokenMap {
+    [key: string]: TokenMapValue | TokenMap;
+}
+declare const processCssTokens: <T extends TokenMap>(cache: string, variables?: T, opts?: {
+    missing?: string;
+}) => string;
+export default processCssTokens;

package/dist/helpers/processCssTokens.mjs

@@ -0,0 +1,16 @@
+//#region src/helpers/processCssTokens.ts
+var e = (e, t = {}, n = { missing: "" }) => {
+	let r = n.missing ?? "";
+	return e.replace(/\{\{\s*([a-z0-9_\-.$]+)\s*\}\}/gi, (e, n) => {
+		let i = n.split("."), a = t;
+		for (let e of i) {
+			if (typeof a != "object" || !a) return r;
+			let t = a;
+			if (!(e in t)) return r;
+			a = t[e];
+		}
+		return typeof a == "string" || typeof a == "number" || typeof a == "boolean" ? String(a) : r;
+	});
+};
+//#endregion
+export { e as default };

package/dist/helpers/processSelector.d.ts

@@ -0,0 +1,4 @@
+import { StyleItem } from '@plitzi/sdk-shared';
+declare const processSelector: (selector: StyleItem, inline?: boolean) => string;
+export declare const processSelectors: (selectors: StyleItem[], inline?: boolean) => string[];
+export default processSelector;

package/dist/helpers/processSelector.mjs

@@ -0,0 +1,39 @@
+import e from "./processSelectorAttributes.mjs";
+import t from "./processSelectorName.mjs";
+import n from "./processSelectorVariables.mjs";
+//#region src/helpers/processSelector.ts
+var r = 2, i = (e = r) => " ".repeat(e), a = (e, t, n) => `${n || !t.length ? e : `${e}\n`}${t.join(n ? "" : "\n")}`, o = (e, t, n = !0, a = r) => {
+	let o = [], s = i(a), c = i(a + r);
+	for (let r of ["light", "dark"]) if (t[r].length) if (n) o.push(`@media(prefers-color-scheme:${r}){${e}{${t[r].join("")}}}`);
+	else {
+		let n = t[r].map((e) => `${c}${e}`).join("\n").replaceAll(":", ": ");
+		o.push(`\n@media(prefers-color-scheme: ${r}) {\n${s}${e} {\n${n}\n${s}}\n}`);
+	}
+	return o;
+}, s = (e, t, n, a, o = !0, s = r) => {
+	let l = o ? t.join("") : t.map((e) => `${i(s + r)}${e}`).join("\n").replaceAll(":", ": "), u = n ? Object.entries(n).map(([e, t]) => c(`&:${e}`, t, void 0, void 0, o, s + r)) : [], d = e.replace("plitzi__", ""), f = a ? Object.entries(a).map(([e, t]) => c(`&[data-variant="${e}"]${o ? "," : ", "}&${d}--${e}`, t.default, t.states, void 0, o, s + r)) : [];
+	if (o) return `${l}${u.join("")}${f.join("")}`;
+	let p = l ? [l] : [];
+	return u.length && p.push(u.join("\n\n")), f.length && p.push(f.join("\n\n")), p.join("\n\n");
+}, c = (e, t, n, a, o = !0, c = r) => {
+	let l = s(e, t, n, a, o, c);
+	return o ? `${e}{${l}}` : `${i(c)}${e} {\n${l}\n${i(c)}}`;
+}, l = (e, t, n = !0, i = r) => {
+	let a = [];
+	for (let [o, l] of Object.entries(t)) {
+		if (o === "base") {
+			let t = s(e, l.default, l.states, l.variants, n, i);
+			t && a.push(t);
+			continue;
+		}
+		a.push(c(`${e}-${o}`, l.default, l.states, l.variants, n, i + r));
+	}
+	return n ? `${e}{${a.join("")}}` : `${e} {\n${a.join("\n\n")}\n}`;
+}, u = (r, i = !0) => {
+	let s = t(r), c = n(r), u = e(r), d = c ? o(s, c, i) : void 0;
+	c && u.attributes.base.default.push(...c.default);
+	let f = l(s, u.attributes, i, 0);
+	return d ? a(f, d, i) : f;
+}, d = (e, t = !1) => e.map((e) => u(e, t));
+//#endregion
+export { u as default, d as processSelectors };

package/dist/helpers/processSelectorAttributes.d.ts

@@ -0,0 +1,17 @@
+import { StyleItem, StyleState } from '@plitzi/sdk-shared';
+type Attributes = Record<string, {
+    default: string[];
+    states?: Record<StyleState, string[]>;
+    variants?: Record<string, {
+        default: string[];
+        states?: Record<StyleState, string[]>;
+    }>;
+}>;
+export declare const processCssString: (attribute: string, value?: string) => {
+    variables: string[];
+    value: string;
+};
+declare function processSelectorAttributes(selector?: StyleItem): {
+    attributes: Attributes;
+};
+export default processSelectorAttributes;

package/dist/helpers/processSelectorAttributes.mjs

@@ -0,0 +1,94 @@
+//#region src/helpers/processSelectorAttributes.ts
+var e = (e, t, n = !1) => n ? t : `${e}:${t};`, t = (e) => {
+	if (!e) return [];
+	let t = [];
+	for (let [n, r] of Object.entries(e)) {
+		let e = a(n, String(r));
+		t.push(...e.variables, e.value);
+	}
+	return t;
+}, n = (t, n, r, i = !1) => {
+	let a = {
+		variables: {},
+		value: ""
+	}, o = r.replaceAll("\"", "").match(/var\((?<variableName>--[\w-]+)\)(?<extraContent>\S.+)/);
+	if (!o || !o.groups) return a.value = e(n, r, i), a;
+	let { variableName: s, extraContent: c } = o.groups, l = `${s}-parsed`, u = `var(${s})+"${c}"`;
+	return t.variables[l] && t.variables[l] !== u && (l = `${l}-${Object.keys(t.variables).length}`), a.variables[l] = u, a.value = e(n, `var(${l})`, i), a;
+}, r = (t, r, i, a, o = !1) => {
+	let s = {
+		variables: {},
+		value: ""
+	};
+	if (i === "url") {
+		let c = n(t, r, a, !0);
+		s.variables = {
+			...s.variables,
+			...c.variables
+		}, s.value = e(r, `${i}(${c.value})`, o);
+	} else s.value = e(r, `${i}(${a})`, o);
+	return s;
+}, i = (e, t, a, o = !1, s = !1) => {
+	let c = {
+		variables: {},
+		value: ""
+	}, l = a.replaceAll(";", "").match(/[a-z-]+\((?:[^()]+|\([^()]*\))*\)|[^\s]+/gi);
+	if (!o && l && l.length > 1) return l.forEach((n) => {
+		let r = i(e, t, n, !0, s);
+		c.variables = {
+			...c.variables,
+			...r.variables
+		}, c.value ? c.value = `${c.value} ${r.value}` : c.value = r.value;
+	}), c;
+	a = l?.[0] ?? a;
+	let u = a.match(/^(?!var\()\s*(?<functionName>[a-z-]+)\s*\(\s*(?<functionContent>[\s\S]*)\s*\)\s*$/i);
+	if (!u || !u.groups) return n(c, t, a, o || s);
+	let { functionName: d, functionContent: f } = u.groups;
+	return r(e, t, d, f, o || s);
+}, a = (e, t) => {
+	let n = {
+		variables: {},
+		value: ""
+	};
+	return (t?.split(/,(?![^(]*\))/).map((e) => e.trim()) ?? []).forEach((t) => {
+		let r = i(n, e, t, !1, !0);
+		n.variables = {
+			...n.variables,
+			...r.variables
+		}, n.value ? n.value = `${n.value},${r.value}` : n.value = r.value;
+	}), n.value &&= `${e}:${n.value};`, {
+		variables: Object.keys(n.variables).map((e) => `${e}:${n.variables[e]};`),
+		value: n.value
+	};
+};
+function o(e) {
+	if (!e?.attributes || !Object.keys(e.attributes).length) return { attributes: { base: { default: [] } } };
+	let n = {};
+	for (let r in e.attributes) {
+		let i = e.attributes[r], a = t(i.default), o = {};
+		if (i.states) for (let [e, n] of Object.entries(i.states)) {
+			let r = t(n);
+			r.length && (o[e] = r);
+		}
+		let s = {};
+		if (i.variants) for (let e in i.variants) {
+			let n = i.variants[e], r = t(n.default), a = {};
+			if (n.states) for (let [e, r] of Object.entries(n.states)) {
+				let n = t(r);
+				n.length && (a[e] = n);
+			}
+			s[e] = {
+				default: r,
+				...Object.keys(a).length && { states: a }
+			};
+		}
+		n[r] = {
+			default: a,
+			...Object.keys(o).length && { states: o },
+			...Object.keys(s).length && { variants: s }
+		};
+	}
+	return { attributes: n };
+}
+//#endregion
+export { o as default };

package/dist/helpers/processSelectorName.d.ts

@@ -0,0 +1,3 @@
+import { StyleItem } from '@plitzi/sdk-shared';
+declare const processSelectorName: (selector: Omit<StyleItem, "cache">) => string;
+export default processSelectorName;

package/dist/helpers/processSelectorName.mjs

@@ -0,0 +1,19 @@
+//#region src/helpers/processSelectorName.ts
+var e = (e) => {
+	let { name: t, type: n } = e, r = t;
+	switch (n) {
+		case "element":
+			r = `.plitzi__${t}`;
+			break;
+		case "class":
+			r = `.${t}`;
+			break;
+		case "id":
+			r = `#${t}`;
+			break;
+		default:
+	}
+	return r;
+};
+//#endregion
+export { e as default };

package/dist/helpers/processSelectorVariables.d.ts

@@ -0,0 +1,7 @@
+import { StyleItem } from '@plitzi/sdk-shared';
+declare const processSelectorVariables: (selector: Omit<StyleItem, "cache">) => {
+    default: string[];
+    light: string[];
+    dark: string[];
+} | undefined;
+export default processSelectorVariables;

package/dist/helpers/processSelectorVariables.mjs

@@ -0,0 +1,30 @@
+import { StyleVariableCategory as e } from "@plitzi/sdk-shared/types";
+//#region src/helpers/processSelectorVariables.ts
+var t = (t) => {
+	let { variables: n } = t;
+	if (!n || !Object.keys(n).length) return;
+	let r = {
+		default: [],
+		light: [],
+		dark: []
+	};
+	return Object.keys(n).forEach((t) => {
+		let i = n[t];
+		if (i) switch (t) {
+			case e.COLOR:
+				Object.keys(i).forEach((e) => {
+					let t = i[e];
+					r.default.push(`--${e}:${t.default};`), t.light && r.light.push(`--${e}:${t.light};`), t.dark && r.dark.push(`--${e}:${t.dark};`);
+				});
+				break;
+			case e.SPACING:
+			case e.SHADOW:
+			case e.CUSTOM:
+			default: Object.keys(i).forEach((e) => {
+				r.default.push(`--${e}:${i[e]};`);
+			});
+		}
+	}), r;
+};
+//#endregion
+export { t as default };

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { default as BuilderStyleContextProvider } from './BuilderStyleContextProvider';
+import { default as SdkStyleContextProvider } from './SdkStyleContextProvider';
+import { default as StyleAdvanceEditor } from './StyleAdvanceEditor';
+import { default as StyleContext } from './StyleContext';
+import { default as StyleMap } from './StyleMap';
+import { default as StyleReducer } from './StyleReducer';
+import * as components from './components';
+import * as helpers from './helpers';
+export * from './BuilderStyleContextProvider';
+export * from './SdkStyleContextProvider';
+export * from './components';
+export * from './StyleMap';
+export * from './StyleHelper';
+export * from './helpers';
+export * from './StyleContext';
+export * from './StyleAdvanceEditor';
+export * from './StyleReducer';
+export { StyleReducer, BuilderStyleContextProvider, SdkStyleContextProvider, StyleAdvanceEditor, StyleContext, StyleMap, components, helpers };

package/dist/index.mjs

@@ -0,0 +1,16 @@
+import e, { processSelectors as t } from "./helpers/processSelector.mjs";
+import n from "./StyleMap/index.mjs";
+import { generateCache as r, makeSelector as i, selectorToString as a } from "./StyleHelper.mjs";
+import o from "./helpers/calculateInheriting.mjs";
+import s from "./helpers/generateStyleSelector.mjs";
+import c from "./helpers/processCssTokens.mjs";
+import { cssToSelectors as l, getReadOnlyRangesFromContent as u } from "./helpers/formatCssFromSelector.mjs";
+import { helpers_exports as d } from "./helpers/index.mjs";
+import f from "./components/StyleInspector/index.mjs";
+import { components_exports as p } from "./components/index.mjs";
+import m from "./StyleContext.mjs";
+import h, { StyleActions as g } from "./StyleReducer.mjs";
+import _ from "./BuilderStyleContextProvider.mjs";
+import v from "./SdkStyleContextProvider.mjs";
+import y from "./StyleAdvanceEditor.mjs";
+export { _ as BuilderStyleContextProvider, v as SdkStyleContextProvider, g as StyleActions, y as StyleAdvanceEditor, m as StyleContext, f as StyleInspector, n as StyleMap, h as StyleReducer, o as calculateInheriting, p as components, l as cssToSelectors, r as generateCache, s as generateStyleSelector, u as getReadOnlyRangesFromContent, d as helpers, i as makeSelector, c as processCssTokens, e as processSelector, t as processSelectors, a as selectorToString };