@wsxjs/eslint-plugin-wsx 0.0.21 → 0.0.23

package/dist/index.js

@@ -669,6 +669,118 @@ var noDuplicateKeys = {
   }
 };
 
+// src/rules/lifecycle-must-call-super.ts
+var lifecycleMustCallSuper = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce that lifecycle methods (onConnected, onDisconnected, onRendered) call super",
+      category: "Possible Errors",
+      recommended: true
+    },
+    messages: {
+      mustCallSuper: "Lifecycle method '{{methodName}}' must call 'super.{{methodName}}()' to ensure proper initialization."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const lifecycleMethods = /* @__PURE__ */ new Set(["onConnected", "onDisconnected", "onRendered"]);
+    function checkForSuperCall(node, methodName, visited = /* @__PURE__ */ new WeakSet()) {
+      if (visited.has(node)) {
+        return false;
+      }
+      visited.add(node);
+      if (node.type === "CallExpression") {
+        const callee = node.callee;
+        if (callee.type === "MemberExpression" && callee.object.type === "Super" && callee.property.type === "Identifier" && callee.property.name === methodName) {
+          return true;
+        }
+      }
+      const nodeAny = node;
+      const keysToCheck = [
+        "body",
+        "consequent",
+        "alternate",
+        "block",
+        "handler",
+        "finalizer",
+        "argument",
+        "callee",
+        "expression",
+        "declarations",
+        "init",
+        "test",
+        "update",
+        "cases",
+        "discriminant",
+        "object",
+        "property",
+        "elements",
+        "properties",
+        "value",
+        "key"
+      ];
+      for (const key of keysToCheck) {
+        const child = nodeAny[key];
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item && typeof item === "object" && "type" in item) {
+              if (checkForSuperCall(
+                item,
+                methodName,
+                visited
+              )) {
+                return true;
+              }
+            }
+          }
+        } else if (child && typeof child === "object" && "type" in child) {
+          if (checkForSuperCall(child, methodName, visited)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    return {
+      MethodDefinition(node) {
+        if (node.accessibility !== "protected") {
+          return;
+        }
+        const methodName = node.key.type === "Identifier" ? node.key.name : null;
+        if (!methodName || !lifecycleMethods.has(methodName)) {
+          return;
+        }
+        const methodValue = node.value;
+        if (!methodValue || methodValue.type !== "FunctionExpression") {
+          return;
+        }
+        const body = methodValue.body;
+        if (!body || body.type !== "BlockStatement") {
+          return;
+        }
+        let hasSuperCall = false;
+        for (const statement of body.body) {
+          if (checkForSuperCall(statement, methodName)) {
+            hasSuperCall = true;
+            break;
+          }
+        }
+        if (!hasSuperCall) {
+          context.report({
+            node: node.key,
+            messageId: "mustCallSuper",
+            data: {
+              methodName
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
 // src/configs/recommended.ts
 var recommendedConfig = {
   parser: "@typescript-eslint/parser",
@@ -695,6 +807,7 @@ var recommendedConfig = {
     "wsx/no-inner-html": "error",
     "wsx/i18n-after-autoregister": "error",
     "wsx/no-duplicate-keys": "error",
+    "wsx/lifecycle-must-call-super": "error",
     // TypeScript 规则（推荐）
     "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
     "@typescript-eslint/no-explicit-any": "warn",
@@ -865,7 +978,8 @@ var plugin = {
     "no-null-render": noNullRender,
     "no-inner-html": noInnerHTML,
     "i18n-after-autoregister": i18nAfterAutoRegister,
-    "no-duplicate-keys": noDuplicateKeys
+    "no-duplicate-keys": noDuplicateKeys,
+    "lifecycle-must-call-super": lifecycleMustCallSuper
   },
   // 配置预设
   configs: {

package/dist/index.mjs

@@ -640,6 +640,118 @@ var noDuplicateKeys = {
   }
 };
 
+// src/rules/lifecycle-must-call-super.ts
+var lifecycleMustCallSuper = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce that lifecycle methods (onConnected, onDisconnected, onRendered) call super",
+      category: "Possible Errors",
+      recommended: true
+    },
+    messages: {
+      mustCallSuper: "Lifecycle method '{{methodName}}' must call 'super.{{methodName}}()' to ensure proper initialization."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const lifecycleMethods = /* @__PURE__ */ new Set(["onConnected", "onDisconnected", "onRendered"]);
+    function checkForSuperCall(node, methodName, visited = /* @__PURE__ */ new WeakSet()) {
+      if (visited.has(node)) {
+        return false;
+      }
+      visited.add(node);
+      if (node.type === "CallExpression") {
+        const callee = node.callee;
+        if (callee.type === "MemberExpression" && callee.object.type === "Super" && callee.property.type === "Identifier" && callee.property.name === methodName) {
+          return true;
+        }
+      }
+      const nodeAny = node;
+      const keysToCheck = [
+        "body",
+        "consequent",
+        "alternate",
+        "block",
+        "handler",
+        "finalizer",
+        "argument",
+        "callee",
+        "expression",
+        "declarations",
+        "init",
+        "test",
+        "update",
+        "cases",
+        "discriminant",
+        "object",
+        "property",
+        "elements",
+        "properties",
+        "value",
+        "key"
+      ];
+      for (const key of keysToCheck) {
+        const child = nodeAny[key];
+        if (Array.isArray(child)) {
+          for (const item of child) {
+            if (item && typeof item === "object" && "type" in item) {
+              if (checkForSuperCall(
+                item,
+                methodName,
+                visited
+              )) {
+                return true;
+              }
+            }
+          }
+        } else if (child && typeof child === "object" && "type" in child) {
+          if (checkForSuperCall(child, methodName, visited)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+    return {
+      MethodDefinition(node) {
+        if (node.accessibility !== "protected") {
+          return;
+        }
+        const methodName = node.key.type === "Identifier" ? node.key.name : null;
+        if (!methodName || !lifecycleMethods.has(methodName)) {
+          return;
+        }
+        const methodValue = node.value;
+        if (!methodValue || methodValue.type !== "FunctionExpression") {
+          return;
+        }
+        const body = methodValue.body;
+        if (!body || body.type !== "BlockStatement") {
+          return;
+        }
+        let hasSuperCall = false;
+        for (const statement of body.body) {
+          if (checkForSuperCall(statement, methodName)) {
+            hasSuperCall = true;
+            break;
+          }
+        }
+        if (!hasSuperCall) {
+          context.report({
+            node: node.key,
+            messageId: "mustCallSuper",
+            data: {
+              methodName
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
 // src/configs/recommended.ts
 var recommendedConfig = {
   parser: "@typescript-eslint/parser",
@@ -666,6 +778,7 @@ var recommendedConfig = {
     "wsx/no-inner-html": "error",
     "wsx/i18n-after-autoregister": "error",
     "wsx/no-duplicate-keys": "error",
+    "wsx/lifecycle-must-call-super": "error",
     // TypeScript 规则（推荐）
     "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
     "@typescript-eslint/no-explicit-any": "warn",
@@ -836,7 +949,8 @@ var plugin = {
     "no-null-render": noNullRender,
     "no-inner-html": noInnerHTML,
     "i18n-after-autoregister": i18nAfterAutoRegister,
-    "no-duplicate-keys": noDuplicateKeys
+    "no-duplicate-keys": noDuplicateKeys,
+    "lifecycle-must-call-super": lifecycleMustCallSuper
   },
   // 配置预设
   configs: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wsxjs/eslint-plugin-wsx",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "ESLint plugin for WSXJS",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -25,7 +25,7 @@
     "web-components"
   ],
   "dependencies": {
-    "@wsxjs/wsx-core": "0.0.21"
+    "@wsxjs/wsx-core": "0.0.23"
   },
   "devDependencies": {
     "tsup": "^8.0.0",

package/src/configs/recommended.ts

@@ -30,6 +30,7 @@ export const recommendedConfig: WSXConfig = {
         "wsx/no-inner-html": "error",
         "wsx/i18n-after-autoregister": "error",
         "wsx/no-duplicate-keys": "error",
+        "wsx/lifecycle-must-call-super": "error",
 
         // TypeScript 规则（推荐）
         "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],

package/src/index.ts

@@ -14,6 +14,7 @@ import { noNullRender } from "./rules/no-null-render";
 import { noInnerHTML } from "./rules/no-inner-html";
 import { i18nAfterAutoRegister } from "./rules/i18n-after-autoregister";
 import { noDuplicateKeys } from "./rules/no-duplicate-keys";
+import { lifecycleMustCallSuper } from "./rules/lifecycle-must-call-super";
 import { recommendedConfig } from "./configs/recommended";
 import { createFlatConfig } from "./configs/flat";
 import { WSXPlugin } from "./types";
@@ -36,6 +37,7 @@ const plugin: WSXPlugin = {
         "no-inner-html": noInnerHTML,
         "i18n-after-autoregister": i18nAfterAutoRegister,
         "no-duplicate-keys": noDuplicateKeys,
+        "lifecycle-must-call-super": lifecycleMustCallSuper,
     },
 
     // 配置预设

package/src/rules/lifecycle-must-call-super.ts

@@ -0,0 +1,155 @@
+/**
+ * ESLint 规则：lifecycle-must-call-super
+ *
+ * 确保生命周期方法（onConnected, onDisconnected, onRendered）调用 super
+ * 这些方法在 BaseComponent 中是可选的，但如果被重写，应该调用 super
+ * 以确保正确的初始化和清理
+ */
+
+import { Rule } from "eslint";
+import { WSXRuleModule } from "../types";
+
+export const lifecycleMustCallSuper: WSXRuleModule = {
+    meta: {
+        type: "problem",
+        docs: {
+            description:
+                "Enforce that lifecycle methods (onConnected, onDisconnected, onRendered) call super",
+            category: "Possible Errors",
+            recommended: true,
+        },
+        messages: {
+            mustCallSuper:
+                "Lifecycle method '{{methodName}}' must call 'super.{{methodName}}()' to ensure proper initialization.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context: Rule.RuleContext) {
+        const lifecycleMethods = new Set(["onConnected", "onDisconnected", "onRendered"]);
+
+        /**
+         * 递归检查节点中是否有 super.methodName() 调用
+         * 使用 visited 集合避免重复检查同一个节点（防止循环引用导致的无限递归）
+         */
+        function checkForSuperCall(
+            node: import("estree").Node,
+            methodName: string,
+            visited = new WeakSet<import("estree").Node>()
+        ): boolean {
+            // 避免重复检查同一个节点
+            if (visited.has(node)) {
+                return false;
+            }
+            visited.add(node);
+
+            if (node.type === "CallExpression") {
+                const callee = node.callee;
+                if (
+                    callee.type === "MemberExpression" &&
+                    callee.object.type === "Super" &&
+                    callee.property.type === "Identifier" &&
+                    callee.property.name === methodName
+                ) {
+                    return true;
+                }
+            }
+
+            // 递归检查子节点（只检查常见的子节点类型，避免遍历所有属性）
+            const nodeAny = node as unknown as Record<string, unknown>;
+            const keysToCheck = [
+                "body",
+                "consequent",
+                "alternate",
+                "block",
+                "handler",
+                "finalizer",
+                "argument",
+                "callee",
+                "expression",
+                "declarations",
+                "init",
+                "test",
+                "update",
+                "cases",
+                "discriminant",
+                "object",
+                "property",
+                "elements",
+                "properties",
+                "value",
+                "key",
+            ];
+
+            for (const key of keysToCheck) {
+                const child = nodeAny[key];
+                if (Array.isArray(child)) {
+                    for (const item of child) {
+                        if (item && typeof item === "object" && "type" in item) {
+                            if (
+                                checkForSuperCall(
+                                    item as import("estree").Node,
+                                    methodName,
+                                    visited
+                                )
+                            ) {
+                                return true;
+                            }
+                        }
+                    }
+                } else if (child && typeof child === "object" && "type" in child) {
+                    if (checkForSuperCall(child as import("estree").Node, methodName, visited)) {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        return {
+            MethodDefinition(node: import("estree").MethodDefinition) {
+                // 只检查 protected 方法
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if ((node as any).accessibility !== "protected") {
+                    return;
+                }
+
+                const methodName = node.key.type === "Identifier" ? node.key.name : null;
+                if (!methodName || !lifecycleMethods.has(methodName)) {
+                    return;
+                }
+
+                // 检查方法体中是否调用了 super
+                const methodValue = node.value;
+                if (!methodValue || methodValue.type !== "FunctionExpression") {
+                    return;
+                }
+
+                const body = methodValue.body;
+                if (!body || body.type !== "BlockStatement") {
+                    return;
+                }
+
+                // 检查是否有 super 调用
+                let hasSuperCall = false;
+                for (const statement of body.body) {
+                    if (checkForSuperCall(statement, methodName)) {
+                        hasSuperCall = true;
+                        break;
+                    }
+                }
+
+                if (!hasSuperCall) {
+                    context.report({
+                        node: node.key,
+                        messageId: "mustCallSuper",
+                        data: {
+                            methodName,
+                        },
+                    });
+                }
+            },
+        };
+    },
+};