@salty-css/core 0.1.0-alpha.26 → 0.1.0-alpha.28

package/parsers/index.cjs

@@ -1,11 +1,31 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const parseStyles = require("../parse-styles-jPtMfgXH.cjs");
+const parseStyles = require("../parse-styles-BFoV7HiL.cjs");
 const dashCase = require("../dash-case-DIwKaYgE.cjs");
 const toHash = require("../to-hash-C05Y906F.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;
+    if (rich.base) {
+      const className = path.map((p) => dashCase.dashCase(String(p))).join("-");
+      const hashClass = "t_" + toHash.toHash(className, 4);
+      const result = await parseStyles.parseAndJoinStyles(rich.base, `.${className}, .${hashClass}`);
+      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 +38,7 @@ const parseTemplates = async (obj, path = []) => {
     }
   }
   if (Object.keys(levelStyles).length) {
-    const className = path.map(dashCase.dashCase).join("-");
+    const className = path.map((p) => dashCase.dashCase(String(p))).join("-");
     const hashClass = "t_" + toHash.toHash(className, 4);
     const result = await parseStyles.parseAndJoinStyles(levelStyles, `.${className}, .${hashClass}`);
     classes.push(result);
@@ -40,13 +60,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 +132,5 @@ exports.reportParserIssue = parseStyles.reportParserIssue;
 exports.getTemplateKeys = getTemplateKeys;
 exports.getTemplateTokens = getTemplateTokens;
 exports.getTemplateTypes = getTemplateTypes;
+exports.getTemplateVariantMaps = getTemplateVariantMaps;
 exports.parseTemplates = parseTemplates;

package/parsers/index.js

@@ -1,10 +1,30 @@
-import { p as parseAndJoinStyles } from "../parse-styles--vHKY6Mw.js";
-import { a, c, d, b, r } from "../parse-styles--vHKY6Mw.js";
+import { i as isRichTemplateNode, p as parseAndJoinStyles } from "../parse-styles-CtA-RKqt.js";
+import { a, c, d, b, r } from "../parse-styles-CtA-RKqt.js";
 import { d as dashCase } from "../dash-case-DblXvymC.js";
 import { t as toHash } from "../to-hash-DAN2LcHK.js";
+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 (isRichTemplateNode(obj)) {
+    const rich = obj;
+    if (rich.base) {
+      const className = path.map((p) => dashCase(String(p))).join("-");
+      const hashClass = "t_" + toHash(className, 4);
+      const result = await parseAndJoinStyles(rich.base, `.${className}, .${hashClass}`);
+      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") ;
@@ -17,7 +37,7 @@ const parseTemplates = async (obj, path = []) => {
     }
   }
   if (Object.keys(levelStyles).length) {
-    const className = path.map(dashCase).join("-");
+    const className = path.map((p) => dashCase(String(p))).join("-");
     const hashClass = "t_" + toHash(className, 4);
     const result = await parseAndJoinStyles(levelStyles, `.${className}, .${hashClass}`);
     classes.push(result);
@@ -39,17 +59,74 @@ const getTemplateTypes = (templates) => {
 };
 const getTemplateTokens = (templates, parent = "", templateTokens = /* @__PURE__ */ new Set()) => {
   if (!templates) return [];
+  if (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 (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 && (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 (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);
+  }
+};
 export {
   getTemplateKeys,
   getTemplateTokens,
   getTemplateTypes,
+  getTemplateVariantMaps,
   parseAndJoinStyles,
   a as parseStyles,
   parseTemplates,

package/parsers/parse-templates.d.ts

@@ -2,3 +2,13 @@ export declare const parseTemplates: <T extends object>(obj: T, path?: PropertyK
 export declare const getTemplateKeys: <T extends object>(templates: T) => string[];
 export declare const getTemplateTypes: <T extends object>(templates: T) => Record<string, string>;
 export declare const getTemplateTokens: <T extends object>(templates: T, parent?: string, templateTokens?: Set<string>) => string[];
+/**
+ * Walk every rich-template path in a templates root and emit, for each reachable dot-path, the set of
+ * variant axes valid at that path (axis name → union of value names, with `boolean` for axes whose only
+ * declared value is `true`).
+ *
+ * Inheritance: a leaf's axis enum is the union of its own values and every ancestor's values for the
+ * same axis. Matches the resolver's bottom-up lookup semantics — anything reachable via fallback is a
+ * valid call-site value.
+ */
+export declare const getTemplateVariantMaps: (templates: Record<string, any>) => Record<string, Record<string, Record<string, string>>>;

package/parsers/resolve-template-variants.d.ts

@@ -0,0 +1,21 @@
+import { RichTemplateNode } from '../types/config-types';
+export type TemplateCallSite = {
+    path: string[];
+    variants: Record<string, string | boolean>;
+};
+export declare const isRichTemplateNode: (node: unknown) => node is RichTemplateNode;
+/**
+ * Parse a template call-site value into its dot-path and the axis values requested at the call site.
+ *
+ * String form:  `'heading.large@weight=heavy&emphasis=loud&italic'`
+ * Object form:  `{ name: 'heading.large', weight: 'heavy', emphasis: 'loud', italic: true }`
+ */
+export declare const parseTemplateCallSite: (value: unknown) => TemplateCallSite | undefined;
+export declare const pathHasRichNode: (root: any, path: string[]) => boolean;
+/**
+ * Resolve a rich-template invocation into a flat CSS-in-JS object.
+ * Implements docs/template-variants-spec.md §5 (parent-to-leaf inheritance, replace semantics).
+ *
+ * Returns `undefined` if the path doesn't resolve. Emits console.warn for unknown axes / values.
+ */
+export declare const resolveRichTemplate: (root: any, path: string[], callSiteVariants: Record<string, string | boolean>, templateName: string) => Record<string, any> | undefined;

package/runtime/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const parseStyles = require("../parse-styles-jPtMfgXH.cjs");
+const parseStyles = require("../parse-styles-BFoV7HiL.cjs");
 const defineRuntime = (config) => {
   const getDynamicStylesCss = async (styles, scope) => {
     const parsed = await parseStyles.parseStyles(styles, scope, config);

package/runtime/index.js

@@ -1,4 +1,4 @@
-import { a as parseStyles } from "../parse-styles--vHKY6Mw.js";
+import { a as parseStyles } from "../parse-styles-CtA-RKqt.js";
 const defineRuntime = (config) => {
   const getDynamicStylesCss = async (styles, scope) => {
     const parsed = await parseStyles(styles, scope, config);

package/types/config-types.d.ts

@@ -16,7 +16,38 @@ export interface SaltyVariables {
     conditional?: CssConditionalVariables;
     [key: string]: undefined | string | number | CssVariableTokensObject;
 }
-type CssTemplate = MediaQueryStyles | CssStyles | {
+/**
+ * A variant axis value bundle: a map from axis name to a map from value name (string keys or `'true'`)
+ * to a CSS-in-JS block. `name` is reserved as the call-site object form's path key and cannot be used
+ * as an axis name (build-time error).
+ */
+export type CssVariantAxes = {
+    [axis: string]: {
+        [value: string]: CssStyles;
+    };
+} & {
+    name?: never;
+};
+export interface CssCompoundVariant {
+    css: CssStyles;
+    [axis: string]: any;
+}
+/**
+ * A "rich" template node: declares its own base styles, named variant bundles, defaults, and compound rules.
+ * May coexist with child template nodes (descendants) as additional sibling keys.
+ */
+export type RichTemplateNode = {
+    base?: CssStyles;
+    variants?: CssVariantAxes;
+    defaultVariants?: {
+        [axis: string]: string | boolean;
+    };
+    compoundVariants?: CssCompoundVariant[];
+    anyOfVariants?: CssCompoundVariant[];
+} & {
+    [key: PropertyKey]: any;
+};
+type CssTemplate = MediaQueryStyles | CssStyles | RichTemplateNode | {
     [key: PropertyKey]: CssTemplate;
 };
 export interface CssTemplateObject {