@pandacss/eslint-plugin 0.0.10 → 0.0.12

package/dist/index.mjs

@@ -10,7 +10,7 @@ var name, version;
 var init_package = __esm({
   "package.json"() {
     name = "@pandacss/eslint-plugin";
-    version = "0.0.10";
+    version = "0.0.12";
   }
 });
 
@@ -7950,7 +7950,7 @@ var require_dist3 = __commonJS({
 // src/utils/nodes.ts
 import { isNodeOfType } from "@typescript-eslint/utils/ast-utils";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-var isIdentifier, isLiteral, isTemplateLiteral, isObjectExpression, isMemberExpression, isVariableDeclarator, isVariableDeclaration, isJSXMemberExpression, isJSXOpeningElement, isJSXExpressionContainer, isJSXAttribute, isJSXIdentifier, isCallExpression, isImportDeclaration, isImportSpecifier;
+var isIdentifier, isLiteral, isTemplateLiteral, isObjectExpression, isMemberExpression, isVariableDeclarator, isVariableDeclaration, isJSXMemberExpression, isJSXOpeningElement, isJSXExpressionContainer, isJSXAttribute, isJSXIdentifier, isCallExpression, isImportDeclaration, isImportSpecifier, isProperty;
 var init_nodes = __esm({
   "src/utils/nodes.ts"() {
     "use strict";
@@ -7970,6 +7970,7 @@ var init_nodes = __esm({
     isCallExpression = isNodeOfType(AST_NODE_TYPES.CallExpression);
     isImportDeclaration = isNodeOfType(AST_NODE_TYPES.ImportDeclaration);
     isImportSpecifier = isNodeOfType(AST_NODE_TYPES.ImportSpecifier);
+    isProperty = isNodeOfType(AST_NODE_TYPES.Property);
   }
 });
 
@@ -8402,7 +8403,7 @@ var init_no_dynamic_styling = __esm({
               return;
             if (isJSXExpressionContainer(node.value) && isTemplateLiteral(node.value.expression) && node.value.expression.expressions.length === 0)
               return;
-            if (isObjectExpression(node.value))
+            if (isObjectExpression(node.value.expression))
               return;
             if (!isPandaProp(node, context))
               return;
@@ -8612,10 +8613,117 @@ var init_no_hardcoded_color = __esm({
   }
 });
 
+// src/rules/no-important.ts
+import { getArbitraryValue as getArbitraryValue2 } from "@pandacss/shared";
+var exclamationRegex, importantRegex, RULE_NAME7, rule7, no_important_default;
+var init_no_important = __esm({
+  "src/rules/no-important.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_helpers();
+    init_utils();
+    init_nodes();
+    exclamationRegex = /\s*!$/;
+    importantRegex = /\s*!important\s*$/;
+    RULE_NAME7 = "no-important";
+    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;
+          const value = getArbitraryValue2(_value);
+          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);
+          }
+        };
+      }
+    });
+    no_important_default = rule7;
+  }
+});
+
 // src/rules/no-invalid-token-paths.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
 import { isNodeOfTypes } from "@typescript-eslint/utils/ast-utils";
