@pandacss/eslint-plugin 0.0.0-dev-20240209020540 → 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-20240209020540";
+var version = "0.0.0-dev-20240209200922";
 
 // src/configs/all.ts
 init_cjs_shims();
@@ -8581,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."
@@ -8640,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;
@@ -8687,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."
@@ -8752,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,
@@ -8773,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}'`);
             }
           }
         ]
@@ -8796,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,
@@ -8840,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);
             }
           }
         ]
@@ -8870,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);
       },
@@ -8880,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,
@@ -8909,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]);
             }
           }
         ]
@@ -8967,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();
@@ -9110,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."
@@ -9168,13 +9264,13 @@ var rule12 = createRule({
     };
   }
 });
-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."
@@ -9228,13 +9324,13 @@ 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_NAME14 = "prefer-unified-property-style";
-var rule14 = createRule({
-  name: RULE_NAME14,
+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"
@@ -9301,7 +9397,7 @@ var rule14 = createRule({
     };
   }
 });
-var prefer_unified_property_style_default = rule14;
+var prefer_unified_property_style_default = rule15;
 
 // src/rules/index.ts
 var rules = {
@@ -9311,18 +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_NAME14]: prefer_unified_property_style_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"];

package/dist/index.mjs

@@ -10,7 +10,7 @@ var name, version;
 var init_package = __esm({
   "package.json"() {
     name = "@pandacss/eslint-plugin";
-    version = "0.0.0-dev-20240209020540";
+    version = "0.0.0-dev-20240209200922";
   }
 });
 
@@ -8613,10 +8613,115 @@ var init_no_hardcoded_color = __esm({
   }
 });
 
+// src/rules/no-important.ts
+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;
+          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";
@@ -8624,9 +8729,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."
@@ -8726,12 +8831,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";
@@ -8739,9 +8844,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."
@@ -8800,29 +8905,30 @@ 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";
+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,
@@ -8830,22 +8936,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(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}'`);
                 }
               }
             ]
@@ -8853,51 +8994,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,
@@ -8906,24 +9048,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);
                 }
               }
             ]
@@ -8936,7 +9075,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);
           },
@@ -8946,37 +9085,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,
@@ -8984,57 +9122,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]);
                 }
               }
             ]
@@ -9042,30 +9148,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;
   }
 });
 
@@ -9190,7 +9295,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";
@@ -9199,9 +9304,9 @@ 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 properties in the codebase."
@@ -9257,12 +9362,12 @@ var init_prefer_atomic_properties = __esm({
         };
       }
     });
-    prefer_atomic_properties_default = rule12;
+    prefer_atomic_properties_default = rule13;
   }
 });
 
 // src/rules/prefer-composite-properties.ts
-var RULE_NAME13, rule13, prefer_composite_properties_default;
+var RULE_NAME14, rule14, prefer_composite_properties_default;
 var init_prefer_composite_properties = __esm({
   "src/rules/prefer-composite-properties.ts"() {
     "use strict";
@@ -9271,9 +9376,9 @@ var init_prefer_composite_properties = __esm({
     init_utils();
     init_composite_properties();
     init_nodes();
-    RULE_NAME13 = "prefer-composite-properties";
-    rule13 = createRule({
-      name: RULE_NAME13,
+    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."
@@ -9327,12 +9432,12 @@ var init_prefer_composite_properties = __esm({
         };
       }
     });
-    prefer_composite_properties_default = rule13;
+    prefer_composite_properties_default = rule14;
   }
 });
 
 // src/rules/prefer-unified-property-style.ts
-var RULE_NAME14, rule14, prefer_unified_property_style_default;
+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";
@@ -9341,9 +9446,9 @@ var init_prefer_unified_property_style = __esm({
     init_utils();
     init_composite_properties();
     init_nodes();
-    RULE_NAME14 = "prefer-unified-property-style";
-    rule14 = createRule({
-      name: RULE_NAME14,
+    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"
@@ -9410,7 +9515,7 @@ var init_prefer_unified_property_style = __esm({
         };
       }
     });
-    prefer_unified_property_style_default = rule14;
+    prefer_unified_property_style_default = rule15;
   }
 });
 
@@ -9426,11 +9531,12 @@ 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();
@@ -9441,14 +9547,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_NAME13]: prefer_composite_properties_default,
-      [RULE_NAME14]: prefer_unified_property_style_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
     };
   }
 });
@@ -9463,7 +9570,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"];

package/package.json

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