@wsxjs/eslint-plugin-wsx 0.0.5

package/src/rules/no-react-imports.ts

@@ -0,0 +1,55 @@
+/**
+ * ESLint 规则：no-react-imports
+ *
+ * 禁止在 WSX 文件中导入 React 相关模块
+ */
+
+import { Rule } from "eslint";
+import { WSXRuleModule } from "../types";
+
+export const noReactImports: WSXRuleModule = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "disallow React imports in WSX files",
+            category: "Best Practices",
+            recommended: true,
+        },
+        fixable: "code",
+        messages: {
+            noReactImport: "Do not import React in WSX files. Use 'h' function instead",
+        },
+        schema: [], // 无配置选项
+    },
+    create(context: Rule.RuleContext) {
+        const reactModules = [
+            "react",
+            "react-dom",
+            "react-dom/client",
+            "react-hooks",
+            "@types/react",
+            "@types/react-dom",
+        ];
+
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ImportDeclaration(node: any) {
+                const source = node.source.value;
+                if (
+                    typeof source === "string" &&
+                    reactModules.some(
+                        (module) => source === module || source.startsWith(module + "/")
+                    )
+                ) {
+                    context.report({
+                        node,
+                        messageId: "noReactImport",
+                        fix(fixer) {
+                            return fixer.remove(node);
+                        },
+                    });
+                }
+            },
+        };
+    },
+};

package/src/rules/render-method-required.ts

@@ -0,0 +1,55 @@
+/**
+ * ESLint 规则：render-method-required
+ *
+ * 确保继承 WebComponent 的类实现 render() 方法
+ */
+
+import { Rule } from "eslint";
+import { WSXRuleModule } from "../types";
+
+export const renderMethodRequired: WSXRuleModule = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "require WSX components to implement render method",
+            category: "Possible Errors",
+            recommended: true,
+        },
+        messages: {
+            missingRenderMethod:
+                "WSX component '{{componentName}}' must implement a render() method",
+        },
+        schema: [], // 无配置选项
+    },
+    create(context: Rule.RuleContext) {
+        return {
+            ClassDeclaration(node: import("estree").ClassDeclaration) {
+                // 检查是否继承自 WebComponent
+                const isWebComponent =
+                    node.superClass &&
+                    node.superClass.type === "Identifier" &&
+                    node.superClass.name === "WebComponent";
+
+                if (!isWebComponent) return;
+
+                const componentName = node.id?.name || "Unknown";
+                const hasRenderMethod = node.body.body.some(
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (member: any) =>
+                        member.type === "MethodDefinition" &&
+                        member.key.type === "Identifier" &&
+                        member.key.name === "render" &&
+                        member.value.body !== null
+                );
+
+                if (!hasRenderMethod) {
+                    context.report({
+                        node,
+                        messageId: "missingRenderMethod",
+                        data: { componentName },
+                    });
+                }
+            },
+        };
+    },
+};

package/src/rules/web-component-naming.ts

@@ -0,0 +1,97 @@
+/**
+ * ESLint 规则：web-component-naming
+ *
+ * 强制 Web Component 命名规范（必须包含连字符）
+ */
+
+import { Rule } from "eslint";
+import { WSXRuleModule } from "../types";
+
+export const webComponentNaming: WSXRuleModule = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "enforce Web Component naming conventions",
+            category: "Stylistic Issues",
+            recommended: true,
+        },
+        messages: {
+            tagNameNeedsHyphen:
+                "Web Component tag name '{{tagName}}' must contain at least one hyphen",
+            tagNameReserved: "Tag name '{{tagName}}' conflicts with HTML standard elements",
+        },
+        schema: [], // 无配置选项
+    },
+    create(context: Rule.RuleContext) {
+        const htmlElements = new Set([
+            "div",
+            "span",
+            "p",
+            "a",
+            "button",
+            "input",
+            "form",
+            "img",
+            "h1",
+            "h2",
+            "h3",
+            "ul",
+            "li",
+            "table",
+            "tr",
+            "td",
+            "th",
+            "section",
+            "article",
+            "header",
+            "footer",
+        ]);
+
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            Decorator(node: any) {
+                if (
+                    node.expression.type === "CallExpression" &&
+                    node.expression.callee.type === "Identifier" &&
+                    node.expression.callee.name === "autoRegister"
+                ) {
+                    const args = node.expression.arguments;
+                    if (args.length > 0 && args[0].type === "ObjectExpression") {
+                        const tagNameProp = args[0].properties.find(
+                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                            (prop: any) =>
+                                prop.type === "Property" &&
+                                prop.key &&
+                                prop.key.type === "Identifier" &&
+                                prop.key.name === "tagName"
+                        );
+
+                        if (
+                            tagNameProp &&
+                            tagNameProp.type === "Property" &&
+                            tagNameProp.value.type === "Literal"
+                        ) {
+                            const tagName = tagNameProp.value.value;
+
+                            if (typeof tagName === "string") {
+                                if (htmlElements.has(tagName)) {
+                                    context.report({
+                                        node: tagNameProp.value,
+                                        messageId: "tagNameReserved",
+                                        data: { tagName },
+                                    });
+                                } else if (!tagName.includes("-")) {
+                                    context.report({
+                                        node: tagNameProp.value,
+                                        messageId: "tagNameNeedsHyphen",
+                                        data: { tagName },
+                                    });
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+};

package/src/types.ts

@@ -0,0 +1,44 @@
+/**
+ * TypeScript 类型定义 - WSX ESLint 插件
+ */
+
+import { Rule } from "eslint";
+
+export interface WSXRuleContext extends Rule.RuleContext {
+    // WSX 特定的上下文扩展
+    report: (descriptor: Rule.ReportDescriptor) => void;
+}
+
+export interface WSXRuleModule extends Rule.RuleModule {
+    // WSX 特定的规则模块扩展
+    create: (context: WSXRuleContext) => Rule.RuleListener;
+}
+
+export interface WSXConfig {
+    parser?: string;
+    parserOptions?: {
+        ecmaVersion?: string | number;
+        sourceType?: "script" | "module";
+        ecmaFeatures?: {
+            jsx?: boolean;
+        };
+        jsxPragma?: string;
+        jsxFragmentName?: string;
+    };
+    plugins?: string[];
+    rules?: Record<string, unknown>;
+    globals?: Record<string, "readonly" | "writable">;
+    settings?: Record<string, unknown>;
+}
+
+export interface WSXPluginMeta {
+    name: string;
+    version: string;
+}
+
+export interface WSXPlugin {
+    meta: WSXPluginMeta;
+    rules: Record<string, WSXRuleModule>;
+    configs: Record<string, WSXConfig>;
+    [key: string]: unknown;
+}