-var RULE_NAME7, rule7, no_invalid_token_paths_default;
+var RULE_NAME8, rule8, no_invalid_token_paths_default;
 var init_no_invalid_token_paths = __esm({
   "src/rules/no-invalid-token-paths.ts"() {
     "use strict";
@@ -8623,9 +8731,9 @@ var init_no_invalid_token_paths = __esm({
     init_helpers();
     init_utils();
     init_nodes();
-    RULE_NAME7 = "no-invalid-token-paths";
-    rule7 = createRule({
-      name: RULE_NAME7,
+    RULE_NAME8 = "no-invalid-token-paths";
+    rule8 = createRule({
+      name: RULE_NAME8,
       meta: {
         docs: {
           description: "Disallow the use of invalid token paths within token function syntax."
@@ -8725,12 +8833,12 @@ var init_no_invalid_token_paths = __esm({
         };
       }
     });
-    no_invalid_token_paths_default = rule7;
+    no_invalid_token_paths_default = rule8;
   }
 });
 
 // src/rules/no-property-renaming.ts
-var RULE_NAME8, rule8, no_property_renaming_default;
+var RULE_NAME9, rule9, no_property_renaming_default;
 var init_no_property_renaming = __esm({
   "src/rules/no-property-renaming.ts"() {
     "use strict";
@@ -8738,9 +8846,9 @@ var init_no_property_renaming = __esm({
     init_utils();
     init_helpers();
     init_nodes();
-    RULE_NAME8 = "no-property-renaming";
-    rule8 = createRule({
-      name: RULE_NAME8,
+    RULE_NAME9 = "no-property-renaming";
+    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."
@@ -8799,29 +8907,31 @@ var init_no_property_renaming = __esm({
         };
       }
     });
-    no_property_renaming_default = rule8;
+    no_property_renaming_default = rule9;
   }
 });
 
-// src/rules/prefer-longhand-properties.ts
-var RULE_NAME9, rule9, prefer_longhand_properties_default;
-var init_prefer_longhand_properties = __esm({
-  "src/rules/prefer-longhand-properties.ts"() {
+// src/rules/no-unsafe-token-fn-usage.ts
+import "@typescript-eslint/utils";
+import { getArbitraryValue as getArbitraryValue3 } from "@pandacss/shared";
+var RULE_NAME10, rule10, no_unsafe_token_fn_usage_default;
+var init_no_unsafe_token_fn_usage = __esm({
+  "src/rules/no-unsafe-token-fn-usage.ts"() {
     "use strict";
     init_esm_shims();
     init_helpers();
     init_utils();
     init_nodes();
-    RULE_NAME9 = "prefer-longhand-properties";
-    rule9 = createRule({
-      name: RULE_NAME9,
+    RULE_NAME10 = "no-unsafe-token-fn-usage";
+    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,
@@ -8829,22 +8939,57 @@ var init_prefer_longhand_properties = __esm({
       },
       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(getArbitraryValue3(value.value?.toString() ?? "")));
+          }
+          if (isTemplateLiteral(value)) {
+            sendReport(node, tokenWrap(getArbitraryValue3(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;
+          const value = getArbitraryValue3(node.value?.toString() ?? "");
+          if (isCompositeValue(value))
+            return;
+          sendReport(node, value);
+        };
+        const handleTemplateLiteral = (node) => {
+          if (!isTemplateLiteral(node))
+            return;
+          if (node.expressions.length > 0)
+            return;
+          sendReport(node, getArbitraryValue3(node.quasis[0].value.raw));
+        };
+        const sendReport = (node, value) => {
+          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}'`);
                 }
               }
             ]
@@ -8852,51 +8997,52 @@ var init_prefer_longhand_properties = __esm({
         };
         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);
           }
         };
       }
     });
-    prefer_longhand_properties_default = rule9;
+    no_unsafe_token_fn_usage_default = rule10;
   }
 });
 
-// src/rules/prefer-shorthand-properties.ts
-var RULE_NAME10, rule10, prefer_shorthand_properties_default;
-var init_prefer_shorthand_properties = __esm({
-  "src/rules/prefer-shorthand-properties.ts"() {
+// src/rules/prefer-longhand-properties.ts
+var RULE_NAME11, rule11, prefer_longhand_properties_default;
+var init_prefer_longhand_properties = __esm({
+  "src/rules/prefer-longhand-properties.ts"() {
     "use strict";
     init_esm_shims();
     init_helpers();
     init_utils();
     init_nodes();
-    RULE_NAME10 = "prefer-shorthand-properties";
-    rule10 = createRule({
-      name: RULE_NAME10,
+    RULE_NAME11 = "prefer-longhand-properties";
+    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,
@@ -8905,24 +9051,21 @@ var init_prefer_shorthand_properties = __esm({
       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);
                 }
               }
             ]
@@ -8935,7 +9078,7 @@ var init_prefer_shorthand_properties = __esm({
             if (!isPandaProp(node, context))
               return;
             const longhand = resolveLonghand(node.name.name, context);
-            if (longhand)
+            if (!longhand)
               return;
             sendReport(node.name, node.name.name);
           },
@@ -8945,37 +9088,36 @@ var init_prefer_shorthand_properties = __esm({
             if (!isPandaAttribute(node, context))
               return;
             const longhand = resolveLonghand(node.key.name, context);
-            if (longhand)
+            if (!longhand)
               return;
             sendReport(node.key, node.key.name);
           }
         };
       }
     });
-    prefer_shorthand_properties_default = rule10;
+    prefer_longhand_properties_default = rule11;
   }
 });
 
-// src/rules/no-unsafe-token-fn-usage.ts
-import "@typescript-eslint/utils";
-var RULE_NAME11, rule11, no_unsafe_token_fn_usage_default;
-var init_no_unsafe_token_fn_usage = __esm({
-  "src/rules/no-unsafe-token-fn-usage.ts"() {
+// src/rules/prefer-shorthand-properties.ts
+var RULE_NAME12, rule12, prefer_shorthand_properties_default;
+var init_prefer_shorthand_properties = __esm({
+  "src/rules/prefer-shorthand-properties.ts"() {
     "use strict";
     init_esm_shims();
     init_helpers();
     init_utils();
     init_nodes();
-    RULE_NAME11 = "no-unsafe-token-fn-usage";
-    rule11 = createRule({
-      name: RULE_NAME11,
+    RULE_NAME12 = "prefer-shorthand-properties";
+    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,
@@ -8983,57 +9125,25 @@ var init_no_unsafe_token_fn_usage = __esm({
       },
       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]);
                 }
               }
             ]
@@ -9041,30 +9151,29 @@ var init_no_unsafe_token_fn_usage = __esm({
         };
         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);
           }
         };
       }
     });
-    no_unsafe_token_fn_usage_default = rule11;
+    prefer_shorthand_properties_default = rule12;
   }
 });
 
@@ -9189,7 +9298,7 @@ var init_composite_properties = __esm({
 });
 
 // src/rules/prefer-atomic-properties.ts
-var RULE_NAME12, rule12, prefer_atomic_properties_default;
+var RULE_NAME13, rule13, prefer_atomic_properties_default;
 var init_prefer_atomic_properties = __esm({
   "src/rules/prefer-atomic-properties.ts"() {
     "use strict";
@@ -9198,12 +9307,12 @@ var init_prefer_atomic_properties = __esm({
     init_utils();
     init_composite_properties();
     init_nodes();
-    RULE_NAME12 = "prefer-atomic-properties";
-    rule12 = createRule({
-      name: RULE_NAME12,
+    RULE_NAME13 = "prefer-atomic-properties";
+    rule13 = createRule({
+      name: RULE_NAME13,
       meta: {
         docs: {
-          description: "Encourage the use of atomic properties instead of composite shorthand properties in the codebase."
+          description: "Encourage the use of atomic properties instead of composite properties in the codebase."
         },
         messages: {
           atomic: "Use atomic properties of `{{composite}}` instead. Prefer: \n{{atomics}}"
@@ -9221,8 +9330,8 @@ var init_prefer_atomic_properties = __esm({
             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",
@@ -9238,8 +9347,78 @@ var init_prefer_atomic_properties = __esm({
               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);
+          },
+          Property(node) {
+            if (!isIdentifier(node.key))
+              return;
+            if (!isPandaAttribute(node, context))
+              return;
+            const cmp = resolveCompositeProperty(node.key.name);
+            if (!cmp)
+              return;
+            sendReport(node.key, node.key.name);
+          }
+        };
+      }
+    });
+    prefer_atomic_properties_default = rule13;
+  }
+});
+
+// src/rules/prefer-composite-properties.ts
+var RULE_NAME14, rule14, prefer_composite_properties_default;
+var init_prefer_composite_properties = __esm({
+  "src/rules/prefer-composite-properties.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_helpers();
+    init_utils();
+    init_composite_properties();
+    init_nodes();
+    RULE_NAME14 = "prefer-composite-properties";
+    rule14 = createRule({
+      name: RULE_NAME14,
+      meta: {
+        docs: {
+          description: "Encourage the use of composite properties instead of atomic properties in the codebase."
+        },
+        messages: {
+          composite: "Use composite property of `{{atomic}}` instead. \nPrefer: {{composite}}"
+        },
+        type: "suggestion",
+        schema: []
+      },
+      defaultOptions: [],
+      create(context) {
+        const resolveCompositeProperty = (name2) => {
+          const longhand = resolveLonghand(name2, context) ?? name2;
+          if (!isValidProperty(longhand, context))
+            return;
+          return Object.keys(compositeProperties).find((cpd) => compositeProperties[cpd].includes(longhand));
+        };
+        const sendReport = (node, name2) => {
+          const cmp = resolveCompositeProperty(name2);
+          return context.report({
+            node,
+            messageId: "composite",
+            data: {
+              composite: cmp,
+              atomic: name2
+            }
+          });
+        };
+        return {
+          JSXAttribute(node) {
+            if (!isJSXIdentifier(node.name))
+              return;
+            if (!isPandaProp(node, context))
+              return;
+            const atm = resolveCompositeProperty(node.name.name);
+            if (!atm)
               return;
             sendReport(node, node.name.name);
           },
@@ -9248,15 +9427,98 @@ var init_prefer_atomic_properties = __esm({
               return;
             if (!isPandaAttribute(node, context))
               return;
-            const cpd = resolveCompositeProperty(node.key.name);
-            if (!cpd)
+            const atm = resolveCompositeProperty(node.key.name);
+            if (!atm)
               return;
             sendReport(node.key, node.key.name);
           }
         };
       }
     });
-    prefer_atomic_properties_default = rule12;
+    prefer_composite_properties_default = rule14;
+  }
+});
+
+// src/rules/prefer-unified-property-style.ts
+var RULE_NAME15, rule15, prefer_unified_property_style_default;
+var init_prefer_unified_property_style = __esm({
+  "src/rules/prefer-unified-property-style.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_helpers();
+    init_utils();
+    init_composite_properties();
+    init_nodes();
+    RULE_NAME15 = "prefer-unified-property-style";
+    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);
+          }
+        };
+      }
+    });
+    prefer_unified_property_style_default = rule15;
   }
 });
 
@@ -9272,12 +9534,15 @@ var init_rules = __esm({
     init_no_dynamic_styling();
     init_no_escape_hatch();
     init_no_hardcoded_color();
+    init_no_important();
     init_no_invalid_token_paths();
     init_no_property_renaming();
+    init_no_unsafe_token_fn_usage();
     init_prefer_longhand_properties();
     init_prefer_shorthand_properties();
-    init_no_unsafe_token_fn_usage();
     init_prefer_atomic_properties();
+    init_prefer_composite_properties();
+    init_prefer_unified_property_style();
     rules = {
       [RULE_NAME]: file_not_included_default,
       [RULE_NAME2]: no_config_function_in_source_default,
@@ -9285,12 +9550,15 @@ var init_rules = __esm({
       [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_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
     };
   }
 });
@@ -9305,7 +9573,7 @@ var init_all = __esm({
     init_file_not_included();
     init_no_config_function_in_source();
     init_no_invalid_token_paths();
-    errorRules = [RULE_NAME, RULE_NAME2, RULE_NAME7];
+    errorRules = [RULE_NAME, RULE_NAME2, RULE_NAME8];
     allRules = Object.fromEntries(
       Object.entries(rules).map(([name2]) => {
         return [`@pandacss/${name2}`, errorRules.includes(name2) ? "error" : "warn"];
@@ -9335,8 +9603,9 @@ var init_recommended = __esm({
         "@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"
       }
     };
   }