@pandacss/eslint-plugin 0.0.15 → 0.0.17

package/dist/index.js

@@ -7957,7 +7957,7 @@ init_cjs_shims();
 
 // package.json
 var name = "@pandacss/eslint-plugin";
-var version = "0.0.15";
+var version = "0.0.17";
 
 // src/configs/all.ts
 init_cjs_shims();
@@ -8839,6 +8839,52 @@ var rule9 = createRule({
 });
 var no_invalid_token_paths_default = rule9;
 
+// src/rules/no-margin-properties.ts
+init_cjs_shims();
+var RULE_NAME10 = "no-margin-properties";
+var rule10 = createRule({
+  name: RULE_NAME10,
+  meta: {
+    docs: {
+      description: "Discourage using margin properties for spacing; prefer defining spacing in parent elements with `flex` or `grid` using the `gap` property for a more resilient layout. Margins make components less reusable in other contexts."
+    },
+    messages: {
+      noMargin: "Use flex or grid with the `gap` property to define spacing in parent elements for a more resilient layout."
+    },
+    type: "suggestion",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const getLonghand = (name2) => resolveLonghand(name2, context) ?? name2;
+    const sendReport = (node) => {
+      if (!getLonghand(node.name).toLowerCase().includes("margin"))
+        return;
+      return context.report({
+        node,
+        messageId: "noMargin"
+      });
+    };
+    return {
+      JSXAttribute(node) {
+        if (!isJSXIdentifier(node.name))
+          return;
+        if (!isPandaProp(node, context))
+          return;
+        sendReport(node.name);
+      },
+      Property(node) {
+        if (!isIdentifier(node.key))
+          return;
+        if (!isPandaAttribute(node, context))
+          return;
+        sendReport(node.key);
+      }
+    };
+  }
+});
+var no_margin_properties_default = rule10;
+
 // src/rules/no-physical-properties.ts
 init_cjs_shims();
 
@@ -8880,9 +8926,9 @@ var physicalProperties = {
 };
 
 // src/rules/no-physical-properties.ts
