@pandacss/eslint-plugin 0.0.9 → 0.0.11

package/dist/index.js

@@ -7957,7 +7957,7 @@ init_cjs_shims();
 
 // package.json
 var name = "@pandacss/eslint-plugin";
-var version = "0.0.9";
+var version = "0.0.11";
 
 // src/configs/all.ts
 init_cjs_shims();
@@ -8161,8 +8161,8 @@ var isPandaAttribute = (node, context) => {
 var resolveLonghand = (name2, context) => {
   return syncAction("resolveLongHand", getSyncOpts(context), name2);
 };
-var resolveShorthand = (name2, context) => {
-  return syncAction("resolveShorthand", getSyncOpts(context), name2);
+var resolveShorthands = (name2, context) => {
+  return syncAction("resolveShorthands", getSyncOpts(context), name2);
 };
 var isColorAttribute = (attr, context) => {
   return syncAction("isColorAttribute", getSyncOpts(context), attr);
@@ -8390,7 +8390,7 @@ var rule4 = createRule({
           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;
@@ -8755,12 +8755,12 @@ var no_property_renaming_default = rule8;
 
 // src/rules/prefer-longhand-properties.ts
 init_cjs_shims();
-var RULE_NAME9 = "no-shorthand-prop";
+var RULE_NAME9 = "prefer-longhand-properties";
 var rule9 = createRule({
   name: RULE_NAME9,
   meta: {
     docs: {
-      description: "Discourage the use of shorthand properties and promote the preference for longhand CSS properties in the codebase."
+      description: "Discourage the use of shorthand properties and promote the preference for longhand properties in the codebase."
     },
     messages: {
       longhand: "Use longhand property of `{{shorthand}}` instead. Prefer `{{longhand}}`",
@@ -8819,12 +8819,81 @@ var rule9 = createRule({
 });
 var prefer_longhand_properties_default = rule9;
 
-// src/rules/no-unsafe-token-fn-usage.ts
+// src/rules/prefer-shorthand-properties.ts
 init_cjs_shims();
-var import_utils14 = require("@typescript-eslint/utils");
-var RULE_NAME10 = "no-unsafe-token-fn-usage";
+var RULE_NAME10 = "prefer-shorthand-properties";
 var rule10 = createRule({
   name: RULE_NAME10,
+  meta: {
+    docs: {
+      description: "Discourage the use of longhand properties and promote the preference for shorthand properties in the codebase."
+    },
+    messages: {
+      shorthand: "Use shorthand property of `{{longhand}}` instead. Prefer {{shorthand}}",
+      replace: "Replace `{{longhand}}` with `{{shorthand}}`"
+    },
+    type: "suggestion",
+    hasSuggestions: true,
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const sendReport = (node, name2) => {
+      const shorthands = resolveShorthands(name2, context);
+      if (!shorthands)
+        return;
+      const shorthand = shorthands.map((s) => "`" + s + "`")?.join(", ");
+      const data = {
+        longhand: name2,
+        shorthand
+      };
+      return context.report({
+        node,
+        messageId: "shorthand",
+        data,
+        suggest: [
+          {
+            messageId: "replace",
+            data,
+            fix: (fixer) => {
+              return fixer.replaceTextRange(node.range, shorthands[0]);
+            }
+          }
+        ]
+      });
+    };
+    return {
+      JSXAttribute(node) {
+        if (!isJSXIdentifier(node.name))
+          return;
+        if (!isPandaProp(node, context))
+          return;
+        const longhand = resolveLonghand(node.name.name, context);
+        if (longhand)
+          return;
+        sendReport(node.name, node.name.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);
+      }
+    };
+  }
+});
+var prefer_shorthand_properties_default = rule10;
+
+// src/rules/no-unsafe-token-fn-usage.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,
   meta: {
     docs: {
       description: "Prevent users from using the token function in situations where they could simply use the raw design token."
@@ -8920,7 +8989,7 @@ var rule10 = createRule({
     };
   }
 });
-var no_unsafe_token_fn_usage_default = rule10;
+var no_unsafe_token_fn_usage_default = rule11;
 
 // src/rules/prefer-atomic-properties.ts
 init_cjs_shims();
@@ -9040,12 +9109,12 @@ var compositeProperties = {
 };
 
 // src/rules/prefer-atomic-properties.ts
-var RULE_NAME11 = "prefer-atomic-properties";
-var rule11 = createRule({
-  name: RULE_NAME11,
+var RULE_NAME12 = "prefer-atomic-properties";
+var rule12 = createRule({
+  name: RULE_NAME12,
   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}}"
@@ -9058,7 +9127,7 @@ var rule11 = createRule({
     const resolveCompositeProperty = (name2) => {
       if (Object.hasOwn(compositeProperties, name2))
         return name2;
-      const longhand = resolveShorthand(name2, context);
+      const longhand = resolveLonghand(name2, context) ?? name2;
       if (isValidProperty(longhand, context) && Object.hasOwn(compositeProperties, longhand))
         return longhand;
     };
@@ -9098,7 +9167,67 @@ var rule11 = createRule({
     };
   }
 });
-var prefer_atomic_properties_default = rule11;
+var prefer_atomic_properties_default = rule12;
+
+// src/rules/prefer-composite-properties.ts
+init_cjs_shims();
+var RULE_NAME13 = "prefer-composite-properties";
+var rule13 = createRule({
+  name: RULE_NAME13,
+  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);
+      },
+      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);
+      }
+    };
+  }
+});
+var prefer_composite_properties_default = rule13;
 
 // src/rules/index.ts
 var rules = {
@@ -9111,8 +9240,10 @@ var rules = {
   [RULE_NAME7]: no_invalid_token_paths_default,
   [RULE_NAME8]: no_property_renaming_default,
   [RULE_NAME9]: prefer_longhand_properties_default,
-  [RULE_NAME10]: no_unsafe_token_fn_usage_default,
-  [RULE_NAME11]: prefer_atomic_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
 };
 
 // src/configs/all.ts

package/dist/index.mjs

@@ -10,7 +10,7 @@ var name, version;
 var init_package = __esm({
   "package.json"() {
     name = "@pandacss/eslint-plugin";
-    version = "0.0.9";
+    version = "0.0.11";
   }
 });
 
@@ -7974,7 +7974,7 @@ var init_nodes = __esm({
 });
 
 // src/utils/helpers.ts
-var import_scope_manager, getAncestor, getSyncOpts, getImportSpecifiers, _getImports, getImports, isValidStyledProp, isPandaIsh, findDeclaration, isLocalStyledFactory, isValidFile, isValidProperty, isPandaImport, isPandaProp, isInPandaFunction, isPandaAttribute, resolveLonghand, resolveShorthand, isColorAttribute, isColorToken, extractTokens, getInvalidTokens, getTokenImport;
+var import_scope_manager, getAncestor, getSyncOpts, getImportSpecifiers, _getImports, getImports, isValidStyledProp, isPandaIsh, findDeclaration, isLocalStyledFactory, isValidFile, isValidProperty, isPandaImport, isPandaProp, isInPandaFunction, isPandaAttribute, resolveLonghand, resolveShorthands, isColorAttribute, isColorToken, extractTokens, getInvalidTokens, getTokenImport;
 var init_helpers = __esm({
   "src/utils/helpers.ts"() {
     "use strict";
@@ -8137,8 +8137,8 @@ var init_helpers = __esm({
     resolveLonghand = (name2, context) => {
       return syncAction("resolveLongHand", getSyncOpts(context), name2);
     };
-    resolveShorthand = (name2, context) => {
-      return syncAction("resolveShorthand", getSyncOpts(context), name2);
+    resolveShorthands = (name2, context) => {
+      return syncAction("resolveShorthands", getSyncOpts(context), name2);
     };
     isColorAttribute = (attr, context) => {
       return syncAction("isColorAttribute", getSyncOpts(context), attr);
@@ -8402,7 +8402,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;
@@ -8812,12 +8812,12 @@ var init_prefer_longhand_properties = __esm({
     init_helpers();
     init_utils();
     init_nodes();
-    RULE_NAME9 = "no-shorthand-prop";
+    RULE_NAME9 = "prefer-longhand-properties";
     rule9 = createRule({
       name: RULE_NAME9,
       meta: {
         docs: {
-          description: "Discourage the use of shorthand properties and promote the preference for longhand CSS properties in the codebase."
+          description: "Discourage the use of shorthand properties and promote the preference for longhand properties in the codebase."
         },
         messages: {
           longhand: "Use longhand property of `{{shorthand}}` instead. Prefer `{{longhand}}`",
@@ -8878,9 +8878,87 @@ var init_prefer_longhand_properties = __esm({
   }
 });
 
+// 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"() {
+    "use strict";
+    init_esm_shims();
+    init_helpers();
+    init_utils();
+    init_nodes();
+    RULE_NAME10 = "prefer-shorthand-properties";
+    rule10 = createRule({
+      name: RULE_NAME10,
+      meta: {
+        docs: {
+          description: "Discourage the use of longhand properties and promote the preference for shorthand properties in the codebase."
+        },
+        messages: {
+          shorthand: "Use shorthand property of `{{longhand}}` instead. Prefer {{shorthand}}",
+          replace: "Replace `{{longhand}}` with `{{shorthand}}`"
+        },
+        type: "suggestion",
+        hasSuggestions: true,
+        schema: []
+      },
+      defaultOptions: [],
+      create(context) {
+        const sendReport = (node, name2) => {
+          const shorthands = resolveShorthands(name2, context);
+          if (!shorthands)
+            return;
+          const shorthand = shorthands.map((s) => "`" + s + "`")?.join(", ");
+          const data = {
+            longhand: name2,
+            shorthand
+          };
+          return context.report({
+            node,
+            messageId: "shorthand",
+            data,
+            suggest: [
+              {
+                messageId: "replace",
+                data,
+                fix: (fixer) => {
+                  return fixer.replaceTextRange(node.range, shorthands[0]);
+                }
+              }
+            ]
+          });
+        };
+        return {
+          JSXAttribute(node) {
+            if (!isJSXIdentifier(node.name))
+              return;
+            if (!isPandaProp(node, context))
+              return;
+            const longhand = resolveLonghand(node.name.name, context);
+            if (longhand)
+              return;
+            sendReport(node.name, node.name.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);
+          }
+        };
+      }
+    });
+    prefer_shorthand_properties_default = rule10;
+  }
+});
+
 // src/rules/no-unsafe-token-fn-usage.ts
 import "@typescript-eslint/utils";
-var RULE_NAME10, rule10, no_unsafe_token_fn_usage_default;
+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"() {
     "use strict";
@@ -8888,9 +8966,9 @@ var init_no_unsafe_token_fn_usage = __esm({
     init_helpers();
     init_utils();
     init_nodes();
-    RULE_NAME10 = "no-unsafe-token-fn-usage";
-    rule10 = createRule({
-      name: RULE_NAME10,
+    RULE_NAME11 = "no-unsafe-token-fn-usage";
+    rule11 = createRule({
+      name: RULE_NAME11,
       meta: {
         docs: {
           description: "Prevent users from using the token function in situations where they could simply use the raw design token."
@@ -8986,7 +9064,7 @@ var init_no_unsafe_token_fn_usage = __esm({
         };
       }
     });
-    no_unsafe_token_fn_usage_default = rule10;
+    no_unsafe_token_fn_usage_default = rule11;
   }
 });
 
@@ -9111,7 +9189,7 @@ var init_composite_properties = __esm({
 });
 
 // src/rules/prefer-atomic-properties.ts
-var RULE_NAME11, rule11, prefer_atomic_properties_default;
+var RULE_NAME12, rule12, prefer_atomic_properties_default;
 var init_prefer_atomic_properties = __esm({
   "src/rules/prefer-atomic-properties.ts"() {
     "use strict";
@@ -9120,12 +9198,12 @@ var init_prefer_atomic_properties = __esm({
     init_utils();
     init_composite_properties();
     init_nodes();
-    RULE_NAME11 = "prefer-atomic-properties";
-    rule11 = createRule({
-      name: RULE_NAME11,
+    RULE_NAME12 = "prefer-atomic-properties";
+    rule12 = createRule({
+      name: RULE_NAME12,
       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}}"
@@ -9138,7 +9216,7 @@ var init_prefer_atomic_properties = __esm({
         const resolveCompositeProperty = (name2) => {
           if (Object.hasOwn(compositeProperties, name2))
             return name2;
-          const longhand = resolveShorthand(name2, context);
+          const longhand = resolveLonghand(name2, context) ?? name2;
           if (isValidProperty(longhand, context) && Object.hasOwn(compositeProperties, longhand))
             return longhand;
         };
@@ -9178,7 +9256,77 @@ var init_prefer_atomic_properties = __esm({
         };
       }
     });
-    prefer_atomic_properties_default = rule11;
+    prefer_atomic_properties_default = rule12;
+  }
+});
+
+// src/rules/prefer-composite-properties.ts
+var RULE_NAME13, rule13, 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_NAME13 = "prefer-composite-properties";
+    rule13 = createRule({
+      name: RULE_NAME13,
+      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);
+          },
+          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);
+          }
+        };
+      }
+    });
+    prefer_composite_properties_default = rule13;
   }
 });
 
@@ -9197,8 +9345,10 @@ var init_rules = __esm({
     init_no_invalid_token_paths();
     init_no_property_renaming();
     init_prefer_longhand_properties();
+    init_prefer_shorthand_properties();
     init_no_unsafe_token_fn_usage();
     init_prefer_atomic_properties();
+    init_prefer_composite_properties();
     rules = {
       [RULE_NAME]: file_not_included_default,
       [RULE_NAME2]: no_config_function_in_source_default,
@@ -9209,8 +9359,10 @@ var init_rules = __esm({
       [RULE_NAME7]: no_invalid_token_paths_default,
       [RULE_NAME8]: no_property_renaming_default,
       [RULE_NAME9]: prefer_longhand_properties_default,
-      [RULE_NAME10]: no_unsafe_token_fn_usage_default,
-      [RULE_NAME11]: prefer_atomic_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
     };
   }
 });

package/dist/utils/worker.js

@@ -3548,8 +3548,9 @@ async function isConfigFile(fileName) {
 async function isValidFile(ctx, fileName) {
   return ctx.getFiles().includes(fileName);
 }
-async function resolveShorthand(ctx, name) {
-  return ctx.utility.resolveShorthand(name);
+async function resolveShorthands(ctx, name) {
+  console.log("name", name, ctx.utility.getPropShorthandsMap().get(name));
+  return ctx.utility.getPropShorthandsMap().get(name);
 }
 async function resolveLongHand(ctx, name) {
   const reverseShorthandsMap = /* @__PURE__ */ new Map();
@@ -3593,8 +3594,8 @@ async function runAsync(action, opts, ...args) {
       return isValidProperty(ctx, ...args);
     case "resolveLongHand":
       return resolveLongHand(ctx, ...args);
-    case "resolveShorthand":
-      return resolveShorthand(ctx, ...args);
+    case "resolveShorthands":
+      return resolveShorthands(ctx, ...args);
     case "isConfigFile":
       return isConfigFile(opts.currentFile);
     case "isValidFile":

package/dist/utils/worker.mjs

@@ -3532,8 +3532,9 @@ async function isConfigFile(fileName) {
 async function isValidFile(ctx, fileName) {
   return ctx.getFiles().includes(fileName);
 }
-async function resolveShorthand(ctx, name) {
-  return ctx.utility.resolveShorthand(name);
+async function resolveShorthands(ctx, name) {
+  console.log("name", name, ctx.utility.getPropShorthandsMap().get(name));
+  return ctx.utility.getPropShorthandsMap().get(name);
 }
 async function resolveLongHand(ctx, name) {
   const reverseShorthandsMap = /* @__PURE__ */ new Map();
@@ -3577,8 +3578,8 @@ async function runAsync(action, opts, ...args) {
       return isValidProperty(ctx, ...args);
     case "resolveLongHand":
       return resolveLongHand(ctx, ...args);
-    case "resolveShorthand":
-      return resolveShorthand(ctx, ...args);
+    case "resolveShorthands":
+      return resolveShorthands(ctx, ...args);
     case "isConfigFile":
       return isConfigFile(opts.currentFile);
     case "isValidFile":

package/package.json

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