@esphome/compose-eslint 0.1.2 → 0.3.0

package/dist/index.mjs

@@ -1,12 +1,239 @@
 // src/index.ts
 import tseslint from "typescript-eslint";
+
+// src/rules/jsx-children-intents.ts
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+// src/utils/intent-resolver.ts
+import { INTRINSIC_INTENT_REGISTRY } from "@esphome/compose";
+function getJSXTagName(node) {
+  if (node.name.type === "JSXIdentifier") {
+    return node.name.name;
+  }
+  if (node.name.type === "JSXMemberExpression") {
+    return flattenMemberExpression(node.name);
+  }
+  return `${node.name.namespace.name}:${node.name.name.name}`;
+}
+function flattenMemberExpression(node) {
+  if (node.object.type === "JSXMemberExpression") {
+    return `${flattenMemberExpression(node.object)}.${node.property.name}`;
+  }
+  return `${node.object.name}.${node.property.name}`;
+}
+function isIntrinsicElement(tagName) {
+  const firstChar = tagName[0];
+  return firstChar === firstChar.toLowerCase() && firstChar !== firstChar.toUpperCase();
+}
+function resolveIntrinsicIntents(tagName) {
+  const meta = INTRINSIC_INTENT_REGISTRY[tagName];
+  if (!meta) return void 0;
+  return {
+    intents: meta.intents,
+    allowedChildIntents: meta.allowedChildIntents,
+    context: meta.context,
+    contextTransparent: meta.contextTransparent ?? false
+  };
+}
+function resolveElementIntents(openingElement, componentIntentCache) {
+  const tagName = getJSXTagName(openingElement);
+  if (isIntrinsicElement(tagName)) {
+    return resolveIntrinsicIntents(tagName);
+  }
+  const cached = componentIntentCache.get(tagName);
+  if (cached !== void 0) {
+    return cached ?? void 0;
+  }
+  return void 0;
+}
+function findConstrainingParent(ancestors, componentIntentCache) {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const ancestor = ancestors[i];
+    if (ancestor.type !== "JSXElement") continue;
+    const resolved = resolveElementIntents(ancestor.openingElement, componentIntentCache);
+    if (!resolved) continue;
+    if (resolved.allowedChildIntents === void 0) continue;
+    return { resolved, element: ancestor };
+  }
+  return void 0;
+}
+function findNearestContext(ancestors, componentIntentCache) {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const ancestor = ancestors[i];
+    if (ancestor.type !== "JSXElement") continue;
+    const resolved = resolveElementIntents(ancestor.openingElement, componentIntentCache);
+    if (!resolved) continue;
+    if (resolved.context && resolved.context.length > 0) {
+      return { context: resolved.context, element: ancestor };
+    }
+  }
+  return void 0;
+}
+
+// src/rules/jsx-children-intents.ts
+var createRule = ESLintUtils.RuleCreator(
+  (name) => `https://github.com/xmlguy74/espcompose/blob/main/docs/rules/${name}.md`
+);
+var jsx_children_intents_default = createRule({
+  name: "jsx-children-intents",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce valid parent-child component nesting based on declared intents"
+    },
+    messages: {
+      invalidChildIntent: '"<{{ childTag }}>" with intents [{{ childIntents }}] cannot be a child of "<{{ parentTag }}>". Parent accepts: [{{ allowedIntents }}].',
+      noIntentsOnChild: '"<{{ childTag }}>" has no declared intents but its parent "<{{ parentTag }}>" requires children with intents: [{{ allowedIntents }}].',
+      missingContextIntent: '"<{{ childTag }}>" with intents [{{ childIntents }}] is missing required context [{{ requiredContext }}] established by "<{{ contextTag }}>".',
+      noIntentsForContext: '"<{{ childTag }}>" has no declared intents but is inside a context [{{ requiredContext }}] established by "<{{ contextTag }}>".'
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const componentIntentCache = /* @__PURE__ */ new Map();
+    return {
+      JSXElement(node) {
+        const { children } = node;
+        for (const child of children) {
+          if (child.type !== "JSXElement") continue;
+          const childOpeningElement = child.openingElement;
+          const childTagName = getJSXTagName(childOpeningElement);
+          const childResolved = resolveElementIntents(childOpeningElement, componentIntentCache);
+          const ancestors = context.sourceCode.getAncestors(node);
+          const fullAncestors = [...ancestors, node];
+          const constrainingParent = findConstrainingParent(fullAncestors, componentIntentCache);
+          if (constrainingParent) {
+            const { resolved: parentResolved, element: parentElement } = constrainingParent;
+            const parentTagName = getJSXTagName(parentElement.openingElement);
+            const allowed = parentResolved.allowedChildIntents;
+            if (!childResolved) {
+              if (isIntrinsicElement(childTagName)) {
+                context.report({
+                  node: childOpeningElement,
+                  messageId: "noIntentsOnChild",
+                  data: {
+                    childTag: childTagName,
+                    parentTag: parentTagName,
+                    allowedIntents: allowed.join(", ")
+                  }
+                });
+              }
+            } else {
+              const hasMatch = childResolved.intents.some((intent) => allowed.includes(intent));
+              if (!hasMatch) {
+                context.report({
+                  node: childOpeningElement,
+                  messageId: "invalidChildIntent",
+                  data: {
+                    childTag: childTagName,
+                    childIntents: childResolved.intents.join(", "),
+                    parentTag: parentTagName,
+                    allowedIntents: allowed.join(", ")
+                  }
+                });
+              }
+            }
+          }
+          if (childResolved?.contextTransparent) continue;
+          const nearestContext = findNearestContext(fullAncestors, componentIntentCache);
+          if (nearestContext) {
+            const { context: requiredContext, element: contextElement } = nearestContext;
+            const contextTagName = getJSXTagName(contextElement.openingElement);
+            if (!childResolved) {
+              if (isIntrinsicElement(childTagName)) {
+                context.report({
+                  node: childOpeningElement,
+                  messageId: "noIntentsForContext",
+                  data: {
+                    childTag: childTagName,
+                    requiredContext: requiredContext.join(", "),
+                    contextTag: contextTagName
+                  }
+                });
+              }
+            } else {
+              const missingContext = requiredContext.filter(
+                (ctx) => !childResolved.intents.includes(ctx)
+              );
+              if (missingContext.length > 0) {
+                context.report({
+                  node: childOpeningElement,
+                  messageId: "missingContextIntent",
+                  data: {
+                    childTag: childTagName,
+                    childIntents: childResolved.intents.join(", "),
+                    requiredContext: missingContext.join(", "),
+                    contextTag: contextTagName
+                  }
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/no-nested-functions.ts
+import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
+var createRule2 = ESLintUtils2.RuleCreator(
+  (name) => `https://github.com/xmlguy74/espcompose/blob/main/docs/rules/${name}.md`
+);
+var no_nested_functions_default = createRule2({
+  name: "no-nested-functions",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow function declarations nested inside other functions. Only top-level function declarations are compiled into ESPHome scripts."
+    },
+    messages: {
+      nestedFunction: `Function declaration "{{ name }}" is nested inside another function. Move it to the module's top level so the compiler can transform it into an ESPHome script, or use an inline arrow function in the trigger prop.`
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    let functionDepth = 0;
+    function enterFunction() {
+      functionDepth++;
+    }
+    function exitFunction() {
+      functionDepth--;
+    }
+    return {
+      // Track all function-like boundaries (declarations, expressions, arrows)
+      FunctionDeclaration(node) {
+        if (functionDepth > 0 && node.id) {
+          context.report({
+            node,
+            messageId: "nestedFunction",
+            data: { name: node.id.name }
+          });
+        }
+        enterFunction();
+      },
+      "FunctionDeclaration:exit": exitFunction,
+      FunctionExpression: enterFunction,
+      "FunctionExpression:exit": exitFunction,
+      ArrowFunctionExpression: enterFunction,
+      "ArrowFunctionExpression:exit": exitFunction
+    };
+  }
+});
+
+// src/index.ts
 var plugin = {
   meta: {
     name: "@esphome/compose-eslint",
     version: "0.0.1"
   },
   rules: {
-    // Custom rules will be added here
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    "jsx-children-intents": jsx_children_intents_default,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    "no-nested-functions": no_nested_functions_default
   }
 };
 var recommended = [
@@ -29,7 +256,12 @@ var recommended = [
       // at compile time.
       "@typescript-eslint/no-unused-vars": ["warn", {
         varsIgnorePattern: "^ESPCompose$"
-      }]
+      }],
+      // Enforce valid parent-child component nesting based on declared intents.
+      "@esphome/compose-eslint/jsx-children-intents": "error",
+      // Prevent nested function declarations — only top-level functions become
+      // ESPHome scripts; nested ones are silently ignored by the compiler.
+      "@esphome/compose-eslint/no-nested-functions": "error"
     }
   },
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esphome/compose-eslint",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "description": "ESLint plugin with custom rules for ESPHome Compose projects",
   "main": "dist/index.mjs",
   "module": "dist/index.mjs",
@@ -34,20 +34,24 @@
     "access": "public"
   },
   "dependencies": {
-    "typescript-eslint": "^8.0.0"
+    "@typescript-eslint/utils": "^8.0.0",
+    "typescript-eslint": "^8.57.2",
+    "@esphome/compose": "0.3.0"
   },
   "peerDependencies": {
     "eslint": ">=9.0.0"
   },
   "devDependencies": {
-    "eslint": "^9.0.0",
+    "@typescript-eslint/rule-tester": "^8.0.0",
+    "eslint": "^9.39.4",
     "tsup": "^8.0.0",
-    "typescript": "^5.4.0"
+    "typescript": "^5.9.3",
+    "vitest": "^2.0.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts",
     "clean": "rimraf dist",
     "lint": "eslint src",
-    "test": "echo \"No tests yet\""
+    "test": "vitest run"
   }
 }