@salty-css/core 0.1.0-refactor-add-additional-paths-to-config-cache.1 → 0.1.0

package/{parse-styles-C54MOrPg.cjs → parse-styles-BbI-2wdn.cjs}

@@ -1,5 +1,5 @@
 "use strict";
-const dashCase = require("./dash-case-DIwKaYgE.cjs");
+const toHash = require("./to-hash-DT2ImSPA.cjs");
 const viewportClamp = require("./viewport-clamp-CEmzmcSj.cjs");
 const parseValueModifiers = (modifiers) => (value) => {
   if (typeof value !== "string") return void 0;
@@ -21,7 +21,7 @@ const parseValueTokens = (tokenNames) => (value) => {
   const hasToken = /\{[^{}]+\}/g.test(value);
   if (!hasToken) return void 0;
   const transformed = value.replace(/\{([^{}]+)\}/g, (...args) => {
-    const variable = dashCase.dashCase(args[1].trim().replaceAll(".", "-"));
+    const variable = toHash.dashCase(args[1].trim().replaceAll(".", "-"));
     if (tokenNames && !tokenNames.includes(variable)) console.warn(`Token ${variable} might not exist`);
     if (variable.startsWith("-")) return `-${variable}`;
     return `var(--${variable})`;
@@ -84,8 +84,8 @@ const isVendorPrefixed = (key) => {
 };
 const propertyNameCheck = (key) => {
   if (key.startsWith("-")) return key;
-  if (isVendorPrefixed(key)) return `-${dashCase.dashCase(key)}`;
-  return dashCase.dashCase(key);
+  if (isVendorPrefixed(key)) return `-${toHash.dashCase(key)}`;
+  return toHash.dashCase(key);
 };
 const reportParserIssue = (strict, message) => {
   if (strict === true) throw new Error(`[salty-css] ${message}`);
@@ -94,6 +94,171 @@ const reportParserIssue = (strict, message) => {
 const pseudoTypoRegex = /^&(hover|focus(-(visible|within))?|active|visited|checked|disabled|enabled|empty|target|first-child|last-child|first-of-type|last-of-type|placeholder|placeholder-shown|root)\b/;
 const templateLiteralLeftoverRegex = /\$\{[^}]+\}/;
 const bareAtRuleRegex = /^@(media|supports|container|layer)\s*$/;
+const keyframesAtRuleRegex = /^@(?:-(?:webkit|moz|o|ms)-)?keyframes\b/;
+const isRichTemplateNode = (node) => {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) return false;
+  const keys = Object.keys(node);
+  return keys.includes("base") || keys.includes("variants");
+};
+const parseTemplateCallSite = (value) => {
+  if (typeof value === "string") {
+    const [rawPath, rawQuery] = value.split("@", 2);
+    const path = rawPath.split(".").filter(Boolean);
+    if (!path.length) return void 0;
+    const variants = {};
+    if (rawQuery) {
+      for (const segment of rawQuery.split("&")) {
+        if (!segment) continue;
+        const eq = segment.indexOf("=");
+        if (eq === -1) {
+          variants[segment.trim()] = true;
+        } else {
+          const axis = segment.slice(0, eq).trim();
+          const raw = segment.slice(eq + 1).trim();
+          if (!axis) continue;
+          if (raw === "true") variants[axis] = true;
+          else if (raw === "false") variants[axis] = false;
+          else variants[axis] = raw;
+        }
+      }
+    }
+    return { path, variants };
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    const name = obj["name"];
+    if (typeof name !== "string") return void 0;
+    const path = name.split(".").filter(Boolean);
+    if (!path.length) return void 0;
+    const variants = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (k === "name") continue;
+      if (typeof v === "string" || typeof v === "boolean") variants[k] = v;
+    }
+    return { path, variants };
+  }
+  return void 0;
+};
+const normalizeAxisValue = (v) => {
+  if (v === void 0) return void 0;
+  return typeof v === "boolean" ? String(v) : v;
+};
+const buildPathStack = (root, path) => {
+  const stack = [{ node: root, isRich: isRichTemplateNode(root) }];
+  let cursor = root;
+  for (const segment of path) {
+    if (cursor == null || typeof cursor !== "object") return void 0;
+    const next = cursor[segment];
+    if (next === void 0) return void 0;
+    stack.push({ node: next, isRich: isRichTemplateNode(next) });
+    cursor = next;
+  }
+  return stack;
+};
+const pathHasRichNode = (root, path) => {
+  const stack = buildPathStack(root, path);
+  if (!stack) return false;
+  return stack.some((entry) => entry.isRich);
+};
+const matchesAll = (entry, effective) => {
+  for (const [axis, raw] of Object.entries(entry)) {
+    if (axis === "css") continue;
+    if (effective[axis] !== normalizeAxisValue(raw)) return false;
+  }
+  return true;
+};
+const matchesAny = (entry, effective) => {
+  let any = false;
+  for (const [axis, raw] of Object.entries(entry)) {
+    if (axis === "css") continue;
+    any = true;
+    if (effective[axis] === normalizeAxisValue(raw)) return true;
+  }
+  return !any;
+};
+const resolveRichTemplate = (root, path, callSiteVariants, templateName) => {
+  var _a, _b, _c, _d;
+  const stack = buildPathStack(root, path);
+  if (!stack) return void 0;
+  const rich = stack.map((entry) => {
+    if (entry.isRich) return entry.node;
+    if (entry.node && typeof entry.node === "object" && !Array.isArray(entry.node)) {
+      const onlyChildKeys = Object.keys(entry.node).every((k) => entry.node[k] && typeof entry.node[k] === "object" && !isRichTemplateNode(entry.node[k]));
+      return onlyChildKeys ? {} : { base: entry.node };
+    }
+    return {};
+  });
+  const declaredAxes = /* @__PURE__ */ new Set();
+  for (const r of rich) {
+    if (r.variants) for (const k of Object.keys(r.variants)) declaredAxes.add(k);
+  }
+  for (const r of rich) {
+    if (r.defaultVariants) for (const k of Object.keys(r.defaultVariants)) declaredAxes.add(k);
+  }
+  const effective = {};
+  for (const axis of declaredAxes) {
+    if (axis in callSiteVariants) {
+      effective[axis] = normalizeAxisValue(callSiteVariants[axis]);
+      continue;
+    }
+    for (let i = rich.length - 1; i >= 0; i--) {
+      const d = (_a = rich[i].defaultVariants) == null ? void 0 : _a[axis];
+      if (d !== void 0) {
+        effective[axis] = normalizeAxisValue(d);
+        break;
+      }
+    }
+  }
+  for (const [axis, raw] of Object.entries(callSiteVariants)) {
+    if (!declaredAxes.has(axis)) {
+      console.warn(`Template "${templateName}" path "${path.join(".")}" has no variant axis "${axis}"; ignored.`);
+      continue;
+    }
+    const wanted = normalizeAxisValue(raw);
+    let found = false;
+    for (const r of rich) {
+      if (((_b = r.variants) == null ? void 0 : _b[axis]) && wanted !== void 0 && wanted in r.variants[axis]) {
+        found = true;
+        break;
+      }
+    }
+    if (!found && wanted !== void 0) {
+      const anyBundle = rich.some((r) => r.variants && axis in r.variants);
+      if (anyBundle) {
+        console.warn(`Template "${templateName}" axis "${axis}" has no value "${wanted}" on path "${path.join(".")}"; ignored.`);
+      }
+    }
+  }
+  const acc = {};
+  for (const r of rich) {
+    if (r.base) Object.assign(acc, r.base);
+  }
+  for (const axis of Object.keys(effective)) {
+    const value = effective[axis];
+    if (value === void 0) continue;
+    for (let i = rich.length - 1; i >= 0; i--) {
+      const bundle = (_d = (_c = rich[i].variants) == null ? void 0 : _c[axis]) == null ? void 0 : _d[value];
+      if (bundle) {
+        Object.assign(acc, bundle);
+        break;
+      }
+    }
+  }
+  for (const r of rich) {
+    if (r.compoundVariants) {
+      for (const entry of r.compoundVariants) {
+        if (matchesAll(entry, effective) && entry.css) Object.assign(acc, entry.css);
+      }
+    }
+    if (r.anyOfVariants) {
+      for (const entry of r.anyOfVariants) {
+        if (matchesAny(entry, effective) && entry.css) Object.assign(acc, entry.css);
+      }
+    }
+  }
+  return acc;
+};
 const parseStyles = async (styles, currentScope = "", config, omitTemplates = false) => {
   if (!styles) throw new Error("No styles provided to parseStyles function!");
   const cssStyles = /* @__PURE__ */ new Set();
@@ -137,13 +302,29 @@ const parseStyles = async (styles, currentScope = "", config, omitTemplates = fa
     }
     if ((config == null ? void 0 : config.templates) && config.templates[_key]) {
       if (omitTemplates) return void 0;
-      const path = value.split(".");
-      const templateStyles = path.reduce((acc, key2) => acc[key2], config.templates[_key]);
-      if (templateStyles) {
-        const [result] = await parseStyles(templateStyles, "");
-        return result;
+      const root = config.templates[_key];
+      const callSite = parseTemplateCallSite(value);
+      if (callSite) {
+        const { path, variants } = callSite;
+        const hasCallSiteVariants = Object.keys(variants).length > 0;
+        if (hasCallSiteVariants || pathHasRichNode(root, path)) {
+          const resolved2 = resolveRichTemplate(root, path, variants, _key);
+          if (resolved2) {
+            const [result] = await parseStyles(resolved2, "");
+            return result;
+          }
+          console.warn(`Template "${_key}" with path of "${path.join(".")}" was not found in config!`);
+          return void 0;
+        }
+        const templateStyles = path.reduce((acc, key2) => acc == null ? void 0 : acc[key2], root);
+        if (templateStyles) {
+          const [result] = await parseStyles(templateStyles, "");
+          return result;
+        }
+        console.warn(`Template "${_key}" with path of "${path.join(".")}" was not found in config!`);
+        return void 0;
       }
-      console.warn(`Template "${_key}" with path of "${value}" was not found in config!`);
+      console.warn(`Template "${_key}" received an unsupported call-site value.`);
       return void 0;
     }
     const isVariantArrayKey = _key === "compoundVariants" || _key === "anyOfVariants";
@@ -154,6 +335,7 @@ const parseStyles = async (styles, currentScope = "", config, omitTemplates = fa
     if (typeof value === "object") {
       if (!value) return void 0;
       if (value.isColor) return toString(value.toString());
+      if (value.isDefineFont) return toString(value.toString());
       if (_key === "defaultVariants") return void 0;
       if (_key === "variants") {
         const variantEntries = Object.entries(value);
@@ -194,8 +376,9 @@ const parseStyles = async (styles, currentScope = "", config, omitTemplates = fa
       }
       if (_key.startsWith("@")) {
         if (bareAtRuleRegex.test(_key)) reportParserIssue(strict, `At-rule "${_key}" is missing its condition (e.g. "@media (min-width: 600px)").`);
+        const innerScope = keyframesAtRuleRegex.test(_key) ? "" : currentScope;
         const mediaQuery = ((_b = config == null ? void 0 : config.mediaQueries) == null ? void 0 : _b[_key]) || _key;
-        const results2 = await parseAndJoinStyles(value, currentScope, config);
+        const results2 = await parseAndJoinStyles(value, innerScope, config);
         const query = `${mediaQuery} { ${results2} }`;
         cssStyles.add(query);
         return void 0;
@@ -322,8 +505,10 @@ const combineSelectors = (currentScope, key) => {
   }
   return combos.join(", ");
 };
+exports.isRichTemplateNode = isRichTemplateNode;
 exports.parseAndJoinStyles = parseAndJoinStyles;
 exports.parseStyles = parseStyles;
+exports.parseTemplateCallSite = parseTemplateCallSite;
 exports.parseValueModifiers = parseValueModifiers;
 exports.parseValueTokens = parseValueTokens;
 exports.parseVariableTokens = parseVariableTokens;

package/{parse-styles-CLMTHo2H.js → parse-styles-BgVqQAni.js}

@@ -1,4 +1,4 @@
-import { d as dashCase } from "./dash-case-DblXvymC.js";
+import { d as dashCase } from "./to-hash-DSoCPs8D.js";
 import { d as defineViewportClamp } from "./viewport-clamp-K553uXu3.js";
 const parseValueModifiers = (modifiers) => (value) => {
   if (typeof value !== "string") return void 0;
@@ -93,6 +93,171 @@ const reportParserIssue = (strict, message) => {
 const pseudoTypoRegex = /^&(hover|focus(-(visible|within))?|active|visited|checked|disabled|enabled|empty|target|first-child|last-child|first-of-type|last-of-type|placeholder|placeholder-shown|root)\b/;
 const templateLiteralLeftoverRegex = /\$\{[^}]+\}/;
 const bareAtRuleRegex = /^@(media|supports|container|layer)\s*$/;
+const keyframesAtRuleRegex = /^@(?:-(?:webkit|moz|o|ms)-)?keyframes\b/;
+const isRichTemplateNode = (node) => {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) return false;
+  const keys = Object.keys(node);
+  return keys.includes("base") || keys.includes("variants");
+};
+const parseTemplateCallSite = (value) => {
+  if (typeof value === "string") {
+    const [rawPath, rawQuery] = value.split("@", 2);
+    const path = rawPath.split(".").filter(Boolean);
+    if (!path.length) return void 0;
+    const variants = {};
+    if (rawQuery) {
+      for (const segment of rawQuery.split("&")) {
+        if (!segment) continue;
+        const eq = segment.indexOf("=");
+        if (eq === -1) {
+          variants[segment.trim()] = true;
+        } else {
+          const axis = segment.slice(0, eq).trim();
+          const raw = segment.slice(eq + 1).trim();
+          if (!axis) continue;
+          if (raw === "true") variants[axis] = true;
+          else if (raw === "false") variants[axis] = false;
+          else variants[axis] = raw;
+        }
+      }
+    }
+    return { path, variants };
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    const name = obj["name"];
+    if (typeof name !== "string") return void 0;
+    const path = name.split(".").filter(Boolean);
+    if (!path.length) return void 0;
+    const variants = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (k === "name") continue;
+      if (typeof v === "string" || typeof v === "boolean") variants[k] = v;
+    }
+    return { path, variants };
+  }
+  return void 0;
+};
+const normalizeAxisValue = (v) => {
+  if (v === void 0) return void 0;
+  return typeof v === "boolean" ? String(v) : v;
+};
+const buildPathStack = (root, path) => {
+  const stack = [{ node: root, isRich: isRichTemplateNode(root) }];
+  let cursor = root;
+  for (const segment of path) {
+    if (cursor == null || typeof cursor !== "object") return void 0;
+    const next = cursor[segment];
+    if (next === void 0) return void 0;
+    stack.push({ node: next, isRich: isRichTemplateNode(next) });
+    cursor = next;
+  }
+  return stack;
+};
+const pathHasRichNode = (root, path) => {
+  const stack = buildPathStack(root, path);
+  if (!stack) return false;
+  return stack.some((entry) => entry.isRich);
+};
+const matchesAll = (entry, effective) => {
+  for (const [axis, raw] of Object.entries(entry)) {
+    if (axis === "css") continue;
+    if (effective[axis] !== normalizeAxisValue(raw)) return false;
+  }
+  return true;
+};
+const matchesAny = (entry, effective) => {
+  let any = false;
+  for (const [axis, raw] of Object.entries(entry)) {
+    if (axis === "css") continue;
+    any = true;
+    if (effective[axis] === normalizeAxisValue(raw)) return true;
+  }
+  return !any;
+};
+const resolveRichTemplate = (root, path, callSiteVariants, templateName) => {
+  var _a, _b, _c, _d;
+  const stack = buildPathStack(root, path);
+  if (!stack) return void 0;
+  const rich = stack.map((entry) => {
+    if (entry.isRich) return entry.node;
+    if (entry.node && typeof entry.node === "object" && !Array.isArray(entry.node)) {
+      const onlyChildKeys = Object.keys(entry.node).every((k) => entry.node[k] && typeof entry.node[k] === "object" && !isRichTemplateNode(entry.node[k]));
+      return onlyChildKeys ? {} : { base: entry.node };
+    }
+    return {};
+  });
+  const declaredAxes = /* @__PURE__ */ new Set();
+  for (const r of rich) {
+    if (r.variants) for (const k of Object.keys(r.variants)) declaredAxes.add(k);
+  }
+  for (const r of rich) {
+    if (r.defaultVariants) for (const k of Object.keys(r.defaultVariants)) declaredAxes.add(k);
+  }
+  const effective = {};
+  for (const axis of declaredAxes) {
+    if (axis in callSiteVariants) {
+      effective[axis] = normalizeAxisValue(callSiteVariants[axis]);
+      continue;
+    }
+    for (let i = rich.length - 1; i >= 0; i--) {
+      const d = (_a = rich[i].defaultVariants) == null ? void 0 : _a[axis];
+      if (d !== void 0) {
+        effective[axis] = normalizeAxisValue(d);
+        break;
+      }
+    }
+  }
+  for (const [axis, raw] of Object.entries(callSiteVariants)) {
+    if (!declaredAxes.has(axis)) {
+      console.warn(`Template "${templateName}" path "${path.join(".")}" has no variant axis "${axis}"; ignored.`);
+      continue;
+    }
+    const wanted = normalizeAxisValue(raw);
+    let found = false;
+    for (const r of rich) {
+      if (((_b = r.variants) == null ? void 0 : _b[axis]) && wanted !== void 0 && wanted in r.variants[axis]) {
+        found = true;
+        break;
+      }
+    }
+    if (!found && wanted !== void 0) {
+      const anyBundle = rich.some((r) => r.variants && axis in r.variants);
+      if (anyBundle) {
+        console.warn(`Template "${templateName}" axis "${axis}" has no value "${wanted}" on path "${path.join(".")}"; ignored.`);
+      }
+    }
+  }
+  const acc = {};
+  for (const r of rich) {
+    if (r.base) Object.assign(acc, r.base);
+  }
+  for (const axis of Object.keys(effective)) {
+    const value = effective[axis];
+    if (value === void 0) continue;
+    for (let i = rich.length - 1; i >= 0; i--) {
+      const bundle = (_d = (_c = rich[i].variants) == null ? void 0 : _c[axis]) == null ? void 0 : _d[value];
+      if (bundle) {
+        Object.assign(acc, bundle);
+        break;
+      }
+    }
+  }
+  for (const r of rich) {
+    if (r.compoundVariants) {
+      for (const entry of r.compoundVariants) {
+        if (matchesAll(entry, effective) && entry.css) Object.assign(acc, entry.css);
+      }
+    }
+    if (r.anyOfVariants) {
+      for (const entry of r.anyOfVariants) {
+        if (matchesAny(entry, effective) && entry.css) Object.assign(acc, entry.css);
+      }
+    }
+  }
+  return acc;
+};
 const parseStyles = async (styles, currentScope = "", config, omitTemplates = false) => {
   if (!styles) throw new Error("No styles provided to parseStyles function!");
   const cssStyles = /* @__PURE__ */ new Set();
@@ -136,13 +301,29 @@ const parseStyles = async (styles, currentScope = "", config, omitTemplates = fa
     }
     if ((config == null ? void 0 : config.templates) && config.templates[_key]) {
       if (omitTemplates) return void 0;
-      const path = value.split(".");
-      const templateStyles = path.reduce((acc, key2) => acc[key2], config.templates[_key]);
-      if (templateStyles) {
-        const [result] = await parseStyles(templateStyles, "");
-        return result;
+      const root = config.templates[_key];
+      const callSite = parseTemplateCallSite(value);
+      if (callSite) {
+        const { path, variants } = callSite;
+        const hasCallSiteVariants = Object.keys(variants).length > 0;
+        if (hasCallSiteVariants || pathHasRichNode(root, path)) {
+          const resolved2 = resolveRichTemplate(root, path, variants, _key);
+          if (resolved2) {
+            const [result] = await parseStyles(resolved2, "");
+            return result;
+          }
+          console.warn(`Template "${_key}" with path of "${path.join(".")}" was not found in config!`);
+          return void 0;
+        }
+        const templateStyles = path.reduce((acc, key2) => acc == null ? void 0 : acc[key2], root);
+        if (templateStyles) {
+          const [result] = await parseStyles(templateStyles, "");
+          return result;
+        }
+        console.warn(`Template "${_key}" with path of "${path.join(".")}" was not found in config!`);
+        return void 0;
       }
-      console.warn(`Template "${_key}" with path of "${value}" was not found in config!`);
+      console.warn(`Template "${_key}" received an unsupported call-site value.`);
       return void 0;
     }
     const isVariantArrayKey = _key === "compoundVariants" || _key === "anyOfVariants";
@@ -153,6 +334,7 @@ const parseStyles = async (styles, currentScope = "", config, omitTemplates = fa
     if (typeof value === "object") {
       if (!value) return void 0;
       if (value.isColor) return toString(value.toString());
+      if (value.isDefineFont) return toString(value.toString());
       if (_key === "defaultVariants") return void 0;
       if (_key === "variants") {
         const variantEntries = Object.entries(value);
@@ -193,8 +375,9 @@ const parseStyles = async (styles, currentScope = "", config, omitTemplates = fa
       }
       if (_key.startsWith("@")) {
         if (bareAtRuleRegex.test(_key)) reportParserIssue(strict, `At-rule "${_key}" is missing its condition (e.g. "@media (min-width: 600px)").`);
+        const innerScope = keyframesAtRuleRegex.test(_key) ? "" : currentScope;
         const mediaQuery = ((_b = config == null ? void 0 : config.mediaQueries) == null ? void 0 : _b[_key]) || _key;
-        const results2 = await parseAndJoinStyles(value, currentScope, config);
+        const results2 = await parseAndJoinStyles(value, innerScope, config);
         const query = `${mediaQuery} { ${results2} }`;
         cssStyles.add(query);
         return void 0;
@@ -323,9 +506,11 @@ const combineSelectors = (currentScope, key) => {
 };
 export {
   parseStyles as a,
-  parseVariableTokens as b,
-  parseValueModifiers as c,
-  parseValueTokens as d,
+  parseTemplateCallSite as b,
+  parseVariableTokens as c,
+  parseValueModifiers as d,
+  parseValueTokens as e,
+  isRichTemplateNode as i,
   parseAndJoinStyles as p,
   reportParserIssue as r
 };

package/parsers/index.cjs

@@ -1,11 +1,42 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const parseStyles = require("../parse-styles-C54MOrPg.cjs");
-const dashCase = require("../dash-case-DIwKaYgE.cjs");
-const toHash = require("../to-hash-C05Y906F.cjs");
+const parseStyles = require("../parse-styles-BbI-2wdn.cjs");
+const toHash = require("../to-hash-DT2ImSPA.cjs");
+const RICH_META_KEYS = /* @__PURE__ */ new Set(["base", "variants", "defaultVariants", "compoundVariants", "anyOfVariants"]);
+const isChildEntry = (key, value) => {
+  if (RICH_META_KEYS.has(key)) return false;
+  return !!value && typeof value === "object" && !Array.isArray(value);
+};
 const parseTemplates = async (obj, path = []) => {
   if (!obj) return "";
   const classes = [];
+  if (parseStyles.isRichTemplateNode(obj)) {
+    const rich = obj;
+    const baseClassName = path.map((p) => toHash.dashCase(String(p))).join("-");
+    if (rich.base) {
+      const hashClass = "t_" + toHash.toHash(baseClassName, 4);
+      const result = await parseStyles.parseAndJoinStyles(rich.base, `.${baseClassName}, .${hashClass}`);
+      classes.push(result);
+    }
+    if (rich.variants) {
+      for (const [axis, valueMap] of Object.entries(rich.variants)) {
+        if (!valueMap || typeof valueMap !== "object") continue;
+        for (const [value, styles] of Object.entries(valueMap)) {
+          if (!styles || typeof styles !== "object") continue;
+          const variantClassName = `${baseClassName}-${toHash.dashCase(axis)}-${toHash.dashCase(value)}`;
+          const variantHashClass = "tv_" + toHash.toHash(variantClassName, 4);
+          const result = await parseStyles.parseAndJoinStyles(styles, `.${variantClassName}, .${variantHashClass}`);
+          classes.push(result);
+        }
+      }
+    }
+    for (const [key, value] of Object.entries(rich)) {
+      if (!isChildEntry(key, value)) continue;
+      const result = await parseTemplates(value, [...path, key.trim()]);
+      classes.push(result);
+    }
+    return classes.join("\n");
+  }
   const levelStyles = {};
   for (const [key, value] of Object.entries(obj)) {
     if (typeof value === "function") ;
@@ -18,7 +49,7 @@ const parseTemplates = async (obj, path = []) => {
     }
   }
   if (Object.keys(levelStyles).length) {
-    const className = path.map(dashCase.dashCase).join("-");
+    const className = path.map((p) => toHash.dashCase(String(p))).join("-");
     const hashClass = "t_" + toHash.toHash(className, 4);
     const result = await parseStyles.parseAndJoinStyles(levelStyles, `.${className}, .${hashClass}`);
     classes.push(result);
@@ -40,13 +71,69 @@ const getTemplateTypes = (templates) => {
 };
 const getTemplateTokens = (templates, parent = "", templateTokens = /* @__PURE__ */ new Set()) => {
   if (!templates) return [];
+  if (parseStyles.isRichTemplateNode(templates)) {
+    if (parent) templateTokens.add(parent);
+    Object.entries(templates).forEach(([key, value]) => {
+      if (!isChildEntry(key, value)) return;
+      const keyValue = parent ? `${parent}.${key}` : key;
+      getTemplateTokens(value, keyValue, templateTokens);
+    });
+    return [...templateTokens];
+  }
   Object.entries(templates).forEach(([key, value]) => {
     const keyValue = parent ? `${parent}.${key}` : key;
-    if (typeof value === "object") return getTemplateTokens(value, keyValue, templateTokens);
+    if (value && typeof value === "object") return getTemplateTokens(value, keyValue, templateTokens);
     return templateTokens.add(parent);
   });
   return [...templateTokens];
 };
+const getTemplateVariantMaps = (templates) => {
+  const result = {};
+  if (!templates) return result;
+  for (const [topKey, topNode] of Object.entries(templates)) {
+    if (!topNode || typeof topNode !== "object" || typeof topNode === "function") continue;
+    walk(topNode, [], result[topKey] || (result[topKey] = {}), {});
+  }
+  return result;
+};
+const mergeAxes = (inherited, node) => {
+  const next = {};
+  for (const [axis, vals] of Object.entries(inherited)) {
+    next[axis] = { ...vals };
+  }
+  if (parseStyles.isRichTemplateNode(node) && node.variants) {
+    for (const [axis, valueMap] of Object.entries(node.variants)) {
+      next[axis] = next[axis] || {};
+      for (const value of Object.keys(valueMap)) next[axis][value] = true;
+    }
+  }
+  return next;
+};
+const walk = (node, path, out, inheritedAxes) => {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return;
+  const axes = mergeAxes(inheritedAxes, node);
+  const dot = path.join(".");
+  if (path.length && (parseStyles.isRichTemplateNode(node) || Object.keys(axes).length)) {
+    const axisMap = {};
+    for (const [axis, valSet] of Object.entries(axes)) {
+      const values = Object.keys(valSet);
+      const isBooleanOnly = values.length === 1 && values[0] === "true";
+      axisMap[axis] = isBooleanOnly ? "boolean" : values.map((v) => `"${v}"`).join(" | ");
+    }
+    if (Object.keys(axisMap).length) out[dot] = axisMap;
+  }
+  if (parseStyles.isRichTemplateNode(node)) {
+    for (const [key, value] of Object.entries(node)) {
+      if (!isChildEntry(key, value)) continue;
+      walk(value, [...path, key.trim()], out, axes);
+    }
+    return;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+    walk(value, [...path, key.trim()], out, axes);
+  }
+};
 exports.parseAndJoinStyles = parseStyles.parseAndJoinStyles;
 exports.parseStyles = parseStyles.parseStyles;
 exports.parseValueModifiers = parseStyles.parseValueModifiers;
@@ -56,4 +143,5 @@ exports.reportParserIssue = parseStyles.reportParserIssue;
 exports.getTemplateKeys = getTemplateKeys;
 exports.getTemplateTokens = getTemplateTokens;
 exports.getTemplateTypes = getTemplateTypes;
+exports.getTemplateVariantMaps = getTemplateVariantMaps;
 exports.parseTemplates = parseTemplates;