@zhangyu1818/oxlint-config 1.0.0

package/dist/react-agent-rules.d.ts

@@ -0,0 +1,44 @@
+interface CallExpressionNode {
+    arguments: unknown[];
+    callee: unknown;
+    type: 'CallExpression';
+}
+interface RuleContext {
+    report(descriptor: {
+        message: string;
+        node: unknown;
+    }): void;
+}
+declare const plugin: {
+    meta: {
+        name: string;
+    };
+    rules: {
+        'effect-empty-deps-only': {
+            meta: {
+                schema: never[];
+            };
+            create(context: RuleContext): {
+                CallExpression(node: CallExpressionNode): void;
+            };
+        };
+        'no-forward-ref': {
+            meta: {
+                schema: never[];
+            };
+            create(context: RuleContext): {
+                CallExpression(node: CallExpressionNode): void;
+            };
+        };
+        'no-manual-memoization': {
+            meta: {
+                schema: never[];
+            };
+            create(context: RuleContext): {
+                CallExpression(node: CallExpressionNode): void;
+            };
+        };
+    };
+};
+
+export { plugin as default };

package/dist/react-agent-rules.js

@@ -0,0 +1,94 @@
+// src/react-agent-rules.ts
+var NO_MANUAL_MEMOIZATION_MESSAGE = "React Compiler automatically optimizes components and values, so manual memoization is not needed.";
+var NO_FORWARD_REF_MESSAGE = "Starting in React 19, ref is a prop, so forwardRef is no longer needed.";
+var EFFECT_EMPTY_DEPS_ONLY_MESSAGE = "Effects here must use an empty dependency array. Use them only for mount and unmount logic. For event-driven logic, use useEffectEvent inside the effect. Do not use effects as a watch mechanism.";
+var manualMemoizationNames = /* @__PURE__ */ new Set(["memo", "useMemo", "useCallback"]);
+var effectNames = /* @__PURE__ */ new Set(["useEffect", "useLayoutEffect"]);
+var forwardRefNames = /* @__PURE__ */ new Set(["forwardRef"]);
+function isRecord(node) {
+  return typeof node === "object" && node !== null;
+}
+function isIdentifier(node, name) {
+  return isRecord(node) && node.type === "Identifier" && node.name === name;
+}
+function isNamedIdentifier(node, names) {
+  return isRecord(node) && node.type === "Identifier" && typeof node.name === "string" && names.has(node.name);
+}
+function isMemberExpression(node) {
+  return isRecord(node) && node.type === "MemberExpression" && typeof node.computed === "boolean" && "object" in node && "property" in node;
+}
+function isReactMember(node, names) {
+  return isMemberExpression(node) && !node.computed && isIdentifier(node.object, "React") && isNamedIdentifier(node.property, names);
+}
+function isEmptyDependencyArray(node) {
+  return isRecord(node) && node.type === "ArrayExpression" && Array.isArray(node.elements) && node.elements.length === 0;
+}
+var noManualMemoizationRule = {
+  meta: {
+    schema: []
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (isNamedIdentifier(node.callee, manualMemoizationNames) || isReactMember(node.callee, manualMemoizationNames)) {
+          context.report({
+            message: NO_MANUAL_MEMOIZATION_MESSAGE,
+            node
+          });
+        }
+      }
+    };
+  }
+};
+var noForwardRefRule = {
+  meta: {
+    schema: []
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (isNamedIdentifier(node.callee, forwardRefNames) || isReactMember(node.callee, forwardRefNames)) {
+          context.report({
+            message: NO_FORWARD_REF_MESSAGE,
+            node
+          });
+        }
+      }
+    };
+  }
+};
+var effectEmptyDepsOnlyRule = {
+  meta: {
+    schema: []
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isNamedIdentifier(node.callee, effectNames) && !isReactMember(node.callee, effectNames)) {
+          return;
+        }
+        const dependencyArray = node.arguments[1];
+        if (!isEmptyDependencyArray(dependencyArray)) {
+          context.report({
+            message: EFFECT_EMPTY_DEPS_ONLY_MESSAGE,
+            node
+          });
+        }
+      }
+    };
+  }
+};
+var plugin = {
+  meta: {
+    name: "react-agent-rules"
+  },
+  rules: {
+    "effect-empty-deps-only": effectEmptyDepsOnlyRule,
+    "no-forward-ref": noForwardRefRule,
+    "no-manual-memoization": noManualMemoizationRule
+  }
+};
+var react_agent_rules_default = plugin;
+export {
+  react_agent_rules_default as default
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@zhangyu1818/oxlint-config",
+  "version": "1.0.0",
+  "description": "Native Oxlint and Oxfmt config preset package",
+  "keywords": [
+    "oxc",
+    "oxfmt-config",
+    "oxlint-config"
+  ],
+  "homepage": "https://github.com/zhangyu1818/oxlint-config",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zhangyu1818/oxlint-config.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "format": "oxfmt -c oxfmt.config.ts .",
+    "format:check": "oxfmt --check -c oxfmt.config.ts .",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "tsc:check": "tsc"
+  },
+  "dependencies": {
+    "local-pkg": "^1.1.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "oxfmt": "^0.45.0",
+    "oxlint": "^1.60.0",
+    "oxlint-tsgolint": "^0.21.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.0"
+  },
+  "peerDependencies": {
+    "oxfmt": "^0.45.0",
+    "oxlint": "^1.60.0",
+    "oxlint-tsgolint": "^0.21.1"
+  },
+  "engines": {
+    "node": "^20.19.0 || ^22.13.0 || >=24"
+  },
+  "packageManager": "pnpm@10.32.1"
+}