@pandacss/eslint-plugin 0.0.0-dev-20240208175853 → 0.0.0-dev-20240209200922

package/dist/index.js

@@ -7957,7 +7957,7 @@ init_cjs_shims();
 
 // package.json
 var name = "@pandacss/eslint-plugin";
-var version = "0.0.0-dev-20240208175853";
+var version = "0.0.0-dev-20240209200922";
 
 // src/configs/all.ts
 init_cjs_shims();
@@ -8004,6 +8004,7 @@ var isJSXIdentifier = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_
 var isCallExpression = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.CallExpression);
 var isImportDeclaration = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.ImportDeclaration);
 var isImportSpecifier = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.ImportSpecifier);
+var isProperty = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.Property);
 
 // src/utils/helpers.ts
 var getAncestor = (ofType, for_) => {
@@ -8580,13 +8581,109 @@ var rule6 = createRule({
 });
 var no_hardcoded_color_default = rule6;
 
-// src/rules/no-invalid-token-paths.ts
+// src/rules/no-important.ts
 init_cjs_shims();
-var import_utils10 = require("@typescript-eslint/utils");
-var import_ast_utils2 = require("@typescript-eslint/utils/ast-utils");
-var RULE_NAME7 = "no-invalid-token-paths";
+var exclamationRegex = /\s*!$/;
+var importantRegex = /\s*!important\s*$/;
+var RULE_NAME7 = "no-important";
 var rule7 = createRule({
   name: RULE_NAME7,
+  meta: {
+    docs: {
+      description: "Disallow usage of important keyword. Prioroitize specificity for a maintainable and predictable styling structure."
+    },
+    messages: {
+      important: "Avoid using the !important keyword. Refactor your code to prioritize specificity for predictable styling.",
+      remove: "Remove the `{{keyword}}` keyword."
+    },
+    type: "suggestion",
+    hasSuggestions: true,
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const removeQuotes = ([start, end]) => [start + 1, end - 1];
+    const hasImportantKeyword = (value) => {
+      if (!value)
+        return false;
+      return exclamationRegex.test(value) || importantRegex.test(value);
+    };
+    const removeImportantKeyword = (input) => {
+      if (exclamationRegex.test(input)) {
+        return { fixed: input.replace(exclamationRegex, ""), keyword: "!" };
+      } else if (importantRegex.test(input)) {
+        return { fixed: input.replace(importantRegex, ""), keyword: "!important" };
+      } else {
+        return { fixed: input, keyword: null };
+      }
+    };
+    const handleLiteral = (node) => {
+      if (!isLiteral(node))
+        return;
+      if (!hasImportantKeyword(node.value?.toString()))
+        return;
+      sendReport(node);
+    };
+    const handleTemplateLiteral = (node) => {
+      if (!isTemplateLiteral(node))
+        return;
+      if (node.expressions.length > 0)
+        return;
+      if (!hasImportantKeyword(node.quasis[0].value.raw))
+        return;
+      sendReport(node.quasis[0], node.quasis[0].value.raw);
+    };
+    const sendReport = (node, _value) => {
+      const value = _value ?? node.value?.toString();
+      const { keyword, fixed } = removeImportantKeyword(value);
+      return context.report({
+        node,
+        messageId: "important",
+        suggest: [
+          {
+            messageId: "remove",
+            data: { keyword },
+            fix: (fixer) => {
+              return fixer.replaceTextRange(removeQuotes(node.range), fixed);
+            }
+          }
+        ]
+      });
+    };
+    return {
+      JSXAttribute(node) {
+        if (!node.value)
+          return;
+        if (!isPandaProp(node, context))
+          return;
+        handleLiteral(node.value);
+        if (!isJSXExpressionContainer(node.value))
+          return;
+        handleLiteral(node.value.expression);
+        handleTemplateLiteral(node.value.expression);
+      },
+      Property(node) {
+        if (!isIdentifier(node.key))
+          return;
+        if (!isLiteral(node.value) && !isTemplateLiteral(node.value))
+          return;
+        if (!isPandaAttribute(node, context))
+          return;
+        handleLiteral(node.value);
+        handleTemplateLiteral(node.value);
+      }
+    };
+  }
+});
+var no_important_default = rule7;
+
+// src/rules/no-invalid-token-paths.ts
+init_cjs_shims();
+var import_utils11 = require("@typescript-eslint/utils");
+var import_ast_utils2 = require("@typescript-eslint/utils/ast-utils");
+var RULE_NAME8 = "no-invalid-token-paths";
+var rule8 = createRule({
+  name: RULE_NAME8,
   meta: {
     docs: {
       description: "Disallow the use of invalid token paths within token function syntax."
@@ -8639,7 +8736,7 @@ var rule7 = createRule({
       Property(node) {
         if (!isIdentifier(node.key))
           return;
-        if (!(0, import_ast_utils2.isNodeOfTypes)([import_utils10.AST_NODE_TYPES.Literal, import_utils10.AST_NODE_TYPES.TemplateLiteral])(node.value))
+        if (!(0, import_ast_utils2.isNodeOfTypes)([import_utils11.AST_NODE_TYPES.Literal, import_utils11.AST_NODE_TYPES.TemplateLiteral])(node.value))
           return;
         if (!isPandaAttribute(node, context))
           return;
@@ -8686,13 +8783,13 @@ var rule7 = createRule({
     };
   }
 });
-var no_invalid_token_paths_default = rule7;
+var no_invalid_token_paths_default = rule8;
 
 // src/rules/no-property-renaming.ts
 init_cjs_shims();
-var RULE_NAME8 = "no-property-renaming";
-var rule8 = createRule({
-  name: RULE_NAME8,
+var RULE_NAME9 = "no-property-renaming";
+var rule9 = createRule({
+  name: RULE_NAME9,
   meta: {
     docs: {
       description: "Ensure user does not rename a property for a pattern or style prop. \nIt doesn't get tracked."
@@ -8751,20 +8848,21 @@ var rule8 = createRule({
     };
   }
 });
-var no_property_renaming_default = rule8;
+var no_property_renaming_default = rule9;
 
-// src/rules/prefer-longhand-properties.ts
+// src/rules/no-unsafe-token-fn-usage.ts
 init_cjs_shims();
-var RULE_NAME9 = "prefer-longhand-properties";
-var rule9 = createRule({
-  name: RULE_NAME9,
+var import_utils14 = require("@typescript-eslint/utils");
+var RULE_NAME10 = "no-unsafe-token-fn-usage";
+var rule10 = createRule({
+  name: RULE_NAME10,
   meta: {
     docs: {
-      description: "Discourage the use of shorthand properties and promote the preference for longhand properties in the codebase."
+      description: "Prevent users from using the token function in situations where they could simply use the raw design token."
     },
     messages: {
-      longhand: "Use longhand property of `{{shorthand}}` instead. Prefer `{{longhand}}`",
-      replace: "Replace `{{shorthand}}` with `{{longhand}}`"
+      noUnsafeTokenFnUsage: "Unneccessary token function usage. Prefer design token",
+      replace: "Replace token function with `{{safe}}`"
     },
     type: "suggestion",
     hasSuggestions: true,
@@ -8772,22 +8870,57 @@ var rule9 = createRule({
   },
   defaultOptions: [],
   create(context) {
-    const sendReport = (node, name2) => {
-      const longhand = resolveLonghand(name2, context);
-      const data = {
-        shorthand: name2,
-        longhand
-      };
+    const isUnsafeCallExpression = (node) => {
+      const tkImport = getTokenImport(context);
+      return isIdentifier(node.callee) && node.callee.name === tkImport?.alias;
+    };
+    const tokenWrap = (value) => value ? `token(${value})` : "";
+    const handleRuntimeFm = (node) => {
+      if (!isCallExpression(node))
+        return;
+      if (!isUnsafeCallExpression(node))
+        return;
+      const value = node.arguments[0];
+      if (isLiteral(value)) {
+        sendReport(node, tokenWrap(value.value?.toString()));
+      }
+      if (isTemplateLiteral(value)) {
+        sendReport(node, tokenWrap(value.quasis[0].value.raw));
+      }
+    };
+    const isCompositeValue = (input) => {
+      if (!input)
+        return;
+      const tokenRegex = /^(?:token\([^)]*\)|\{[^}]*\})$/;
+      return !tokenRegex.test(input);
+    };
+    const handleLiteral = (node) => {
+      if (!isLiteral(node))
+        return;
+      if (isCompositeValue(node.value?.toString()))
+        return;
+      sendReport(node);
+    };
+    const handleTemplateLiteral = (node) => {
+      if (!isTemplateLiteral(node))
+        return;
+      if (node.expressions.length > 0)
+        return;
+      sendReport(node, node.quasis[0].value.raw);
+    };
+    const sendReport = (node, _value) => {
+      const value = _value ?? node.value?.toString();
+      const tkImports = extractTokens(value);
+      const token = tkImports[0].replace(/^[^.]*\./, "");
       return context.report({
         node,
-        messageId: "longhand",
-        data,
+        messageId: "noUnsafeTokenFnUsage",
         suggest: [
           {
             messageId: "replace",
-            data,
+            data: { safe: token },
             fix: (fixer) => {
-              return fixer.replaceTextRange(node.range, longhand);
+              return fixer.replaceTextRange(node.range, `'${token}'`);
             }
           }
         ]
@@ -8795,42 +8928,43 @@ var rule9 = createRule({
     };
     return {
       JSXAttribute(node) {
-        if (!isJSXIdentifier(node.name))
+        if (!node.value)
           return;
         if (!isPandaProp(node, context))
           return;
-        const longhand = resolveLonghand(node.name.name, context);
-        if (!longhand)
+        handleLiteral(node.value);
+        if (!isJSXExpressionContainer(node.value))
           return;
-        sendReport(node.name, node.name.name);
+        handleLiteral(node.value.expression);
+        handleTemplateLiteral(node.value.expression);
+        handleRuntimeFm(node.value.expression);
       },
       Property(node) {
-        if (!isIdentifier(node.key))
+        if (!isCallExpression(node.value) && !isLiteral(node.value) && !isTemplateLiteral(node.value))
           return;
         if (!isPandaAttribute(node, context))
           return;
-        const longhand = resolveLonghand(node.key.name, context);
-        if (!longhand)
-          return;
-        sendReport(node.key, node.key.name);
+        handleRuntimeFm(node.value);
+        handleLiteral(node.value);
+        handleTemplateLiteral(node.value);
       }
     };
   }
 });
-var prefer_longhand_properties_default = rule9;
+var no_unsafe_token_fn_usage_default = rule10;
 
-// src/rules/prefer-shorthand-properties.ts
+// src/rules/prefer-longhand-properties.ts
 init_cjs_shims();
-var RULE_NAME10 = "prefer-shorthand-properties";
-var rule10 = createRule({
-  name: RULE_NAME10,
+var RULE_NAME11 = "prefer-longhand-properties";
+var rule11 = createRule({
+  name: RULE_NAME11,
   meta: {
     docs: {
-      description: "Discourage the use of longhand properties and promote the preference for shorthand properties in the codebase."
+      description: "Discourage the use of shorthand properties and promote the preference for longhand properties in the codebase."
     },
     messages: {
-      shorthand: "Use shorthand property of `{{longhand}}` instead. Prefer {{shorthand}}",
-      replace: "Replace `{{longhand}}` with `{{shorthand}}`"
+      longhand: "Use longhand property of `{{shorthand}}` instead. Prefer `{{longhand}}`",
+      replace: "Replace `{{shorthand}}` with `{{longhand}}`"
     },
     type: "suggestion",
     hasSuggestions: true,
@@ -8839,24 +8973,21 @@ var rule10 = createRule({
   defaultOptions: [],
   create(context) {
     const sendReport = (node, name2) => {
-      const shorthands = resolveShorthands(name2, context);
-      if (!shorthands)
-        return;
-      const shorthand = shorthands.map((s) => "`" + s + "`")?.join(", ");
+      const longhand = resolveLonghand(name2, context);
       const data = {
-        longhand: name2,
-        shorthand
+        shorthand: name2,
+        longhand
       };
       return context.report({
         node,
-        messageId: "shorthand",
+        messageId: "longhand",
         data,
         suggest: [
           {
             messageId: "replace",
             data,
             fix: (fixer) => {
-              return fixer.replaceTextRange(node.range, shorthands[0]);
+              return fixer.replaceTextRange(node.range, longhand);
             }
           }
         ]
@@ -8869,7 +9000,7 @@ var rule10 = createRule({
         if (!isPandaProp(node, context))
           return;
         const longhand = resolveLonghand(node.name.name, context);
-        if (longhand)
+        if (!longhand)
           return;
         sendReport(node.name, node.name.name);
       },
@@ -8879,28 +9010,27 @@ var rule10 = createRule({
         if (!isPandaAttribute(node, context))
           return;
         const longhand = resolveLonghand(node.key.name, context);
-        if (longhand)
+        if (!longhand)
           return;
         sendReport(node.key, node.key.name);
       }
     };
   }
 });
-var prefer_shorthand_properties_default = rule10;
+var prefer_longhand_properties_default = rule11;
 
-// src/rules/no-unsafe-token-fn-usage.ts
+// src/rules/prefer-shorthand-properties.ts
 init_cjs_shims();
-var import_utils15 = require("@typescript-eslint/utils");
-var RULE_NAME11 = "no-unsafe-token-fn-usage";
-var rule11 = createRule({
-  name: RULE_NAME11,
+var RULE_NAME12 = "prefer-shorthand-properties";
+var rule12 = createRule({
+  name: RULE_NAME12,
   meta: {
     docs: {
-      description: "Prevent users from using the token function in situations where they could simply use the raw design token."
+      description: "Discourage the use of longhand properties and promote the preference for shorthand properties in the codebase."
     },
     messages: {
-      noUnsafeTokenFnUsage: "Unneccessary token function usage. Prefer design token",
-      replace: "Replace token function with `{{safe}}`"
+      shorthand: "Use shorthand property of `{{longhand}}` instead. Prefer {{shorthand}}",
+      replace: "Replace `{{longhand}}` with `{{shorthand}}`"
     },
     type: "suggestion",
     hasSuggestions: true,
@@ -8908,57 +9038,25 @@ var rule11 = createRule({
   },
   defaultOptions: [],
   create(context) {
-    const isUnsafeCallExpression = (node) => {
-      const tkImport = getTokenImport(context);
-      return isIdentifier(node.callee) && node.callee.name === tkImport?.alias;
-    };
-    const tokenWrap = (value) => value ? `token(${value})` : "";
-    const handleRuntimeFm = (node) => {
-      if (!isCallExpression(node))
-        return;
-      if (!isUnsafeCallExpression(node))
-        return;
-      const value = node.arguments[0];
-      if (isLiteral(value)) {
-        sendReport(node, tokenWrap(value.value?.toString()));
-      }
-      if (isTemplateLiteral(value)) {
-        sendReport(node, tokenWrap(value.quasis[0].value.raw));
-      }
-    };
-    const isCompositeValue = (input) => {
-      if (!input)
-        return;
-      const tokenRegex = /^(?:token\([^)]*\)|\{[^}]*\})$/;
-      return !tokenRegex.test(input);
-    };
-    const handleLiteral = (node) => {
-      if (!isLiteral(node))
-        return;
-      if (isCompositeValue(node.value?.toString()))
-        return;
-      sendReport(node);
-    };
-    const handleTemplateLiteral = (node) => {
-      if (!isTemplateLiteral(node))
-        return;
-      if (node.expressions.length > 0)
+    const sendReport = (node, name2) => {
+      const shorthands = resolveShorthands(name2, context);
+      if (!shorthands)
         return;
-      sendReport(node, node.quasis[0].value.raw);
-    };
-    const sendReport = (node, _value) => {
-      const value = _value ?? node.value?.toString();
-      const tkImports = extractTokens(value);
-      const token = tkImports[0].replace(/^[^.]*\./, "");
+      const shorthand = shorthands.map((s) => `\`${s}\``)?.join(", ");
+      const data = {
+        longhand: name2,
+        shorthand
+      };
       return context.report({
         node,
-        messageId: "noUnsafeTokenFnUsage",
+        messageId: "shorthand",
+        data,
         suggest: [
           {
             messageId: "replace",
-            data: { safe: token },
+            data,
             fix: (fixer) => {
-              return fixer.replaceTextRange(node.range, `'${token}'`);
+              return fixer.replaceTextRange(node.range, shorthands[0]);
             }
           }
         ]
@@ -8966,30 +9064,29 @@ var rule11 = createRule({
     };
     return {
       JSXAttribute(node) {
-        if (!node.value)
+        if (!isJSXIdentifier(node.name))
           return;
         if (!isPandaProp(node, context))
           return;
-        handleLiteral(node.value);
-        if (!isJSXExpressionContainer(node.value))
+        const longhand = resolveLonghand(node.name.name, context);
+        if (longhand)
           return;
-        handleLiteral(node.value.expression);
-        handleTemplateLiteral(node.value.expression);
-        handleRuntimeFm(node.value.expression);
+        sendReport(node.name, node.name.name);
       },
       Property(node) {
-        if (!isCallExpression(node.value) && !isLiteral(node.value) && !isTemplateLiteral(node.value))
+        if (!isIdentifier(node.key))
           return;
         if (!isPandaAttribute(node, context))
           return;
-        handleRuntimeFm(node.value);
-        handleLiteral(node.value);
-        handleTemplateLiteral(node.value);
+        const longhand = resolveLonghand(node.key.name, context);
+        if (longhand)
+          return;
+        sendReport(node.key, node.key.name);
       }
     };
   }
 });
-var no_unsafe_token_fn_usage_default = rule11;
+var prefer_shorthand_properties_default = rule12;
 
 // src/rules/prefer-atomic-properties.ts
 init_cjs_shims();
@@ -9109,9 +9206,9 @@ var compositeProperties = {
 };
 
 // src/rules/prefer-atomic-properties.ts
-var RULE_NAME12 = "prefer-atomic-properties";
-var rule12 = createRule({
-  name: RULE_NAME12,
+var RULE_NAME13 = "prefer-atomic-properties";
+var rule13 = createRule({
+  name: RULE_NAME13,
   meta: {
     docs: {
       description: "Encourage the use of atomic properties instead of composite properties in the codebase."
@@ -9132,8 +9229,8 @@ var rule12 = createRule({
         return longhand;
     };
     const sendReport = (node, name2) => {
-      const cpd = resolveCompositeProperty(name2);
-      const atomics = compositeProperties[cpd].map((name3) => `\`${name3}\``).join(",\n");
+      const cmp = resolveCompositeProperty(name2);
+      const atomics = compositeProperties[cmp].map((name3) => `\`${name3}\``).join(",\n");
       return context.report({
         node,
         messageId: "atomic",
@@ -9149,8 +9246,8 @@ var rule12 = createRule({
           return;
         if (!isPandaProp(node, context))
           return;
-        const cpd = resolveCompositeProperty(node.name.name);
-        if (!cpd)
+        const cmp = resolveCompositeProperty(node.name.name);
+        if (!cmp)
           return;
         sendReport(node, node.name.name);
       },
@@ -9159,21 +9256,21 @@ var rule12 = createRule({
           return;
         if (!isPandaAttribute(node, context))
           return;
-        const cpd = resolveCompositeProperty(node.key.name);
-        if (!cpd)
+        const cmp = resolveCompositeProperty(node.key.name);
+        if (!cmp)
           return;
         sendReport(node.key, node.key.name);
       }
     };
   }
 });
-var prefer_atomic_properties_default = rule12;
+var prefer_atomic_properties_default = rule13;
 
 // src/rules/prefer-composite-properties.ts
 init_cjs_shims();
-var RULE_NAME13 = "prefer-composite-properties";
-var rule13 = createRule({
-  name: RULE_NAME13,
+var RULE_NAME14 = "prefer-composite-properties";
+var rule14 = createRule({
+  name: RULE_NAME14,
   meta: {
     docs: {
       description: "Encourage the use of composite properties instead of atomic properties in the codebase."
@@ -9227,7 +9324,80 @@ var rule13 = createRule({
     };
   }
 });
-var prefer_composite_properties_default = rule13;
+var prefer_composite_properties_default = rule14;
+
+// src/rules/prefer-unified-property-style.ts
+init_cjs_shims();
+var RULE_NAME15 = "prefer-unified-property-style";
+var rule15 = createRule({
+  name: RULE_NAME15,
+  meta: {
+    docs: {
+      description: "Discourage against mixing atomic and composite forms of the same property in a style declaration. Atomic styles give more consistent results"
+    },
+    messages: {
+      unify: "You're mixing atomic {{atomicProperties}} with composite property {{composite}}. \nPrefer atomic styling to mixing atomic and composite properties. \nRemove `{{composite}}` and use one or more of {{atomics}} instead"
+    },
+    type: "suggestion",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const getLonghand = (name2) => resolveLonghand(name2, context) ?? name2;
+    const resolveCompositeProperty = (name2) => {
+      if (Object.hasOwn(compositeProperties, name2))
+        return name2;
+      const longhand = getLonghand(name2);
+      if (isValidProperty(longhand, context) && Object.hasOwn(compositeProperties, longhand))
+        return longhand;
+    };
+    const sendReport = (node, cmp, siblings) => {
+      const _atomicProperties = siblings.filter((prop) => compositeProperties[cmp].includes(getLonghand(prop))).map((prop) => `\`${prop}\``);
+      if (!_atomicProperties.length)
+        return;
+      const atomicProperties = _atomicProperties.join(", ") + (_atomicProperties.length === 1 ? " style" : " styles");
+      const atomics = compositeProperties[cmp].map((name2) => `\`${name2}\``).join(", ");
+      context.report({
+        node,
+        messageId: "unify",
+        data: {
+          composite: cmp,
+          atomicProperties,
+          atomics
+        }
+      });
+    };
+    return {
+      JSXAttribute(node) {
+        if (!isJSXIdentifier(node.name))
+          return;
+        if (!isPandaProp(node, context))
+          return;
+        const cmp = resolveCompositeProperty(node.name.name);
+        if (!cmp)
+          return;
+        if (!isJSXOpeningElement(node.parent))
+          return;
+        const siblings = node.parent.attributes.map((attr) => attr.name.name);
+        sendReport(node, cmp, siblings);
+      },
+      Property(node) {
+        if (!isIdentifier(node.key))
+          return;
+        if (!isPandaAttribute(node, context))
+          return;
+        const cmp = resolveCompositeProperty(node.key.name);
+        if (!cmp)
+          return;
+        if (!isObjectExpression(node.parent))
+          return;
+        const siblings = node.parent.properties.map((prop) => isIdentifier(prop.key) && prop.key.name);
+        sendReport(node.key, cmp, siblings);
+      }
+    };
+  }
+});
+var prefer_unified_property_style_default = rule15;
 
 // src/rules/index.ts
 var rules = {
@@ -9237,17 +9407,19 @@ var rules = {
   [RULE_NAME4]: no_dynamic_styling_default,
   [RULE_NAME5]: no_escape_hatch_default,
   [RULE_NAME6]: no_hardcoded_color_default,
-  [RULE_NAME7]: no_invalid_token_paths_default,
-  [RULE_NAME8]: no_property_renaming_default,
-  [RULE_NAME9]: prefer_longhand_properties_default,
-  [RULE_NAME10]: prefer_shorthand_properties_default,
-  [RULE_NAME11]: no_unsafe_token_fn_usage_default,
-  [RULE_NAME12]: prefer_atomic_properties_default,
-  [RULE_NAME13]: prefer_composite_properties_default
+  [RULE_NAME7]: no_important_default,
+  [RULE_NAME8]: no_invalid_token_paths_default,
+  [RULE_NAME9]: no_property_renaming_default,
+  [RULE_NAME10]: no_unsafe_token_fn_usage_default,
+  [RULE_NAME11]: prefer_longhand_properties_default,
+  [RULE_NAME12]: prefer_shorthand_properties_default,
+  [RULE_NAME13]: prefer_atomic_properties_default,
+  [RULE_NAME14]: prefer_composite_properties_default,
+  [RULE_NAME15]: prefer_unified_property_style_default
 };
 
 // src/configs/all.ts
-var errorRules = [RULE_NAME, RULE_NAME2, RULE_NAME7];
+var errorRules = [RULE_NAME, RULE_NAME2, RULE_NAME8];
 var allRules = Object.fromEntries(
   Object.entries(rules).map(([name2]) => {
     return [`@pandacss/${name2}`, errorRules.includes(name2) ? "error" : "warn"];
@@ -9271,8 +9443,9 @@ var recommended_default = {
     "@pandacss/no-config-function-in-source": "error",
     "@pandacss/no-debug": "warn",
     "@pandacss/no-dynamic-styling": "warn",
+    "@pandacss/no-invalid-token-paths": "error",
     "@pandacss/no-property-renaming": "warn",
-    "@pandacss/no-invalid-token-paths": "error"
+    "@pandacss/prefer-unified-property-style": "warn"
   }
 };