-var RULE_NAME10 = "no-physical-properties";
-var rule10 = createRule({
-  name: RULE_NAME10,
+var RULE_NAME11 = "no-physical-properties";
+var rule11 = createRule({
+  name: RULE_NAME11,
   meta: {
     docs: {
       description: "Encourage the use of [logical properties](https://mdn.io/logical-properties-basic-concepts) over physical proeprties, to foster a responsive and adaptable user interface."
@@ -8898,21 +8944,23 @@ var rule10 = createRule({
   defaultOptions: [],
   create(context) {
     const getLonghand = (name2) => resolveLonghand(name2, context) ?? name2;
-    const sendReport = (node, name2) => {
-      const logical = physicalProperties[getLonghand(name2)];
-      const longhand = resolveLonghand(name2, context);
+    const sendReport = (node) => {
+      if (!(getLonghand(node.name) in physicalProperties))
+        return;
+      const logical = physicalProperties[getLonghand(node.name)];
+      const longhand = resolveLonghand(node.name, context);
       return context.report({
         node,
         messageId: "physical",
         data: {
-          physical: `\`${name2}\`${longhand ? ` - \`${longhand}\`` : ""}`,
+          physical: `\`${node.name}\`${longhand ? ` - \`${longhand}\`` : ""}`,
           logical
         },
         suggest: [
           {
             messageId: "replace",
             data: {
-              physical: name2,
+              physical: node.name,
               logical
             },
             fix: (fixer) => {
@@ -8928,29 +8976,25 @@ var rule10 = createRule({
           return;
         if (!isPandaProp(node, context))
           return;
-        if (getLonghand(node.name.name) in physicalProperties) {
-          sendReport(node.name, node.name.name);
-        }
+        sendReport(node.name);
       },
       Property(node) {
         if (!isIdentifier(node.key))
           return;
         if (!isPandaAttribute(node, context))
           return;
-        if (getLonghand(node.key.name) in physicalProperties) {
-          sendReport(node.key, node.key.name);
-        }
+        sendReport(node.key);
       }
     };
   }
 });
-var no_physical_properties_default = rule10;
+var no_physical_properties_default = rule11;
 
 // src/rules/no-property-renaming.ts
 init_cjs_shims();
-var RULE_NAME11 = "no-property-renaming";
-var rule11 = createRule({
-  name: RULE_NAME11,
+var RULE_NAME12 = "no-property-renaming";
+var rule12 = createRule({
+  name: RULE_NAME12,
   meta: {
     docs: {
       description: "Ensure user does not rename a property for a pattern or style prop. \nIt doesn't get tracked."
@@ -8973,6 +9017,14 @@ var rule11 = createRule({
         }
       });
     };
+    const handleReport = (node, value, attr) => {
+      if (isIdentifier(value) && attr !== value.name) {
+        return sendReport(node, attr, value.name);
+      }
+      if (isMemberExpression(value) && isIdentifier(value.property) && attr !== value.property.name) {
+        return sendReport(node, attr, value.property.name);
+      }
+    };
     return {
       JSXAttribute(node) {
         if (!node.value)
@@ -8983,12 +9035,7 @@ var rule11 = createRule({
           return;
         const attr = node.name.name.toString();
         const expression = node.value.expression;
-        if (isIdentifier(expression) && attr !== expression.name) {
-          return sendReport(node, attr, expression.name);
-        }
-        if (isMemberExpression(expression) && isIdentifier(expression.property) && attr !== expression.property.name) {
-          return sendReport(node, attr, expression.property.name);
-        }
+        handleReport(node, expression, attr);
       },
       Property(node) {
         if (!isIdentifier(node.key))
@@ -8999,25 +9046,20 @@ var rule11 = createRule({
           return;
         const attr = node.key.name.toString();
         const value = node.value;
-        if (isIdentifier(value) && attr !== value.name) {
-          return sendReport(node, attr, value.name);
-        }
-        if (isMemberExpression(value) && isIdentifier(value.property) && attr !== value.property.name) {
-          return sendReport(node, attr, value.property.name);
-        }
+        handleReport(node, value, attr);
       }
     };
   }
 });
-var no_property_renaming_default = rule11;
+var no_property_renaming_default = rule12;
 
 // src/rules/no-unsafe-token-fn-usage.ts
 init_cjs_shims();
-var import_utils16 = require("@typescript-eslint/utils");
+var import_utils17 = require("@typescript-eslint/utils");
 var import_shared3 = require("@pandacss/shared");
-var RULE_NAME12 = "no-unsafe-token-fn-usage";
-var rule12 = createRule({
-  name: RULE_NAME12,
+var RULE_NAME13 = "no-unsafe-token-fn-usage";
+var rule13 = createRule({
+  name: RULE_NAME13,
   meta: {
     docs: {
       description: "Prevent users from using the token function in situations where they could simply use the raw design token."
@@ -9113,13 +9155,13 @@ var rule12 = createRule({
     };
   }
 });
-var no_unsafe_token_fn_usage_default = rule12;
+var no_unsafe_token_fn_usage_default = rule13;
 
 // src/rules/prefer-longhand-properties.ts
 init_cjs_shims();
-var RULE_NAME13 = "prefer-longhand-properties";
-var rule13 = createRule({
-  name: RULE_NAME13,
+var RULE_NAME14 = "prefer-longhand-properties";
+var rule14 = createRule({
+  name: RULE_NAME14,
   meta: {
     docs: {
       description: "Discourage the use of shorthand properties and promote the preference for longhand properties in the codebase."
@@ -9134,10 +9176,12 @@ var rule13 = createRule({
   },
   defaultOptions: [],
   create(context) {
-    const sendReport = (node, name2) => {
-      const longhand = resolveLonghand(name2, context);
+    const sendReport = (node) => {
+      const longhand = resolveLonghand(node.name, context);
+      if (!longhand)
+        return;
       const data = {
-        shorthand: name2,
+        shorthand: node.name,
         longhand
       };
       return context.report({
@@ -9161,31 +9205,25 @@ var rule13 = createRule({
           return;
         if (!isPandaProp(node, context))
           return;
-        const longhand = resolveLonghand(node.name.name, context);
-        if (!longhand)
-          return;
-        sendReport(node.name, node.name.name);
+        sendReport(node.name);
       },
       Property(node) {
         if (!isIdentifier(node.key))
           return;
         if (!isPandaAttribute(node, context))
           return;
-        const longhand = resolveLonghand(node.key.name, context);
-        if (!longhand)
-          return;
-        sendReport(node.key, node.key.name);
+        sendReport(node.key);
       }
     };
   }
 });
-var prefer_longhand_properties_default = rule13;
+var prefer_longhand_properties_default = rule14;
 
 // src/rules/prefer-shorthand-properties.ts
 init_cjs_shims();
-var RULE_NAME14 = "prefer-shorthand-properties";
-var rule14 = createRule({
-  name: RULE_NAME14,
+var RULE_NAME15 = "prefer-shorthand-properties";
+var rule15 = createRule({
+  name: RULE_NAME15,
   meta: {
     docs: {
       description: "Discourage the use of longhand properties and promote the preference for shorthand properties in the codebase."
@@ -9200,13 +9238,16 @@ var rule14 = createRule({
   },
   defaultOptions: [],
   create(context) {
-    const sendReport = (node, name2) => {
-      const shorthands = resolveShorthands(name2, context);
+    const sendReport = (node) => {
+      const longhand = resolveLonghand(node.name, context);
+      if (longhand)
+        return;
+      const shorthands = resolveShorthands(node.name, context);
       if (!shorthands)
         return;
       const shorthand = shorthands.map((s) => `\`${s}\``)?.join(", ");
       const data = {
-        longhand: name2,
+        longhand: node.name,
         shorthand
       };
       return context.report({
@@ -9230,25 +9271,19 @@ var rule14 = createRule({
           return;
         if (!isPandaProp(node, context))
           return;
-        const longhand = resolveLonghand(node.name.name, context);
-        if (longhand)
-          return;
-        sendReport(node.name, node.name.name);
+        sendReport(node.name);
       },
       Property(node) {
         if (!isIdentifier(node.key))
           return;
         if (!isPandaAttribute(node, context))
           return;
-        const longhand = resolveLonghand(node.key.name, context);
-        if (longhand)
-          return;
-        sendReport(node.key, node.key.name);
+        sendReport(node.key);
       }
     };
   }
 });
-var prefer_shorthand_properties_default = rule14;
+var prefer_shorthand_properties_default = rule15;
 
 // src/rules/prefer-atomic-properties.ts
 init_cjs_shims();
@@ -9368,9 +9403,9 @@ var compositeProperties = {
 };
 
 // src/rules/prefer-atomic-properties.ts
-var RULE_NAME15 = "prefer-atomic-properties";
-var rule15 = createRule({
-  name: RULE_NAME15,
+var RULE_NAME16 = "prefer-atomic-properties";
+var rule16 = createRule({
+  name: RULE_NAME16,
   meta: {
     docs: {
       description: "Encourage the use of atomic properties instead of composite properties in the codebase."
@@ -9390,14 +9425,16 @@ var rule15 = createRule({
       if (isValidProperty(longhand, context) && Object.hasOwn(compositeProperties, longhand))
         return longhand;
     };
-    const sendReport = (node, name2) => {
-      const cmp = resolveCompositeProperty(name2);
-      const atomics = compositeProperties[cmp].map((name3) => `\`${name3}\``).join(",\n");
+    const sendReport = (node) => {
+      const cmp = resolveCompositeProperty(node.name);
+      if (!cmp)
+        return;
+      const atomics = compositeProperties[cmp].map((name2) => `\`${name2}\``).join(",\n");
       return context.report({
         node,
         messageId: "atomic",
         data: {
-          composite: name2,
+          composite: node.name,
           atomics
         }
       });
@@ -9408,31 +9445,25 @@ var rule15 = createRule({
           return;
         if (!isPandaProp(node, context))
           return;
-        const cmp = resolveCompositeProperty(node.name.name);
-        if (!cmp)
-          return;
-        sendReport(node, node.name.name);
+        sendReport(node.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);
+        sendReport(node.key);
       }
     };
   }
 });
-var prefer_atomic_properties_default = rule15;
+var prefer_atomic_properties_default = rule16;
 
 // src/rules/prefer-composite-properties.ts
 init_cjs_shims();
-var RULE_NAME16 = "prefer-composite-properties";
-var rule16 = createRule({
-  name: RULE_NAME16,
+var RULE_NAME17 = "prefer-composite-properties";
+var rule17 = createRule({
+  name: RULE_NAME17,
   meta: {
     docs: {
       description: "Encourage the use of composite properties instead of atomic properties in the codebase."
@@ -9451,14 +9482,16 @@ var rule16 = createRule({
         return;
       return Object.keys(compositeProperties).find((cpd) => compositeProperties[cpd].includes(longhand));
     };
-    const sendReport = (node, name2) => {
-      const cmp = resolveCompositeProperty(name2);
+    const sendReport = (node) => {
+      const cmp = resolveCompositeProperty(node.name);
+      if (!cmp)
+        return;
       return context.report({
         node,
         messageId: "composite",
         data: {
           composite: cmp,
-          atomic: name2
+          atomic: node.name
         }
       });
     };
@@ -9468,31 +9501,25 @@ var rule16 = createRule({
           return;
         if (!isPandaProp(node, context))
           return;
-        const atm = resolveCompositeProperty(node.name.name);
-        if (!atm)
-          return;
-        sendReport(node, node.name.name);
+        sendReport(node.name);
       },
       Property(node) {
         if (!isIdentifier(node.key))
           return;
         if (!isPandaAttribute(node, context))
           return;
-        const atm = resolveCompositeProperty(node.key.name);
-        if (!atm)
-          return;
-        sendReport(node.key, node.key.name);
+        sendReport(node.key);
       }
     };
   }
 });
-var prefer_composite_properties_default = rule16;
+var prefer_composite_properties_default = rule17;
 
 // src/rules/prefer-unified-property-style.ts
 init_cjs_shims();
-var RULE_NAME17 = "prefer-unified-property-style";
-var rule17 = createRule({
-  name: RULE_NAME17,
+var RULE_NAME18 = "prefer-unified-property-style";
+var rule18 = createRule({
+  name: RULE_NAME18,
   meta: {
     docs: {
       description: "Discourage against mixing atomic and composite forms of the same property in a style declaration. Atomic styles give more consistent results"
@@ -9559,7 +9586,7 @@ var rule17 = createRule({
     };
   }
 });
-var prefer_unified_property_style_default = rule17;
+var prefer_unified_property_style_default = rule18;
 
 // src/rules/index.ts
 var rules = {
@@ -9572,14 +9599,15 @@ var rules = {
   [RULE_NAME7]: no_important_default,
   [RULE_NAME9]: no_invalid_token_paths_default,
   [RULE_NAME8]: no_invalid_nesting_default,
-  [RULE_NAME11]: no_property_renaming_default,
-  [RULE_NAME10]: no_physical_properties_default,
-  [RULE_NAME12]: no_unsafe_token_fn_usage_default,
-  [RULE_NAME13]: prefer_longhand_properties_default,
-  [RULE_NAME14]: prefer_shorthand_properties_default,
-  [RULE_NAME15]: prefer_atomic_properties_default,
-  [RULE_NAME16]: prefer_composite_properties_default,
-  [RULE_NAME17]: prefer_unified_property_style_default
+  [RULE_NAME10]: no_margin_properties_default,
+  [RULE_NAME11]: no_physical_properties_default,
+  [RULE_NAME12]: no_property_renaming_default,
+  [RULE_NAME13]: no_unsafe_token_fn_usage_default,
+  [RULE_NAME14]: prefer_longhand_properties_default,
+  [RULE_NAME15]: prefer_shorthand_properties_default,
+  [RULE_NAME16]: prefer_atomic_properties_default,
+  [RULE_NAME17]: prefer_composite_properties_default,
+  [RULE_NAME18]: prefer_unified_property_style_default
 };
 
 // src/configs/all.ts
@@ -9610,7 +9638,7 @@ var recommended_default = {
     "@pandacss/no-invalid-nesting": "error",
     "@pandacss/no-invalid-token-paths": "error",
     "@pandacss/no-property-renaming": "warn",
-    "@pandacss/prefer-unified-property-style": "warn"
+    "@pandacss/no-unsafe-token-fn-usage": "warn"
   }
 };
 

package/dist/index.mjs

@@ -10,7 +10,7 @@ var name, version;
 var init_package = __esm({
   "package.json"() {
     name = "@pandacss/eslint-plugin";
-    version = "0.0.15";
+    version = "0.0.17";
   }
 });
 
@@ -8898,6 +8898,61 @@ var init_no_invalid_token_paths = __esm({
   }
 });
 
+// src/rules/no-margin-properties.ts
+var RULE_NAME10, rule10, no_margin_properties_default;
+var init_no_margin_properties = __esm({
+  "src/rules/no-margin-properties.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_helpers();
+    init_utils();
+    init_nodes();
+    RULE_NAME10 = "no-margin-properties";
+    rule10 = createRule({
+      name: RULE_NAME10,
+      meta: {
+        docs: {
+          description: "Discourage using margin properties for spacing; prefer defining spacing in parent elements with `flex` or `grid` using the `gap` property for a more resilient layout. Margins make components less reusable in other contexts."
+        },
+        messages: {
+          noMargin: "Use flex or grid with the `gap` property to define spacing in parent elements for a more resilient layout."
+        },
+        type: "suggestion",
+        schema: []
+      },
+      defaultOptions: [],
+      create(context) {
+        const getLonghand = (name2) => resolveLonghand(name2, context) ?? name2;
+        const sendReport = (node) => {
+          if (!getLonghand(node.name).toLowerCase().includes("margin"))
+            return;
+          return context.report({
+            node,
+            messageId: "noMargin"
+          });
+        };
+        return {
+          JSXAttribute(node) {
+            if (!isJSXIdentifier(node.name))
+              return;
+            if (!isPandaProp(node, context))
+              return;
+            sendReport(node.name);
+          },
+          Property(node) {
+            if (!isIdentifier(node.key))
+              return;
+            if (!isPandaAttribute(node, context))
+              return;
+            sendReport(node.key);
+          }
+        };
+      }
+    });
+    no_margin_properties_default = rule10;
+  }
+});
+
 // src/utils/physical-properties.ts
 var physicalProperties;
 var init_physical_properties = __esm({
@@ -8942,7 +8997,7 @@ var init_physical_properties = __esm({
 });
 
 // src/rules/no-physical-properties.ts
-var RULE_NAME10, rule10, no_physical_properties_default;
+var RULE_NAME11, rule11, no_physical_properties_default;
 var init_no_physical_properties = __esm({
   "src/rules/no-physical-properties.ts"() {
     "use strict";
@@ -8951,9 +9006,9 @@ var init_no_physical_properties = __esm({
     init_utils();
     init_nodes();
     init_physical_properties();
-    RULE_NAME10 = "no-physical-properties";
-    rule10 = createRule({
-      name: RULE_NAME10,
+    RULE_NAME11 = "no-physical-properties";
+    rule11 = createRule({
+      name: RULE_NAME11,
       meta: {
         docs: {
           description: "Encourage the use of [logical properties](https://mdn.io/logical-properties-basic-concepts) over physical proeprties, to foster a responsive and adaptable user interface."
@@ -8969,21 +9024,23 @@ var init_no_physical_properties = __esm({
       defaultOptions: [],
       create(context) {
         const getLonghand = (name2) => resolveLonghand(name2, context) ?? name2;
-        const sendReport = (node, name2) => {
-          const logical = physicalProperties[getLonghand(name2)];
-          const longhand = resolveLonghand(name2, context);
+        const sendReport = (node) => {
+          if (!(getLonghand(node.name) in physicalProperties))
+            return;
+          const logical = physicalProperties[getLonghand(node.name)];
+          const longhand = resolveLonghand(node.name, context);
           return context.report({
             node,
             messageId: "physical",
             data: {
-              physical: `\`${name2}\`${longhand ? ` - \`${longhand}\`` : ""}`,
+              physical: `\`${node.name}\`${longhand ? ` - \`${longhand}\`` : ""}`,
               logical
             },
             suggest: [
               {
                 messageId: "replace",
                 data: {
-                  physical: name2,
+                  physical: node.name,
                   logical
                 },
                 fix: (fixer) => {
@@ -8999,28 +9056,24 @@ var init_no_physical_properties = __esm({
               return;
             if (!isPandaProp(node, context))
               return;
-            if (getLonghand(node.name.name) in physicalProperties) {
-              sendReport(node.name, node.name.name);
-            }
+            sendReport(node.name);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
             if (!isPandaAttribute(node, context))
               return;
-            if (getLonghand(node.key.name) in physicalProperties) {
-              sendReport(node.key, node.key.name);
-            }
+            sendReport(node.key);
           }
         };
       }
     });
-    no_physical_properties_default = rule10;
+    no_physical_properties_default = rule11;
   }
 });
 
 // src/rules/no-property-renaming.ts
-var RULE_NAME11, rule11, no_property_renaming_default;
+var RULE_NAME12, rule12, no_property_renaming_default;
 var init_no_property_renaming = __esm({
   "src/rules/no-property-renaming.ts"() {
     "use strict";
@@ -9028,9 +9081,9 @@ var init_no_property_renaming = __esm({
     init_utils();
     init_helpers();
     init_nodes();
-    RULE_NAME11 = "no-property-renaming";
-    rule11 = createRule({
-      name: RULE_NAME11,
+    RULE_NAME12 = "no-property-renaming";
+    rule12 = createRule({
+      name: RULE_NAME12,
       meta: {
         docs: {
           description: "Ensure user does not rename a property for a pattern or style prop. \nIt doesn't get tracked."
@@ -9053,6 +9106,14 @@ var init_no_property_renaming = __esm({
             }
           });
         };
+        const handleReport = (node, value, attr) => {
+          if (isIdentifier(value) && attr !== value.name) {
+            return sendReport(node, attr, value.name);
+          }
+          if (isMemberExpression(value) && isIdentifier(value.property) && attr !== value.property.name) {
+            return sendReport(node, attr, value.property.name);
+          }
+        };
         return {
           JSXAttribute(node) {
             if (!node.value)
@@ -9063,12 +9124,7 @@ var init_no_property_renaming = __esm({
               return;
             const attr = node.name.name.toString();
             const expression = node.value.expression;
-            if (isIdentifier(expression) && attr !== expression.name) {
-              return sendReport(node, attr, expression.name);
-            }
-            if (isMemberExpression(expression) && isIdentifier(expression.property) && attr !== expression.property.name) {
-              return sendReport(node, attr, expression.property.name);
-            }
+            handleReport(node, expression, attr);
           },
           Property(node) {
             if (!isIdentifier(node.key))
@@ -9079,24 +9135,19 @@ var init_no_property_renaming = __esm({
               return;
             const attr = node.key.name.toString();
             const value = node.value;
-            if (isIdentifier(value) && attr !== value.name) {
-              return sendReport(node, attr, value.name);
-            }
-            if (isMemberExpression(value) && isIdentifier(value.property) && attr !== value.property.name) {
-              return sendReport(node, attr, value.property.name);
-            }
+            handleReport(node, value, attr);
           }
         };
       }
     });
-    no_property_renaming_default = rule11;
+    no_property_renaming_default = rule12;
   }
 });
 
 // src/rules/no-unsafe-token-fn-usage.ts
 import "@typescript-eslint/utils";
 import { getArbitraryValue as getArbitraryValue3 } from "@pandacss/shared";
-var RULE_NAME12, rule12, no_unsafe_token_fn_usage_default;
+var RULE_NAME13, rule13, no_unsafe_token_fn_usage_default;
 var init_no_unsafe_token_fn_usage = __esm({
   "src/rules/no-unsafe-token-fn-usage.ts"() {
     "use strict";
@@ -9104,9 +9155,9 @@ var init_no_unsafe_token_fn_usage = __esm({
     init_helpers();
     init_utils();
     init_nodes();
-    RULE_NAME12 = "no-unsafe-token-fn-usage";
-    rule12 = createRule({
-      name: RULE_NAME12,
+    RULE_NAME13 = "no-unsafe-token-fn-usage";
+    rule13 = createRule({
+      name: RULE_NAME13,
       meta: {
         docs: {
           description: "Prevent users from using the token function in situations where they could simply use the raw design token."
@@ -9202,12 +9253,12 @@ var init_no_unsafe_token_fn_usage = __esm({
         };
       }
     });
-    no_unsafe_token_fn_usage_default = rule12;
+    no_unsafe_token_fn_usage_default = rule13;
   }
 });
 
 // src/rules/prefer-longhand-properties.ts
-var RULE_NAME13, rule13, prefer_longhand_properties_default;
+var RULE_NAME14, rule14, prefer_longhand_properties_default;
 var init_prefer_longhand_properties = __esm({
   "src/rules/prefer-longhand-properties.ts"() {
     "use strict";
@@ -9215,9 +9266,9 @@ var init_prefer_longhand_properties = __esm({
     init_helpers();
     init_utils();
     init_nodes();
-    RULE_NAME13 = "prefer-longhand-properties";
-    rule13 = createRule({
-      name: RULE_NAME13,
+    RULE_NAME14 = "prefer-longhand-properties";
+    rule14 = createRule({
+      name: RULE_NAME14,
       meta: {
         docs: {
           description: "Discourage the use of shorthand properties and promote the preference for longhand properties in the codebase."
@@ -9232,10 +9283,12 @@ var init_prefer_longhand_properties = __esm({
       },
       defaultOptions: [],
       create(context) {
-        const sendReport = (node, name2) => {
-          const longhand = resolveLonghand(name2, context);
+        const sendReport = (node) => {
+          const longhand = resolveLonghand(node.name, context);
+          if (!longhand)
+            return;
           const data = {
-            shorthand: name2,
+            shorthand: node.name,
             longhand
           };
           return context.report({
@@ -9259,30 +9312,24 @@ var init_prefer_longhand_properties = __esm({
               return;
             if (!isPandaProp(node, context))
               return;
-            const longhand = resolveLonghand(node.name.name, context);
-            if (!longhand)
-              return;
-            sendReport(node.name, node.name.name);
+            sendReport(node.name);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
             if (!isPandaAttribute(node, context))
               return;
-            const longhand = resolveLonghand(node.key.name, context);
-            if (!longhand)
-              return;
-            sendReport(node.key, node.key.name);
+            sendReport(node.key);
           }
         };
       }
     });
-    prefer_longhand_properties_default = rule13;
+    prefer_longhand_properties_default = rule14;
   }
 });
 
 // src/rules/prefer-shorthand-properties.ts
-var RULE_NAME14, rule14, prefer_shorthand_properties_default;
+var RULE_NAME15, rule15, prefer_shorthand_properties_default;
 var init_prefer_shorthand_properties = __esm({
   "src/rules/prefer-shorthand-properties.ts"() {
     "use strict";
@@ -9290,9 +9337,9 @@ var init_prefer_shorthand_properties = __esm({
     init_helpers();
     init_utils();
     init_nodes();
-    RULE_NAME14 = "prefer-shorthand-properties";
-    rule14 = createRule({
-      name: RULE_NAME14,
+    RULE_NAME15 = "prefer-shorthand-properties";
+    rule15 = createRule({
+      name: RULE_NAME15,
       meta: {
         docs: {
           description: "Discourage the use of longhand properties and promote the preference for shorthand properties in the codebase."
@@ -9307,13 +9354,16 @@ var init_prefer_shorthand_properties = __esm({
       },
       defaultOptions: [],
       create(context) {
-        const sendReport = (node, name2) => {
-          const shorthands = resolveShorthands(name2, context);
+        const sendReport = (node) => {
+          const longhand = resolveLonghand(node.name, context);
+          if (longhand)
+            return;
+          const shorthands = resolveShorthands(node.name, context);
           if (!shorthands)
             return;
           const shorthand = shorthands.map((s) => `\`${s}\``)?.join(", ");
           const data = {
-            longhand: name2,
+            longhand: node.name,
             shorthand
           };
           return context.report({
@@ -9337,25 +9387,19 @@ var init_prefer_shorthand_properties = __esm({
               return;
             if (!isPandaProp(node, context))
               return;
-            const longhand = resolveLonghand(node.name.name, context);
-            if (longhand)
-              return;
-            sendReport(node.name, node.name.name);
+            sendReport(node.name);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
             if (!isPandaAttribute(node, context))
               return;
-            const longhand = resolveLonghand(node.key.name, context);
-            if (longhand)
-              return;
-            sendReport(node.key, node.key.name);
+            sendReport(node.key);
           }
         };
       }
     });
-    prefer_shorthand_properties_default = rule14;
+    prefer_shorthand_properties_default = rule15;
   }
 });
 
@@ -9480,7 +9524,7 @@ var init_composite_properties = __esm({
 });
 
 // src/rules/prefer-atomic-properties.ts
-var RULE_NAME15, rule15, prefer_atomic_properties_default;
+var RULE_NAME16, rule16, prefer_atomic_properties_default;
 var init_prefer_atomic_properties = __esm({
   "src/rules/prefer-atomic-properties.ts"() {
     "use strict";
@@ -9489,9 +9533,9 @@ var init_prefer_atomic_properties = __esm({
     init_utils();
     init_composite_properties();
     init_nodes();
-    RULE_NAME15 = "prefer-atomic-properties";
-    rule15 = createRule({
-      name: RULE_NAME15,
+    RULE_NAME16 = "prefer-atomic-properties";
+    rule16 = createRule({
+      name: RULE_NAME16,
       meta: {
         docs: {
           description: "Encourage the use of atomic properties instead of composite properties in the codebase."
@@ -9511,14 +9555,16 @@ var init_prefer_atomic_properties = __esm({
           if (isValidProperty(longhand, context) && Object.hasOwn(compositeProperties, longhand))
             return longhand;
         };
-        const sendReport = (node, name2) => {
-          const cmp = resolveCompositeProperty(name2);
-          const atomics = compositeProperties[cmp].map((name3) => `\`${name3}\``).join(",\n");
+        const sendReport = (node) => {
+          const cmp = resolveCompositeProperty(node.name);
+          if (!cmp)
+            return;
+          const atomics = compositeProperties[cmp].map((name2) => `\`${name2}\``).join(",\n");
           return context.report({
             node,
             messageId: "atomic",
             data: {
-              composite: name2,
+              composite: node.name,
               atomics
             }
           });
@@ -9529,30 +9575,24 @@ var init_prefer_atomic_properties = __esm({
               return;
             if (!isPandaProp(node, context))
               return;
-            const cmp = resolveCompositeProperty(node.name.name);
-            if (!cmp)
-              return;
-            sendReport(node, node.name.name);
+            sendReport(node.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);
+            sendReport(node.key);
           }
         };
       }
     });
-    prefer_atomic_properties_default = rule15;
+    prefer_atomic_properties_default = rule16;
   }
 });
 
 // src/rules/prefer-composite-properties.ts
-var RULE_NAME16, rule16, prefer_composite_properties_default;
+var RULE_NAME17, rule17, prefer_composite_properties_default;
 var init_prefer_composite_properties = __esm({
   "src/rules/prefer-composite-properties.ts"() {
     "use strict";
@@ -9561,9 +9601,9 @@ var init_prefer_composite_properties = __esm({
     init_utils();
     init_composite_properties();
     init_nodes();
-    RULE_NAME16 = "prefer-composite-properties";
-    rule16 = createRule({
-      name: RULE_NAME16,
+    RULE_NAME17 = "prefer-composite-properties";
+    rule17 = createRule({
+      name: RULE_NAME17,
       meta: {
         docs: {
           description: "Encourage the use of composite properties instead of atomic properties in the codebase."
@@ -9582,14 +9622,16 @@ var init_prefer_composite_properties = __esm({
             return;
           return Object.keys(compositeProperties).find((cpd) => compositeProperties[cpd].includes(longhand));
         };
-        const sendReport = (node, name2) => {
-          const cmp = resolveCompositeProperty(name2);
+        const sendReport = (node) => {
+          const cmp = resolveCompositeProperty(node.name);
+          if (!cmp)
+            return;
           return context.report({
             node,
             messageId: "composite",
             data: {
               composite: cmp,
-              atomic: name2
+              atomic: node.name
             }
           });
         };
@@ -9599,30 +9641,24 @@ var init_prefer_composite_properties = __esm({
               return;
             if (!isPandaProp(node, context))
               return;
-            const atm = resolveCompositeProperty(node.name.name);
-            if (!atm)
-              return;
-            sendReport(node, node.name.name);
+            sendReport(node.name);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
             if (!isPandaAttribute(node, context))
               return;
-            const atm = resolveCompositeProperty(node.key.name);
-            if (!atm)
-              return;
-            sendReport(node.key, node.key.name);
+            sendReport(node.key);
           }
         };
       }
     });
-    prefer_composite_properties_default = rule16;
+    prefer_composite_properties_default = rule17;
   }
 });
 
 // src/rules/prefer-unified-property-style.ts
-var RULE_NAME17, rule17, prefer_unified_property_style_default;
+var RULE_NAME18, rule18, prefer_unified_property_style_default;
 var init_prefer_unified_property_style = __esm({
   "src/rules/prefer-unified-property-style.ts"() {
     "use strict";
@@ -9631,9 +9667,9 @@ var init_prefer_unified_property_style = __esm({
     init_utils();
     init_composite_properties();
     init_nodes();
-    RULE_NAME17 = "prefer-unified-property-style";
-    rule17 = createRule({
-      name: RULE_NAME17,
+    RULE_NAME18 = "prefer-unified-property-style";
+    rule18 = createRule({
+      name: RULE_NAME18,
       meta: {
         docs: {
           description: "Discourage against mixing atomic and composite forms of the same property in a style declaration. Atomic styles give more consistent results"
@@ -9700,7 +9736,7 @@ var init_prefer_unified_property_style = __esm({
         };
       }
     });
-    prefer_unified_property_style_default = rule17;
+    prefer_unified_property_style_default = rule18;
   }
 });
 
@@ -9719,6 +9755,7 @@ var init_rules = __esm({
     init_no_important();
     init_no_invalid_nesting();
     init_no_invalid_token_paths();
+    init_no_margin_properties();
     init_no_physical_properties();
     init_no_property_renaming();
     init_no_unsafe_token_fn_usage();
@@ -9737,14 +9774,15 @@ var init_rules = __esm({
       [RULE_NAME7]: no_important_default,
       [RULE_NAME9]: no_invalid_token_paths_default,
       [RULE_NAME8]: no_invalid_nesting_default,
-      [RULE_NAME11]: no_property_renaming_default,
-      [RULE_NAME10]: no_physical_properties_default,
-      [RULE_NAME12]: no_unsafe_token_fn_usage_default,
-      [RULE_NAME13]: prefer_longhand_properties_default,
-      [RULE_NAME14]: prefer_shorthand_properties_default,
-      [RULE_NAME15]: prefer_atomic_properties_default,
-      [RULE_NAME16]: prefer_composite_properties_default,
-      [RULE_NAME17]: prefer_unified_property_style_default
+      [RULE_NAME10]: no_margin_properties_default,
+      [RULE_NAME11]: no_physical_properties_default,
+      [RULE_NAME12]: no_property_renaming_default,
+      [RULE_NAME13]: no_unsafe_token_fn_usage_default,
+      [RULE_NAME14]: prefer_longhand_properties_default,
+      [RULE_NAME15]: prefer_shorthand_properties_default,
+      [RULE_NAME16]: prefer_atomic_properties_default,
+      [RULE_NAME17]: prefer_composite_properties_default,
+      [RULE_NAME18]: prefer_unified_property_style_default
     };
   }
 });
@@ -9792,7 +9830,7 @@ var init_recommended = __esm({
         "@pandacss/no-invalid-nesting": "error",
         "@pandacss/no-invalid-token-paths": "error",
         "@pandacss/no-property-renaming": "warn",
-        "@pandacss/prefer-unified-property-style": "warn"
+        "@pandacss/no-unsafe-token-fn-usage": "warn"
       }
     };
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pandacss/eslint-plugin",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "description": "Eslint plugin for Panda CSS",
   "author": "Abraham Aremu <anubra266@gmail.com>",
   "main": "dist/index.js",