@pandacss/eslint-plugin 0.2.8 → 0.2.9

package/dist/index.js

@@ -7884,7 +7884,7 @@ init_cjs_shims();
 
 // package.json
 var name = "@pandacss/eslint-plugin";
-var version = "0.2.8";
+var version = "0.2.9";
 
 // src/configs/all.ts
 init_cjs_shims();
@@ -9086,19 +9086,112 @@ var physicalProperties = {
   top: "insetBlockStart",
   bottom: "insetBlockEnd"
 };
+var physicalPropertyValues = {
+  // text-align physical values mapped to logical values
+  textAlign: {
+    left: "start",
+    right: "end"
+  }
+};
 
 // src/rules/no-physical-properties.ts
 var RULE_NAME11 = "no-physical-properties";
+var MESSAGES = {
+  physical: "Use logical property instead of {{physical}}. Prefer `{{logical}}`.",
+  physicalValue: "Use logical value instead of {{physical}}. Prefer `{{logical}}`.",
+  replace: "Replace `{{physical}}` with `{{logical}}`."
+};
+var PropertyCache = class {
+  longhandCache = /* @__PURE__ */ new Map();
+  pandaPropCache = /* @__PURE__ */ new WeakMap();
+  pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+  recipeVariantCache = /* @__PURE__ */ new WeakMap();
+  getLonghand(name2, context) {
+    if (this.longhandCache.has(name2)) {
+      return this.longhandCache.get(name2);
+    }
+    const longhand = resolveLonghand(name2, context) ?? name2;
+    this.longhandCache.set(name2, longhand);
+    return longhand;
+  }
+  isPandaProp(node, context) {
+    if (this.pandaPropCache.has(node)) {
+      return this.pandaPropCache.get(node);
+    }
+    const result = isPandaProp(node, context);
+    this.pandaPropCache.set(node, result);
+    return !!result;
+  }
+  isPandaAttribute(node, context) {
+    if (this.pandaAttributeCache.has(node)) {
+      return this.pandaAttributeCache.get(node);
+    }
+    const result = isPandaAttribute(node, context);
+    this.pandaAttributeCache.set(node, result);
+    return !!result;
+  }
+  isRecipeVariant(node, context) {
+    if (this.recipeVariantCache.has(node)) {
+      return this.recipeVariantCache.get(node);
+    }
+    const result = isRecipeVariant(node, context);
+    this.recipeVariantCache.set(node, result);
+    return !!result;
+  }
+};
+var extractStringLiteralValue = (valueNode) => {
+  if (isLiteral(valueNode) && typeof valueNode.value === "string") {
+    return valueNode.value;
+  }
+  if (isJSXExpressionContainer(valueNode) && isLiteral(valueNode.expression) && typeof valueNode.expression.value === "string") {
+    return valueNode.expression.value;
+  }
+  return null;
+};
+var createPropertyReport = (node, longhandName, logical, context) => {
+  const physicalName = `\`${node.name}\`${longhandName !== node.name ? ` (resolved to \`${longhandName}\`)` : ""}`;
+  context.report({
+    node,
+    messageId: "physical",
+    data: { physical: physicalName, logical },
+    suggest: [
+      {
+        messageId: "replace",
+        data: { physical: node.name, logical },
+        fix: (fixer) => fixer.replaceText(node, logical)
+      }
+    ]
+  });
+};
+var createValueReport = (valueNode, valueText, logical, context) => {
+  context.report({
+    node: valueNode,
+    messageId: "physicalValue",
+    data: { physical: `"${valueText}"`, logical: `"${logical}"` },
+    suggest: [
+      {
+        messageId: "replace",
+        data: { physical: `"${valueText}"`, logical: `"${logical}"` },
+        fix: (fixer) => {
+          if (isLiteral(valueNode)) {
+            return fixer.replaceText(valueNode, `"${logical}"`);
+          }
+          if (isJSXExpressionContainer(valueNode) && isLiteral(valueNode.expression)) {
+            return fixer.replaceText(valueNode.expression, `"${logical}"`);
+          }
+          return null;
+        }
+      }
+    ]
+  });
+};
 var rule11 = createRule({
   name: RULE_NAME11,
   meta: {
     docs: {
       description: "Encourage the use of logical properties over physical properties to foster a responsive and adaptable user interface."
     },
-    messages: {
-      physical: "Use logical property instead of {{physical}}. Prefer `{{logical}}`.",
-      replace: "Replace `{{physical}}` with `{{logical}}`."
-    },
+    messages: MESSAGES,
     type: "suggestion",
     hasSuggestions: true,
     schema: [
@@ -9118,87 +9211,44 @@ var rule11 = createRule({
       }
     ]
   },
-  defaultOptions: [
-    {
-      whitelist: []
-    }
-  ],
+  defaultOptions: [{ whitelist: [] }],
   create(context) {
     const whitelist = context.options[0]?.whitelist ?? [];
-    const longhandCache = /* @__PURE__ */ new Map();
-    const pandaPropCache = /* @__PURE__ */ new WeakMap();
-    const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
-    const recipeVariantCache = /* @__PURE__ */ new WeakMap();
-    const getLonghand = (name2) => {
-      if (longhandCache.has(name2)) {
-        return longhandCache.get(name2);
-      }
-      const longhand = resolveLonghand(name2, context) ?? name2;
-      longhandCache.set(name2, longhand);
-      return longhand;
-    };
-    const isCachedPandaProp = (node) => {
-      if (pandaPropCache.has(node)) {
-        return pandaPropCache.get(node);
-      }
-      const result = isPandaProp(node, context);
-      pandaPropCache.set(node, result);
-      return !!result;
-    };
-    const isCachedPandaAttribute = (node) => {
-      if (pandaAttributeCache.has(node)) {
-        return pandaAttributeCache.get(node);
-      }
-      const result = isPandaAttribute(node, context);
-      pandaAttributeCache.set(node, result);
-      return !!result;
-    };
-    const isCachedRecipeVariant = (node) => {
-      if (recipeVariantCache.has(node)) {
-        return recipeVariantCache.get(node);
-      }
-      const result = isRecipeVariant(node, context);
-      recipeVariantCache.set(node, result);
-      return !!result;
-    };
-    const sendReport = (node) => {
+    const cache = new PropertyCache();
+    const checkPropertyName = (node) => {
       if (whitelist.includes(node.name)) return;
-      const longhandName = getLonghand(node.name);
+      const longhandName = cache.getLonghand(node.name, context);
       if (!(longhandName in physicalProperties)) return;
       const logical = physicalProperties[longhandName];
-      const physicalName = `\`${node.name}\`${longhandName !== node.name ? ` (resolved to \`${longhandName}\`)` : ""}`;
-      context.report({
-        node,
-        messageId: "physical",
-        data: {
-          physical: physicalName,
-          logical
-        },
-        suggest: [
-          {
-            messageId: "replace",
-            data: {
-              physical: node.name,
-              logical
-            },
-            fix: (fixer) => {
-              return fixer.replaceText(node, logical);
-            }
-          }
-        ]
-      });
+      createPropertyReport(node, longhandName, logical, context);
+    };
+    const checkPropertyValue = (keyNode, valueNode) => {
+      const propName = keyNode.name;
+      if (!(propName in physicalPropertyValues)) return false;
+      const valueText = extractStringLiteralValue(valueNode);
+      if (valueText === null) return false;
+      const valueMap = physicalPropertyValues[propName];
+      if (!valueMap[valueText]) return false;
+      createValueReport(valueNode, valueText, valueMap[valueText], context);
+      return true;
     };
     return {
       JSXAttribute(node) {
         if (!isJSXIdentifier(node.name)) return;
-        if (!isCachedPandaProp(node)) return;
-        sendReport(node.name);
+        if (!cache.isPandaProp(node, context)) return;
+        checkPropertyName(node.name);
+        if (node.value) {
+          checkPropertyValue(node.name, node.value);
+        }
       },
       Property(node) {
         if (!isIdentifier(node.key)) return;
-        if (!isCachedPandaAttribute(node)) return;
-        if (isCachedRecipeVariant(node)) return;
-        sendReport(node.key);
+        if (!cache.isPandaAttribute(node, context)) return;
+        if (cache.isRecipeVariant(node, context)) return;
+        checkPropertyName(node.key);
+        if (node.value) {
+          checkPropertyValue(node.key, node.value);
+        }
       }
     };
   }

package/dist/index.mjs

@@ -10,7 +10,7 @@ var name, version;
 var init_package = __esm({
   "package.json"() {
     name = "@pandacss/eslint-plugin";
-    version = "0.2.8";
+    version = "0.2.9";
   }
 });
 
@@ -9115,7 +9115,7 @@ var init_no_margin_properties = __esm({
 });
 
 // src/utils/physical-properties.ts
-var physicalProperties;
+var physicalProperties, physicalPropertyValues;
 var init_physical_properties = __esm({
   "src/utils/physical-properties.ts"() {
     "use strict";
@@ -9154,11 +9154,18 @@ var init_physical_properties = __esm({
       top: "insetBlockStart",
       bottom: "insetBlockEnd"
     };
+    physicalPropertyValues = {
+      // text-align physical values mapped to logical values
+      textAlign: {
+        left: "start",
+        right: "end"
+      }
+    };
   }
 });
 
 // src/rules/no-physical-properties.ts
-var RULE_NAME11, rule11, no_physical_properties_default;
+var RULE_NAME11, MESSAGES, PropertyCache, extractStringLiteralValue, createPropertyReport, createValueReport, rule11, no_physical_properties_default;
 var init_no_physical_properties = __esm({
   "src/rules/no-physical-properties.ts"() {
     "use strict";
@@ -9168,16 +9175,102 @@ var init_no_physical_properties = __esm({
     init_nodes();
     init_physical_properties();
     RULE_NAME11 = "no-physical-properties";
+    MESSAGES = {
+      physical: "Use logical property instead of {{physical}}. Prefer `{{logical}}`.",
+      physicalValue: "Use logical value instead of {{physical}}. Prefer `{{logical}}`.",
+      replace: "Replace `{{physical}}` with `{{logical}}`."
+    };
+    PropertyCache = class {
+      longhandCache = /* @__PURE__ */ new Map();
+      pandaPropCache = /* @__PURE__ */ new WeakMap();
+      pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+      recipeVariantCache = /* @__PURE__ */ new WeakMap();
+      getLonghand(name2, context) {
+        if (this.longhandCache.has(name2)) {
+          return this.longhandCache.get(name2);
+        }
+        const longhand = resolveLonghand(name2, context) ?? name2;
+        this.longhandCache.set(name2, longhand);
+        return longhand;
+      }
+      isPandaProp(node, context) {
+        if (this.pandaPropCache.has(node)) {
+          return this.pandaPropCache.get(node);
+        }
+        const result = isPandaProp(node, context);
+        this.pandaPropCache.set(node, result);
+        return !!result;
+      }
+      isPandaAttribute(node, context) {
+        if (this.pandaAttributeCache.has(node)) {
+          return this.pandaAttributeCache.get(node);
+        }
+        const result = isPandaAttribute(node, context);
+        this.pandaAttributeCache.set(node, result);
+        return !!result;
+      }
+      isRecipeVariant(node, context) {
+        if (this.recipeVariantCache.has(node)) {
+          return this.recipeVariantCache.get(node);
+        }
+        const result = isRecipeVariant(node, context);
+        this.recipeVariantCache.set(node, result);
+        return !!result;
+      }
+    };
+    extractStringLiteralValue = (valueNode) => {
+      if (isLiteral(valueNode) && typeof valueNode.value === "string") {
+        return valueNode.value;
+      }
+      if (isJSXExpressionContainer(valueNode) && isLiteral(valueNode.expression) && typeof valueNode.expression.value === "string") {
+        return valueNode.expression.value;
+      }
+      return null;
+    };
+    createPropertyReport = (node, longhandName, logical, context) => {
+      const physicalName = `\`${node.name}\`${longhandName !== node.name ? ` (resolved to \`${longhandName}\`)` : ""}`;
+      context.report({
+        node,
+        messageId: "physical",
+        data: { physical: physicalName, logical },
+        suggest: [
+          {
+            messageId: "replace",
+            data: { physical: node.name, logical },
+            fix: (fixer) => fixer.replaceText(node, logical)
+          }
+        ]
+      });
+    };
+    createValueReport = (valueNode, valueText, logical, context) => {
+      context.report({
+        node: valueNode,
+        messageId: "physicalValue",
+        data: { physical: `"${valueText}"`, logical: `"${logical}"` },
+        suggest: [
+          {
+            messageId: "replace",
+            data: { physical: `"${valueText}"`, logical: `"${logical}"` },
+            fix: (fixer) => {
+              if (isLiteral(valueNode)) {
+                return fixer.replaceText(valueNode, `"${logical}"`);
+              }
+              if (isJSXExpressionContainer(valueNode) && isLiteral(valueNode.expression)) {
+                return fixer.replaceText(valueNode.expression, `"${logical}"`);
+              }
+              return null;
+            }
+          }
+        ]
+      });
+    };
     rule11 = createRule({
       name: RULE_NAME11,
       meta: {
         docs: {
           description: "Encourage the use of logical properties over physical properties to foster a responsive and adaptable user interface."
         },
-        messages: {
-          physical: "Use logical property instead of {{physical}}. Prefer `{{logical}}`.",
-          replace: "Replace `{{physical}}` with `{{logical}}`."
-        },
+        messages: MESSAGES,
         type: "suggestion",
         hasSuggestions: true,
         schema: [
@@ -9197,87 +9290,44 @@ var init_no_physical_properties = __esm({
           }
         ]
       },
-      defaultOptions: [
-        {
-          whitelist: []
-        }
-      ],
+      defaultOptions: [{ whitelist: [] }],
       create(context) {
         const whitelist = context.options[0]?.whitelist ?? [];
-        const longhandCache = /* @__PURE__ */ new Map();
-        const pandaPropCache = /* @__PURE__ */ new WeakMap();
-        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
-        const recipeVariantCache = /* @__PURE__ */ new WeakMap();
-        const getLonghand = (name2) => {
-          if (longhandCache.has(name2)) {
-            return longhandCache.get(name2);
-          }
-          const longhand = resolveLonghand(name2, context) ?? name2;
-          longhandCache.set(name2, longhand);
-          return longhand;
-        };
-        const isCachedPandaProp = (node) => {
-          if (pandaPropCache.has(node)) {
-            return pandaPropCache.get(node);
-          }
-          const result = isPandaProp(node, context);
-          pandaPropCache.set(node, result);
-          return !!result;
-        };
-        const isCachedPandaAttribute = (node) => {
-          if (pandaAttributeCache.has(node)) {
-            return pandaAttributeCache.get(node);
-          }
-          const result = isPandaAttribute(node, context);
-          pandaAttributeCache.set(node, result);
-          return !!result;
-        };
-        const isCachedRecipeVariant = (node) => {
-          if (recipeVariantCache.has(node)) {
-            return recipeVariantCache.get(node);
-          }
-          const result = isRecipeVariant(node, context);
-          recipeVariantCache.set(node, result);
-          return !!result;
-        };
-        const sendReport = (node) => {
+        const cache = new PropertyCache();
+        const checkPropertyName = (node) => {
           if (whitelist.includes(node.name)) return;
-          const longhandName = getLonghand(node.name);
+          const longhandName = cache.getLonghand(node.name, context);
           if (!(longhandName in physicalProperties)) return;
           const logical = physicalProperties[longhandName];
-          const physicalName = `\`${node.name}\`${longhandName !== node.name ? ` (resolved to \`${longhandName}\`)` : ""}`;
-          context.report({
-            node,
-            messageId: "physical",
-            data: {
-              physical: physicalName,
-              logical
-            },
-            suggest: [
-              {
-                messageId: "replace",
-                data: {
-                  physical: node.name,
-                  logical
-                },
-                fix: (fixer) => {
-                  return fixer.replaceText(node, logical);
-                }
-              }
-            ]
-          });
+          createPropertyReport(node, longhandName, logical, context);
+        };
+        const checkPropertyValue = (keyNode, valueNode) => {
+          const propName = keyNode.name;
+          if (!(propName in physicalPropertyValues)) return false;
+          const valueText = extractStringLiteralValue(valueNode);
+          if (valueText === null) return false;
+          const valueMap = physicalPropertyValues[propName];
+          if (!valueMap[valueText]) return false;
+          createValueReport(valueNode, valueText, valueMap[valueText], context);
+          return true;
         };
         return {
           JSXAttribute(node) {
             if (!isJSXIdentifier(node.name)) return;
-            if (!isCachedPandaProp(node)) return;
-            sendReport(node.name);
+            if (!cache.isPandaProp(node, context)) return;
+            checkPropertyName(node.name);
+            if (node.value) {
+              checkPropertyValue(node.name, node.value);
+            }
           },
           Property(node) {
             if (!isIdentifier(node.key)) return;
-            if (!isCachedPandaAttribute(node)) return;
-            if (isCachedRecipeVariant(node)) return;
-            sendReport(node.key);
+            if (!cache.isPandaAttribute(node, context)) return;
+            if (cache.isRecipeVariant(node, context)) return;
+            checkPropertyName(node.key);
+            if (node.value) {
+              checkPropertyValue(node.key, node.value);
+            }
           }
         };
       }

package/package.json

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