@pandacss/config 0.37.0 → 0.37.1

package/dist/index.js

@@ -600,7 +600,7 @@ async function getResolvedConfig(config, cwd) {
 
 // src/resolve-config.ts
 var import_logger4 = require("@pandacss/logger");
-var import_shared9 = require("@pandacss/shared");
+var import_shared10 = require("@pandacss/shared");
 
 // src/bundled-preset.ts
 var import_preset_base = require("@pandacss/preset-base");
@@ -618,21 +618,21 @@ var getBundledPreset = (preset) => {
 
 // src/validate-config.ts
 var import_logger3 = require("@pandacss/logger");
-var import_shared8 = require("@pandacss/shared");
+var import_shared9 = require("@pandacss/shared");
 
 // src/validation/validate-artifact.ts
 var validateArtifactNames = (names, addError) => {
   names.recipes.forEach((recipeName) => {
     if (names.slotRecipes.has(recipeName)) {
-      addError("recipes", `This recipe name is already used in \`config.theme.slotRecipes\`: ${recipeName}`);
+      addError("recipes", `This recipe name is already used in \`theme.slotRecipes\`: ${recipeName}`);
     }
     if (names.patterns.has(recipeName)) {
-      addError("recipes", `This recipe name is already used in \`config.patterns\`: \`${recipeName}\``);
+      addError("recipes", `This recipe name is already used in \`patterns\`: \`${recipeName}\``);
     }
   });
   names.slotRecipes.forEach((recipeName) => {
     if (names.patterns.has(recipeName)) {
-      addError("recipes", `This recipe name is already used in \`config.patterns\`: ${recipeName}`);
+      addError("recipes", `This recipe name is already used in \`patterns\`: ${recipeName}`);
     }
   });
 };
@@ -704,16 +704,42 @@ var validateRecipes = (options) => {
 };
 
 // src/validation/validate-tokens.ts
-var import_shared7 = require("@pandacss/shared");
+var import_shared8 = require("@pandacss/shared");
 
 // src/validation/utils.ts
+var import_shared7 = require("@pandacss/shared");
+var REFERENCE_REGEX = /({([^}]*)})/g;
+var curlyBracketRegex = /[{}]/g;
 var isValidToken = (token) => Object.hasOwnProperty.call(token, "value");
-var isTokenReference = (value) => typeof value === "string" && value.startsWith("{");
+var isTokenReference = (value) => typeof value === "string" && REFERENCE_REGEX.test(value);
 var formatPath = (path2) => path2;
 var SEP = ".";
+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((value2) => {
+    return value2.trim().split("/")[0];
+  });
+}
+var serializeTokenValue = (value) => {
+  if ((0, import_shared7.isString)(value)) {
+    return value;
+  }
+  if ((0, import_shared7.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();
+};
 
 // src/validation/validate-token-references.ts
-var validateTokenReferences = (valueAtPath, refsByPath, addError) => {
+var validateTokenReferences = (props) => {
+  const { valueAtPath, refsByPath, addError, typeByPath } = props;
   refsByPath.forEach((refs, path2) => {
     if (refs.has(path2)) {
       addError("tokens", `Self token reference: \`${path2}\``);
@@ -727,7 +753,8 @@ var validateTokenReferences = (valueAtPath, refsByPath, addError) => {
       }
       const value = valueAtPath.get(currentPath);
       if (!value) {
-        addError("tokens", `Missing token: \`${currentPath}\` used in \`config.semanticTokens.${path2}\``);
+        const configKey = typeByPath.get(path2);
+        addError("tokens", `Missing token: \`${currentPath}\` used in \`theme.${configKey}.${path2}\``);
       }
       if (isTokenReference(value) && !refsByPath.has(value)) {
         addError("tokens", `Unknown token reference: \`${currentPath}\` used in \`${value}\``);
@@ -758,10 +785,10 @@ var validateTokens = (options) => {
   } = options;
   if (!theme)
     return;
-  const { tokenNames, semanticTokenNames, valueAtPath, refsByPath } = tokens2;
+  const { tokenNames, semanticTokenNames, valueAtPath, refsByPath, typeByPath } = tokens2;
   if (theme.tokens) {
     const tokenPaths = /* @__PURE__ */ new Set();
-    (0, import_shared7.walkObject)(
+    (0, import_shared8.walkObject)(
       theme.tokens,
       (value, paths) => {
         const path2 = paths.join(SEP);
@@ -777,9 +804,10 @@ var validateTokens = (options) => {
       }
     );
     tokenPaths.forEach((path2) => {
-      const value = valueAtPath.get(path2);
+      const itemValue = valueAtPath.get(path2);
       const formattedPath = formatPath(path2);
-      if (!isValidToken(value)) {
+      typeByPath.set(formattedPath, "tokens");
+      if (!isValidToken(itemValue)) {
         addError("tokens", `Token must contain 'value': \`theme.tokens.${formattedPath}\``);
         return;
       }
@@ -787,14 +815,21 @@ var validateTokens = (options) => {
         addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
         return;
       }
-      if (isTokenReference(value)) {
+      const valueStr = serializeTokenValue(itemValue.value || itemValue);
+      if (isTokenReference(valueStr)) {
         refsByPath.set(formattedPath, /* @__PURE__ */ new Set([]));
       }
+      const references = refsByPath.get(formattedPath);
+      if (!references)
+        return;
+      getReferences(valueStr).forEach((reference) => {
+        references.add(reference);
+      });
     });
   }
   if (theme.semanticTokens) {
     const tokenPaths = /* @__PURE__ */ new Set();
-    (0, import_shared7.walkObject)(
+    (0, import_shared8.walkObject)(
       theme.semanticTokens,
       (value, paths) => {
         const path2 = paths.join(SEP);
@@ -806,22 +841,25 @@ var validateTokens = (options) => {
         }
         if (!isValidToken(value))
           return;
-        (0, import_shared7.walkObject)(value, (itemValue, paths2) => {
+        (0, import_shared8.walkObject)(value, (itemValue, paths2) => {
           const valuePath = paths2.join(SEP);
           const formattedPath = formatPath(path2);
+          typeByPath.set(formattedPath, "semanticTokens");
           const fullPath = formattedPath + "." + paths2.join(SEP);
           if (valuePath.includes("value" + SEP + "value")) {
             addError("tokens", `You used \`value\` twice resulting in an invalid token \`theme.tokens.${fullPath}\``);
           }
-          if (isTokenReference(itemValue)) {
+          const valueStr = serializeTokenValue(itemValue.value || itemValue);
+          if (isTokenReference(valueStr)) {
             if (!refsByPath.has(formattedPath)) {
               refsByPath.set(formattedPath, /* @__PURE__ */ new Set());
             }
             const references = refsByPath.get(formattedPath);
             if (!references)
               return;
-            const reference = itemValue.slice(1, -1);
-            references.add(reference);
+            getReferences(valueStr).forEach((reference) => {
+              references.add(reference);
+            });
           }
         });
       },
@@ -836,12 +874,12 @@ var validateTokens = (options) => {
         addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
         return;
       }
-      if (!(0, import_shared7.isObject)(value) && !path2.includes("value")) {
+      if (!(0, import_shared8.isObject)(value) && !path2.includes("value")) {
         addError("tokens", `Token must contain 'value': \`theme.semanticTokens.${formattedPath}\``);
       }
     });
-    validateTokenReferences(valueAtPath, refsByPath, addError);
   }
+  validateTokenReferences({ valueAtPath, refsByPath, addError, typeByPath });
 };
 
 // src/validate-config.ts
@@ -863,7 +901,8 @@ var validateConfig = (config) => {
     tokenNames: /* @__PURE__ */ new Set(),
     semanticTokenNames: /* @__PURE__ */ new Set(),
     valueAtPath: /* @__PURE__ */ new Map(),
-    refsByPath: /* @__PURE__ */ new Map()
+    refsByPath: /* @__PURE__ */ new Map(),
+    typeByPath: /* @__PURE__ */ new Map()
   };
   if (config.theme) {
     validateTokens({ config, tokens: tokens2, addError });
@@ -876,7 +915,7 @@ var validateConfig = (config) => {
 ${Array.from(warnings).map((err) => "- " + err).join("\n")}
 `;
     if (config.validation === "error") {
-      throw new import_shared8.PandaError("CONFIG_ERROR", errors);
+      throw new import_shared9.PandaError("CONFIG_ERROR", errors);
     }
     import_logger3.logger.warn("config", errors);
     return warnings;
@@ -885,8 +924,8 @@ ${Array.from(warnings).map((err) => "- " + err).join("\n")}
 
 // src/resolve-config.ts
 var hookUtils = {
-  omit: import_shared9.omit,
-  traverse: import_shared9.traverse
+  omit: import_shared10.omit,
+  traverse: import_shared10.traverse
 };
 async function resolveConfig(result, cwd) {
   const presets = /* @__PURE__ */ new Set();
@@ -922,8 +961,8 @@ async function resolveConfig(result, cwd) {
       loadConfigResult.config = result2;
     }
   }
-  const serialized = (0, import_shared9.stringifyJson)(loadConfigResult.config);
-  const deserialize = () => (0, import_shared9.parseJson)(serialized);
+  const serialized = (0, import_shared10.stringifyJson)(loadConfigResult.config);
+  const deserialize = () => (0, import_shared10.parseJson)(serialized);
   return { ...loadConfigResult, serialized, deserialize, hooks };
 }
 

package/dist/index.mjs

@@ -238,15 +238,15 @@ import { PandaError as PandaError3 } from "@pandacss/shared";
 var validateArtifactNames = (names, addError) => {
   names.recipes.forEach((recipeName) => {
     if (names.slotRecipes.has(recipeName)) {
-      addError("recipes", `This recipe name is already used in \`config.theme.slotRecipes\`: ${recipeName}`);
+      addError("recipes", `This recipe name is already used in \`theme.slotRecipes\`: ${recipeName}`);
     }
     if (names.patterns.has(recipeName)) {
-      addError("recipes", `This recipe name is already used in \`config.patterns\`: \`${recipeName}\``);
+      addError("recipes", `This recipe name is already used in \`patterns\`: \`${recipeName}\``);
     }
   });
   names.slotRecipes.forEach((recipeName) => {
     if (names.patterns.has(recipeName)) {
-      addError("recipes", `This recipe name is already used in \`config.patterns\`: ${recipeName}`);
+      addError("recipes", `This recipe name is already used in \`patterns\`: ${recipeName}`);
     }
   });
 };
@@ -318,16 +318,42 @@ var validateRecipes = (options) => {
 };
 
 // src/validation/validate-tokens.ts
-import { isObject, walkObject } from "@pandacss/shared";
+import { isObject as isObject2, walkObject } from "@pandacss/shared";
 
 // src/validation/utils.ts
+import { isObject, isString as isString2 } from "@pandacss/shared";
+var REFERENCE_REGEX = /({([^}]*)})/g;
+var curlyBracketRegex = /[{}]/g;
 var isValidToken = (token) => Object.hasOwnProperty.call(token, "value");
-var isTokenReference = (value) => typeof value === "string" && value.startsWith("{");
+var isTokenReference = (value) => typeof value === "string" && REFERENCE_REGEX.test(value);
 var formatPath = (path2) => path2;
 var SEP = ".";
+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((value2) => {
+    return value2.trim().split("/")[0];
+  });
+}
+var serializeTokenValue = (value) => {
+  if (isString2(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();
+};
 
 // src/validation/validate-token-references.ts
-var validateTokenReferences = (valueAtPath, refsByPath, addError) => {
+var validateTokenReferences = (props) => {
+  const { valueAtPath, refsByPath, addError, typeByPath } = props;
   refsByPath.forEach((refs, path2) => {
     if (refs.has(path2)) {
       addError("tokens", `Self token reference: \`${path2}\``);
@@ -341,7 +367,8 @@ var validateTokenReferences = (valueAtPath, refsByPath, addError) => {
       }
       const value = valueAtPath.get(currentPath);
       if (!value) {
-        addError("tokens", `Missing token: \`${currentPath}\` used in \`config.semanticTokens.${path2}\``);
+        const configKey = typeByPath.get(path2);
+        addError("tokens", `Missing token: \`${currentPath}\` used in \`theme.${configKey}.${path2}\``);
       }
       if (isTokenReference(value) && !refsByPath.has(value)) {
         addError("tokens", `Unknown token reference: \`${currentPath}\` used in \`${value}\``);
@@ -372,7 +399,7 @@ var validateTokens = (options) => {
   } = options;
   if (!theme)
     return;
-  const { tokenNames, semanticTokenNames, valueAtPath, refsByPath } = tokens;
+  const { tokenNames, semanticTokenNames, valueAtPath, refsByPath, typeByPath } = tokens;
   if (theme.tokens) {
     const tokenPaths = /* @__PURE__ */ new Set();
     walkObject(
@@ -391,9 +418,10 @@ var validateTokens = (options) => {
       }
     );
     tokenPaths.forEach((path2) => {
-      const value = valueAtPath.get(path2);
+      const itemValue = valueAtPath.get(path2);
       const formattedPath = formatPath(path2);
-      if (!isValidToken(value)) {
+      typeByPath.set(formattedPath, "tokens");
+      if (!isValidToken(itemValue)) {
         addError("tokens", `Token must contain 'value': \`theme.tokens.${formattedPath}\``);
         return;
       }
@@ -401,9 +429,16 @@ var validateTokens = (options) => {
         addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
         return;
       }
-      if (isTokenReference(value)) {
+      const valueStr = serializeTokenValue(itemValue.value || itemValue);
+      if (isTokenReference(valueStr)) {
         refsByPath.set(formattedPath, /* @__PURE__ */ new Set([]));
       }
+      const references = refsByPath.get(formattedPath);
+      if (!references)
+        return;
+      getReferences(valueStr).forEach((reference) => {
+        references.add(reference);
+      });
     });
   }
   if (theme.semanticTokens) {
@@ -423,19 +458,22 @@ var validateTokens = (options) => {
         walkObject(value, (itemValue, paths2) => {
           const valuePath = paths2.join(SEP);
           const formattedPath = formatPath(path2);
+          typeByPath.set(formattedPath, "semanticTokens");
           const fullPath = formattedPath + "." + paths2.join(SEP);
           if (valuePath.includes("value" + SEP + "value")) {
             addError("tokens", `You used \`value\` twice resulting in an invalid token \`theme.tokens.${fullPath}\``);
           }
-          if (isTokenReference(itemValue)) {
+          const valueStr = serializeTokenValue(itemValue.value || itemValue);
+          if (isTokenReference(valueStr)) {
             if (!refsByPath.has(formattedPath)) {
               refsByPath.set(formattedPath, /* @__PURE__ */ new Set());
             }
             const references = refsByPath.get(formattedPath);
             if (!references)
               return;
-            const reference = itemValue.slice(1, -1);
-            references.add(reference);
+            getReferences(valueStr).forEach((reference) => {
+              references.add(reference);
+            });
           }
         });
       },
@@ -450,12 +488,12 @@ var validateTokens = (options) => {
         addError("tokens", `Token key must not contain spaces: \`theme.tokens.${formattedPath}\``);
         return;
       }
-      if (!isObject(value) && !path2.includes("value")) {
+      if (!isObject2(value) && !path2.includes("value")) {
         addError("tokens", `Token must contain 'value': \`theme.semanticTokens.${formattedPath}\``);
       }
     });
-    validateTokenReferences(valueAtPath, refsByPath, addError);
   }
+  validateTokenReferences({ valueAtPath, refsByPath, addError, typeByPath });
 };
 
 // src/validate-config.ts
@@ -477,7 +515,8 @@ var validateConfig = (config) => {
     tokenNames: /* @__PURE__ */ new Set(),
     semanticTokenNames: /* @__PURE__ */ new Set(),
     valueAtPath: /* @__PURE__ */ new Map(),
-    refsByPath: /* @__PURE__ */ new Map()
+    refsByPath: /* @__PURE__ */ new Map(),
+    typeByPath: /* @__PURE__ */ new Map()
   };
   if (config.theme) {
     validateTokens({ config, tokens, addError });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pandacss/config",
-  "version": "0.37.0",
+  "version": "0.37.1",
   "description": "Find and load panda config",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -73,11 +73,11 @@
     "merge-anything": "5.1.7",
     "microdiff": "1.3.2",
     "typescript": "5.3.3",
-    "@pandacss/logger": "0.37.0",
-    "@pandacss/preset-base": "0.37.0",
-    "@pandacss/preset-panda": "0.37.0",
-    "@pandacss/shared": "0.37.0",
-    "@pandacss/types": "0.37.0"
+    "@pandacss/logger": "0.37.1",
+    "@pandacss/preset-base": "0.37.1",
+    "@pandacss/preset-panda": "0.37.1",
+    "@pandacss/shared": "0.37.1",
+    "@pandacss/types": "0.37.1"
   },
   "devDependencies": {
     "pkg-types": "1.0.3"