@newsteam/eslint-config 1.2.15 → 1.2.17

package/dist/{plugins → rules}/react-compiler.js

@@ -4,13 +4,11 @@ import reactCompiler from "eslint-plugin-react-compiler";
  *
  * https://www.npmjs.com/package/eslint-plugin-react-compiler
  */
-export const reactCompilerPlugin = [
-    {
-        plugins: {
-            "react-compiler": reactCompiler,
-        },
-        rules: {
-            "react-compiler/react-compiler": "warn",
-        },
+export const reactCompilerPluginConfig = {
+    plugins: {
+        "react-compiler": reactCompiler,
     },
-];
+    rules: {
+        "react-compiler/react-compiler": "warn",
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { Linter } from "eslint";
+export declare const reactHooksPluginConfig: Linter.Config;
+//# sourceMappingURL=react-hooks.d.ts.map

package/dist/rules/react-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-hooks.d.ts","sourceRoot":"","sources":["../../src/rules/react-hooks.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAWrC,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,MAwL3C,CAAC"}

package/dist/rules/react-hooks.js

@@ -0,0 +1,163 @@
+import reactHooks from "eslint-plugin-react-hooks";
+/*
+ * This ESLint plugin enforces the Rules of Hooks.
+ *
+ * It is a part of the Hooks API for React.
+ *
+ * https://www.npmjs.com/package/eslint-plugin-react-hooks
+ * https://reactjs.org/docs/hooks-rules.html
+ */
+export const reactHooksPluginConfig = {
+    plugins: {
+        "react-hooks": reactHooks,
+    },
+    rules: {
+        /*
+         * Verifies that automatic effect dependencies are compiled if opted-in
+         */
+        "react-hooks/automatic-effect-dependencies": "warn",
+        /*
+         * Validates against calling capitalized functions/methods instead of using JSX
+         */
+        "react-hooks/capitalized-calls": "warn",
+        /*
+         * Validates against higher order functions defining nested components or hooks.
+         * Components and hooks should be defined at the module level
+         */
+        "react-hooks/component-hook-factories": "warn",
+        /*
+         * Validates the compiler configuration options
+         */
+        "react-hooks/config": "warn",
+        /*
+         * Validates usage of error boundaries instead of try/catch for errors in child components
+         */
+        "react-hooks/error-boundaries": "warn",
+        /*
+         * Checks effect dependencies
+         *
+         * This is off because it doesn't always make sense to list all dependencies
+         */
+        // TODO (this should be turned on eventually)
+        "react-hooks/exhaustive-deps": "off",
+        /*
+         * Validates usage of fbt
+         *
+         * We don't use fbt
+         */
+        "react-hooks/fbt": "off",
+        /*
+         * Validates usage of `fire`
+         *
+         * We don't use fire
+         */
+        "react-hooks/fire": "off",
+        /*
+         * Validates configuration of
+         *
+         * We don't use gating
+         *
+         * https://react.dev/reference/react-compiler/gating
+         */
+        "react-hooks/gating": "off",
+        /*
+         * Validates against assignment/mutation of globals during render, part of ensuring that [side effects must render outside of render](https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)
+         */
+        "react-hooks/globals": "warn",
+        /*
+         * Validates the rules of hooks
+         */
+        "react-hooks/hooks": "warn",
+        /*
+         * Validates against mutating props, state, and other values that [are immutable](https://react.dev/reference/rules/components-and-hooks-must-be-pure#props-and-state-are-immutable)
+         */
+        "react-hooks/immutability": "warn",
+        /*
+         * Validates against usage of libraries which are incompatible with memoization (manual or automatic)
+         */
+        "react-hooks/incompatible-library": "warn",
+        /*
+         * Internal invariants
+         */
+        "react-hooks/invariant": "warn",
+        /*
+         * Validates that effect dependencies are memoized
+         */
+        "react-hooks/memoized-effect-dependencies": "warn",
+        /*
+         * Checks for unnessessary setState calls in useEffect hooks
+         *
+         * https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state
+         */
+        "react-hooks/no-deriving-state-in-effects": "warn",
+        // Apprently this doesn't exist anymore
+        // "react-hooks/no-unused-directives": "warn",
+        /*
+         * Validates that existing manual memoized is preserved by the compiler.
+         * React Compiler will only compile components and hooks if its inference
+         *
+         * https://react.dev/learn/react-compiler/introduction#what-should-i-do-about-usememo-usecallback-and-reactmemo
+         *
+         */
+        // TODO (this should be turned on eventually)
+        "react-hooks/preserve-manual-memoization": "off",
+        /*
+         * Validates that [components/hooks are pure](https://react.dev/reference/rules/components-and-hooks-must-be-pure) by checking that they do not call known-impure functions
+         */
+        "react-hooks/purity": "warn",
+        /*
+         * Validates correct usage of refs, not reading/writing during render. See the "pitfalls" section in [`useRef()` usage](https://react.dev/reference/react/useRef#usage)
+         *
+         * see https://medium.com/@teh_builder/ref-objects-inside-useeffect-hooks-eb7c15198780
+         */
+        "react-hooks/refs": "warn",
+        /*
+         * Validates against suppression of other rules
+         *
+         * Yeah we can suppress without having to do it twice
+         */
+        "react-hooks/rule-suppression": "off",
+        /*
+         * Validates the rules of hooks
+         */
+        "react-hooks/rules-of-hooks": "warn",
+        /*
+         * Validates against calling setState synchronously in an effect, which can lead to re-renders that degrade performance
+         */
+        // TODO (this should be turned on eventually)
+        "react-hooks/set-state-in-effect": "off",
+        /*
+         * Validates against setting state during render, which can trigger additional renders and potential infinite render loops
+         */
+        "react-hooks/set-state-in-render": "warn",
+        /*
+         * Validates that components are static, not recreated every render.
+         * Components that are recreated dynamically can reset state and trigger excessive re-rendering
+         */
+        "react-hooks/static-components": "warn",
+        /*
+         * Validates against invalid syntax
+         */
+        "react-hooks/syntax": "warn",
+        /*
+         * Unimplemented features
+         *
+         * It's unclear what this does, leaving it off
+         */
+        "react-hooks/todo": "off",
+        /*
+         * Validates against syntax that we do not plan to support in React Compiler
+         */
+        "react-hooks/unsupported-syntax": "warn",
+        /*
+         * Validates usage of the useMemo() hook against common mistakes.
+         *
+         * https://react.dev/reference/react/useMemo
+         */
+        "react-hooks/use-memo": "warn",
+        /*
+         * Validates that useMemos always return a value. See [`useMemo()` docs](https://react.dev/reference/react/useMemo) for more information.
+         */
+        "react-hooks/void-use-memo": "warn",
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { Linter } from "eslint";
+export declare const reactPerfPluginConfig: Linter.Config;
+//# sourceMappingURL=react-perf.d.ts.map

package/dist/rules/react-perf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-perf.d.ts","sourceRoot":"","sources":["../../src/rules/react-perf.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AASrC,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MA0C1C,CAAC"}

package/dist/rules/react-perf.js

@@ -0,0 +1,47 @@
+import { fixupPluginRules } from "@eslint/compat";
+import reactPerf from "eslint-plugin-react-perf";
+/*
+ * Performance-minded React linting rules for ESLint motivated by esamatti's
+ * post "React.js pure render performance anti-pattern".
+ * https://medium.com/@esamatti/react-js-pure-render-performance-anti-pattern-fb88c101332f
+ *
+ * https://www.npmjs.com/package/eslint-plugin-react-perf
+ */
+export const reactPerfPluginConfig = {
+    plugins: {
+        "react-perf": fixupPluginRules(reactPerf),
+    },
+    rules: {
+        /*
+         * Prevent JSX that are local to the current method from being used as values of JSX props
+         *
+         * We're unwilling to turn this on since it's a pretty common pattern and
+         * we're not convinced it'll make a noticable difference.
+         *
+         * https://github.com/cvazac/eslint-plugin-react-perf/blob/HEAD/docs/rules/jsx-no-jsx-as-prop.md
+         */
+        "react-perf/jsx-no-jsx-as-prop": "off",
+        /*
+         * Prevent Arrays that are local to the current method from being used as values of JSX props
+         *
+         * So common that we do this it's annoying
+         *
+         * https://github.com/cvazac/eslint-plugin-react-perf/blob/HEAD/docs/rules/jsx-no-new-array-as-prop.md
+         */
+        "react-perf/jsx-no-new-array-as-prop": "off",
+        /*
+         * Prevent Functions that are local to the current method from being used as values of JSX props
+         *
+         * https://github.com/cvazac/eslint-plugin-react-perf/blob/HEAD/docs/rules/jsx-no-new-function-as-prop.md
+         */
+        "react-perf/jsx-no-new-function-as-prop": "warn",
+        /*
+         * Prevent Objects that are local to the current method from being used as values of JSX props
+         *
+         * This is really annoying in practice, we're turning it off
+         *
+         * https://github.com/cvazac/eslint-plugin-react-perf/blob/HEAD/docs/rules/jsx-no-new-object-as-prop.md
+         */
+        "react-perf/jsx-no-new-object-as-prop": "off",
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { Linter } from "eslint";
+export declare const reactRefreshPluginConfig: Linter.Config;
+//# sourceMappingURL=react-refresh.d.ts.map

package/dist/rules/react-refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-refresh.d.ts","sourceRoot":"","sources":["../../src/rules/react-refresh.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAQrC,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAc7C,CAAC"}

package/dist/rules/react-refresh.js

@@ -0,0 +1,19 @@
+import reactRefresh from "eslint-plugin-react-refresh";
+/*
+ * Validate that your components can safely be updated with fast refresh.
+ *
+ * https://github.com/ArnaudBarre/eslint-plugin-react-refresh
+ */
+export const reactRefreshPluginConfig = {
+    plugins: {
+        "react-refresh": reactRefresh,
+    },
+    rules: {
+        /*
+         * Validate that your components can safely be updated with fast refresh.
+         *
+         * https://github.com/ArnaudBarre/eslint-plugin-react-refresh#usage
+         */
+        "react-refresh/only-export-components": "warn",
+    },
+};

package/dist/rules/react.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from "eslint";
+export declare const reactPluginConfig: Linter.Config;
+//# sourceMappingURL=react.d.ts.map

package/dist/rules/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/rules/react.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAQrC,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAm0BtC,CAAC"}