@reasonabletech/eslint-config 0.1.0

package/dist/src/react/config.js

@@ -0,0 +1,40 @@
+import { createCombinedReactPluginConfig } from "./plugins.js";
+import { allReactRules } from "./rules.js";
+import { createSharedReactComponentFileConfig } from "../shared/react-rules.js";
+/**
+ * Configuration builders for React projects.
+ *
+ * This module combines React plugins, rules, and file-specific
+ * configurations into complete ESLint configurations.
+ */
+/**
+ * Base React rules configuration.
+ *
+ * Applies all React rules (shared and React-specific) to the
+ * ESLint configuration.
+ * @returns ESLint configuration object with React rules
+ */
+export const createReactRulesConfig = () => ({
+    rules: {
+        ...allReactRules,
+    },
+});
+/**
+ * Complete React configuration builder.
+ *
+ * Combines all React-specific configurations including plugins,
+ * rules, and file-specific overrides into a comprehensive
+ * configuration array.
+ *
+ * Configuration includes:
+ * - React and React Hooks plugins with browser globals
+ * - All React rules (core, hooks, TypeScript overrides)
+ * - JSDoc rule exemptions for React component files
+ * @returns Array of ESLint configurations for React projects
+ */
+export const createReactConfigs = () => [
+    ...createCombinedReactPluginConfig(),
+    createReactRulesConfig(),
+    createSharedReactComponentFileConfig(),
+];
+//# sourceMappingURL=config.js.map

package/dist/src/react/plugins.d.ts

@@ -0,0 +1,24 @@
+import type { Linter } from "eslint";
+/**
+ * React plugin configurations for ESLint.
+ *
+ * This module provides pre-configured plugin setups for React development,
+ * including the base React plugin and React Hooks plugin with appropriate
+ * browser globals and settings.
+ */
+/**
+ * Base React plugin configuration.
+ *
+ * Provides the core React ESLint plugin with browser and service worker
+ * globals enabled for modern React applications.
+ * @returns Array of ESLint configurations for React projects
+ */
+export declare const createReactPluginConfig: () => Linter.Config[];
+/**
+ * Combined React plugin configuration.
+ *
+ * Returns React plugin configurations.
+ * @returns Array of ESLint configurations for React
+ */
+export declare const createCombinedReactPluginConfig: () => Linter.Config[];
+//# sourceMappingURL=plugins.d.ts.map

package/dist/src/react/plugins.js

@@ -0,0 +1,46 @@
+import reactPlugin from "eslint-plugin-react";
+import globals from "globals";
+/**
+ * React plugin configurations for ESLint.
+ *
+ * This module provides pre-configured plugin setups for React development,
+ * including the base React plugin and React Hooks plugin with appropriate
+ * browser globals and settings.
+ */
+/**
+ * Base React plugin configuration.
+ *
+ * Provides the core React ESLint plugin with browser and service worker
+ * globals enabled for modern React applications.
+ * @returns Array of ESLint configurations for React projects
+ */
+export const createReactPluginConfig = () => {
+    const reactConfig = reactPlugin.configs.flat.recommended;
+    return [
+        reactConfig,
+        {
+            languageOptions: {
+                ...reactConfig.languageOptions,
+                globals: {
+                    ...globals.serviceworker,
+                    ...globals.browser,
+                },
+            },
+            settings: {
+                react: {
+                    version: "detect",
+                },
+            },
+        },
+    ];
+};
+/**
+ * Combined React plugin configuration.
+ *
+ * Returns React plugin configurations.
+ * @returns Array of ESLint configurations for React
+ */
+export const createCombinedReactPluginConfig = () => {
+    return createReactPluginConfig();
+};
+//# sourceMappingURL=plugins.js.map

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

@@ -0,0 +1,30 @@
+import type { Linter } from "eslint";
+/**
+ * React-specific ESLint rules for standalone React projects.
+ *
+ * This module provides rules specifically tailored for React projects
+ * that are not using Next.js. It leverages shared React rules while
+ * adding React-specific configurations.
+ */
+/**
+ * Complete React rules configuration for standalone React projects.
+ *
+ * Uses shared React rules configured for modern React development
+ * with the new JSX transform.
+ */
+export declare const reactRules: Record<string, Linter.RuleEntry<any[]>>;
+/**
+ * Additional React-specific rules that don't apply to Next.js.
+ *
+ * These rules are specific to standalone React applications and
+ * may not be appropriate or necessary for Next.js projects.
+ */
+export declare const reactOnlyRules: {};
+/**
+ * Combined React rules for standalone React projects.
+ *
+ * Merges shared React rules with React-only rules to create
+ * a complete rule set for React projects.
+ */
+export declare const allReactRules: {};
+//# sourceMappingURL=rules.d.ts.map

package/dist/src/react/rules.js

@@ -0,0 +1,35 @@
+import { createSharedReactRules } from "../shared/react-rules.js";
+/**
+ * React-specific ESLint rules for standalone React projects.
+ *
+ * This module provides rules specifically tailored for React projects
+ * that are not using Next.js. It leverages shared React rules while
+ * adding React-specific configurations.
+ */
+/**
+ * Complete React rules configuration for standalone React projects.
+ *
+ * Uses shared React rules configured for modern React development
+ * with the new JSX transform.
+ */
+export const reactRules = createSharedReactRules("react");
+/**
+ * Additional React-specific rules that don't apply to Next.js.
+ *
+ * These rules are specific to standalone React applications and
+ * may not be appropriate or necessary for Next.js projects.
+ */
+export const reactOnlyRules = {
+// Add any React-only rules here if needed in the future
+};
+/**
+ * Combined React rules for standalone React projects.
+ *
+ * Merges shared React rules with React-only rules to create
+ * a complete rule set for React projects.
+ */
+export const allReactRules = {
+    ...reactRules,
+    ...reactOnlyRules,
+};
+//# sourceMappingURL=rules.js.map

package/dist/src/react.d.ts

@@ -0,0 +1,27 @@
+import type { Linter } from "eslint";
+/**
+ * Creates a type-aware ESLint configuration for React projects.
+ *
+ * This configuration extends the base TypeScript configuration with React-specific
+ * rules, plugins, and optimizations. It provides a comprehensive setup for modern
+ * React development with TypeScript.
+ *
+ * Key features:
+ * - Browser and service worker globals
+ * - React hooks validation with exhaustive dependencies
+ * - TypeScript rule overrides for React patterns
+ * - JSDoc requirement exemptions for React components
+ * - Modern JSX transform support (no React import required)
+ * @param projectDir - The directory containing the TypeScript project
+ * @returns A comprehensive type-aware ESLint configuration for React
+ * @example
+ * ```typescript
+ * // In your eslint.config.mjs
+ * import { createTypeAwareReactConfig } from "@reasonabletech/eslint-config/react";
+ *
+ * export default createTypeAwareReactConfig(import.meta.dirname);
+ * ```
+ */
+export declare function createTypeAwareReactConfig(projectDir: string): Linter.Config[];
+export default createTypeAwareReactConfig;
+//# sourceMappingURL=react.d.ts.map

package/dist/src/react.js

@@ -0,0 +1,35 @@
+import { createTypeAwareConfig } from "./index.js";
+import { createReactConfigs } from "./react/config.js";
+/**
+ * Creates a type-aware ESLint configuration for React projects.
+ *
+ * This configuration extends the base TypeScript configuration with React-specific
+ * rules, plugins, and optimizations. It provides a comprehensive setup for modern
+ * React development with TypeScript.
+ *
+ * Key features:
+ * - Browser and service worker globals
+ * - React hooks validation with exhaustive dependencies
+ * - TypeScript rule overrides for React patterns
+ * - JSDoc requirement exemptions for React components
+ * - Modern JSX transform support (no React import required)
+ * @param projectDir - The directory containing the TypeScript project
+ * @returns A comprehensive type-aware ESLint configuration for React
+ * @example
+ * ```typescript
+ * // In your eslint.config.mjs
+ * import { createTypeAwareReactConfig } from "@reasonabletech/eslint-config/react";
+ *
+ * export default createTypeAwareReactConfig(import.meta.dirname);
+ * ```
+ */
+export function createTypeAwareReactConfig(projectDir) {
+    return [
+        // Base TypeScript configuration with type-aware rules
+        ...createTypeAwareConfig(projectDir),
+        // React-specific configurations (plugins, rules, file overrides)
+        ...createReactConfigs(),
+    ];
+}
+export default createTypeAwareReactConfig;
+//# sourceMappingURL=react.js.map

package/dist/src/shared/parser-options.d.ts

@@ -0,0 +1,3 @@
+import type { Linter } from "eslint";
+export declare const removeProjectParserOption: (config: Linter.Config) => Linter.Config;
+//# sourceMappingURL=parser-options.d.ts.map

package/dist/src/shared/parser-options.js

@@ -0,0 +1,19 @@
+export const removeProjectParserOption = (config) => {
+    const parserOptions = config.languageOptions?.parserOptions;
+    if (parserOptions == null ||
+        typeof parserOptions !== "object" ||
+        Array.isArray(parserOptions) ||
+        !("project" in parserOptions)) {
+        return config;
+    }
+    const parserOptionsRecord = parserOptions;
+    const { project: _project, ...rest } = parserOptionsRecord;
+    return {
+        ...config,
+        languageOptions: {
+            ...config.languageOptions,
+            parserOptions: rest,
+        },
+    };
+};
+//# sourceMappingURL=parser-options.js.map

package/dist/src/shared/plugin-utils.d.ts

@@ -0,0 +1,8 @@
+import type { ESLint } from "eslint";
+/**
+ * Removes plugin config metadata to avoid circular references in flat configs.
+ * @param plugin - ESLint plugin instance that may include circular configs
+ * @returns Plugin without the `configs` metadata attached
+ */
+export declare const stripPluginConfigs: <T extends ESLint.Plugin>(plugin: T) => ESLint.Plugin;
+//# sourceMappingURL=plugin-utils.d.ts.map

package/dist/src/shared/plugin-utils.js

@@ -0,0 +1,23 @@
+/**
+ * Removes plugin config metadata to avoid circular references in flat configs.
+ * @param plugin - ESLint plugin instance that may include circular configs
+ * @returns Plugin without the `configs` metadata attached
+ */
+export const stripPluginConfigs = (plugin) => {
+    const { rules, processors, environments, meta } = plugin;
+    const stripped = {};
+    if (rules !== undefined) {
+        stripped.rules = rules;
+    }
+    if (processors !== undefined) {
+        stripped.processors = processors;
+    }
+    if (environments !== undefined) {
+        stripped.environments = environments;
+    }
+    if (meta !== undefined) {
+        stripped.meta = meta;
+    }
+    return stripped;
+};
+//# sourceMappingURL=plugin-utils.js.map

package/dist/src/shared/react-rules.d.ts

@@ -0,0 +1,97 @@
+import type { Linter } from "eslint";
+/**
+ * Shared React ESLint rules used across both React and Next.js configurations.
+ *
+ * This module provides reusable rule configurations that are common between
+ * standalone React projects and Next.js projects, reducing duplication and
+ * ensuring consistency across project types.
+ */
+/**
+ * Core React rules that apply to all React-based projects.
+ *
+ * These rules enforce modern React best practices and are suitable
+ * for both standalone React applications and Next.js applications.
+ */
+export declare const sharedReactCoreRules: {
+    readonly "react/no-unescaped-entities": "error";
+};
+/**
+ * React JSX scope rules with framework-specific variations.
+ *
+ * The JSX scope rule behavior differs between standalone React and Next.js:
+ * - Next.js: Always off (built-in JSX transform)
+ * - React: Off for modern setups with new JSX transform
+ */
+export declare const reactJSXScopeRules: {
+    /** For Next.js projects where JSX transform is built-in */
+    readonly nextjs: {
+        readonly "react/react-in-jsx-scope": "off";
+    };
+    /** For modern React projects with new JSX transform */
+    readonly modern: {
+        readonly "react/react-in-jsx-scope": "off";
+    };
+};
+/**
+ * TypeScript rule overrides for React development.
+ *
+ * These overrides disable specific TypeScript rules that conflict with
+ * React patterns while maintaining strict type safety standards.
+ * The same overrides apply to both React and Next.js projects.
+ *
+ * NOTE: strict-boolean-expressions is NOT disabled for React - we enforce
+ * explicit boolean checks even in conditional rendering to prevent bugs
+ * and maintain consistent architecture across the platform.
+ */
+export declare const sharedReactTypeScriptRules: {
+    readonly "@typescript-eslint/prefer-readonly-parameter-types": "off";
+    readonly "@typescript-eslint/require-await": "off";
+    readonly "@typescript-eslint/unbound-method": "off";
+};
+/**
+ * Rules for React component files.
+ *
+ * React components often have obvious return types (React.JSX.Element) and
+ * don't need explicit return type annotations or `@returns` documentation.
+ * This applies to both React and Next.js projects.
+ *
+ * Additionally, React components use destructured props with well-documented
+ * Props interfaces. ESLint's jsdoc plugin options are configured to skip
+ * destructured parameter documentation:
+ * - `checkDestructured: false` - don't require `@param` for individual properties
+ * - `checkDestructuredRoots: false` - don't require `@param` for the root parameter
+ *
+ * This prevents conflicts with TypeDoc which warns about unused `@param` tags
+ * when Props interfaces already document the properties.
+ */
+export declare const sharedReactComponentRules: {
+    readonly "jsdoc/require-returns": "off";
+    readonly "jsdoc/require-returns-description": "off";
+    readonly "jsdoc/require-param": ["warn", {
+        readonly checkDestructured: false;
+        readonly checkDestructuredRoots: false;
+    }];
+    readonly "jsdoc/check-param-names": ["warn", {
+        readonly checkDestructured: false;
+    }];
+};
+/**
+ * Creates a complete React rules configuration for a specific framework.
+ *
+ * Combines all shared React rules with framework-specific JSX scope rules
+ * to create a comprehensive rule set.
+ * @param framework - The target framework ("react" or "nextjs")
+ * @returns Combined React rules configuration
+ */
+export declare const createSharedReactRules: (framework: "react" | "nextjs") => Record<string, Linter.RuleEntry>;
+/**
+ * Creates a file-specific configuration for React components.
+ *
+ * Applies rule overrides to React component files (.tsx, .jsx) including:
+ * - Disables explicit return type requirements for React components only (JSX.Element is obvious)
+ * - Disables JSDoc return documentation requirements
+ * This configuration is identical for both React and Next.js projects.
+ * @returns ESLint configuration object for React component files
+ */
+export declare const createSharedReactComponentFileConfig: () => Linter.Config;
+//# sourceMappingURL=react-rules.d.ts.map

package/dist/src/shared/react-rules.js

@@ -0,0 +1,126 @@
+/**
+ * Shared React ESLint rules used across both React and Next.js configurations.
+ *
+ * This module provides reusable rule configurations that are common between
+ * standalone React projects and Next.js projects, reducing duplication and
+ * ensuring consistency across project types.
+ */
+/**
+ * Core React rules that apply to all React-based projects.
+ *
+ * These rules enforce modern React best practices and are suitable
+ * for both standalone React applications and Next.js applications.
+ */
+export const sharedReactCoreRules = {
+    "react/no-unescaped-entities": "error", // Prevent HTML entity issues
+};
+/**
+ * React JSX scope rules with framework-specific variations.
+ *
+ * The JSX scope rule behavior differs between standalone React and Next.js:
+ * - Next.js: Always off (built-in JSX transform)
+ * - React: Off for modern setups with new JSX transform
+ */
+export const reactJSXScopeRules = {
+    /** For Next.js projects where JSX transform is built-in */
+    nextjs: {
+        "react/react-in-jsx-scope": "off",
+    },
+    /** For modern React projects with new JSX transform */
+    modern: {
+        "react/react-in-jsx-scope": "off",
+    },
+};
+/**
+ * TypeScript rule overrides for React development.
+ *
+ * These overrides disable specific TypeScript rules that conflict with
+ * React patterns while maintaining strict type safety standards.
+ * The same overrides apply to both React and Next.js projects.
+ *
+ * NOTE: strict-boolean-expressions is NOT disabled for React - we enforce
+ * explicit boolean checks even in conditional rendering to prevent bugs
+ * and maintain consistent architecture across the platform.
+ */
+export const sharedReactTypeScriptRules = {
+    "@typescript-eslint/prefer-readonly-parameter-types": "off", // Too restrictive for React props
+    "@typescript-eslint/require-await": "off", // React event handlers often don't need await
+    "@typescript-eslint/unbound-method": "off", // Known issue with React event handlers
+};
+/**
+ * Rules for React component files.
+ *
+ * React components often have obvious return types (React.JSX.Element) and
+ * don't need explicit return type annotations or `@returns` documentation.
+ * This applies to both React and Next.js projects.
+ *
+ * Additionally, React components use destructured props with well-documented
+ * Props interfaces. ESLint's jsdoc plugin options are configured to skip
+ * destructured parameter documentation:
+ * - `checkDestructured: false` - don't require `@param` for individual properties
+ * - `checkDestructuredRoots: false` - don't require `@param` for the root parameter
+ *
+ * This prevents conflicts with TypeDoc which warns about unused `@param` tags
+ * when Props interfaces already document the properties.
+ */
+export const sharedReactComponentRules = {
+    // Disable explicit return types for React components - JSX.Element is obvious
+    // Note: This is applied via file-specific overrides in createSharedReactComponentFileConfig
+    // JSDoc return documentation not needed with explicit TypeScript types
+    "jsdoc/require-returns": "off",
+    "jsdoc/require-returns-description": "off",
+    // Disable requiring @param for destructured props - Props interfaces document these
+    // checkDestructuredRoots: false prevents the "Missing @param root0" warning
+    "jsdoc/require-param": [
+        "warn",
+        { checkDestructured: false, checkDestructuredRoots: false },
+    ],
+    // check-param-names only supports checkDestructured (not checkDestructuredRoots)
+    "jsdoc/check-param-names": ["warn", { checkDestructured: false }],
+};
+/**
+ * Creates a complete React rules configuration for a specific framework.
+ *
+ * Combines all shared React rules with framework-specific JSX scope rules
+ * to create a comprehensive rule set.
+ * @param framework - The target framework ("react" or "nextjs")
+ * @returns Combined React rules configuration
+ */
+export const createSharedReactRules = (framework) => ({
+    ...sharedReactCoreRules,
+    ...(framework === "nextjs"
+        ? reactJSXScopeRules.nextjs
+        : reactJSXScopeRules.modern),
+    ...sharedReactTypeScriptRules,
+});
+/**
+ * Creates a file-specific configuration for React components.
+ *
+ * Applies rule overrides to React component files (.tsx, .jsx) including:
+ * - Disables explicit return type requirements for React components only (JSX.Element is obvious)
+ * - Disables JSDoc return documentation requirements
+ * This configuration is identical for both React and Next.js projects.
+ * @returns ESLint configuration object for React component files
+ */
+export const createSharedReactComponentFileConfig = () => ({
+    files: ["**/*.tsx", "**/*.jsx"],
+    rules: {
+        ...sharedReactComponentRules,
+        // Only disable explicit return types for React component functions
+        // This uses overrides to target functions that return JSX elements
+        "@typescript-eslint/explicit-function-return-type": [
+            "error",
+            {
+                allowExpressions: true,
+                allowTypedFunctionExpressions: true,
+                allowHigherOrderFunctions: true,
+                allowDirectConstAssertionInArrowFunctions: true,
+                allowConciseArrowFunctionExpressionsStartingWithVoid: false,
+                // Allow JSX-returning functions to omit return types
+                allowedNames: [],
+                allowFunctionsWithoutTypeParameters: false,
+            },
+        ],
+    },
+});
+//# sourceMappingURL=react-rules.js.map

package/dist/src/shared/strict-rules.d.ts

@@ -0,0 +1,27 @@
+import type { Linter } from "eslint";
+/**
+ * Strict TypeScript rules that should be applied to all projects.
+ *
+ * This module provides rules-only configurations that can be safely
+ * added to any ESLint setup without conflicting with existing plugins.
+ * These rules ensure consistent type safety across all project types.
+ */
+/**
+ * Creates a rules-only configuration for strict TypeScript checking.
+ *
+ * This configuration contains only rules and does not define any plugins,
+ * making it safe to add to configurations that already have TypeScript
+ * ESLint plugins configured (like Next.js configs).
+ * @returns ESLint configuration with strict TypeScript rules
+ */
+export declare const createStrictTypeScriptRulesConfig: () => Linter.Config;
+/**
+ * Creates a rules-only configuration for strict boolean expressions specifically.
+ *
+ * This is a focused configuration that only includes the strict-boolean-expressions
+ * rule, which is often the most impactful rule for React/Next.js projects.
+ * @param projectDir - The project directory for TypeScript parser configuration (required for type-aware rules)
+ * @returns ESLint configuration with strict boolean expression rule and parser options
+ */
+export declare const createStrictBooleanExpressionsConfig: (projectDir: string) => Linter.Config;
+//# sourceMappingURL=strict-rules.d.ts.map

package/dist/src/shared/strict-rules.js

@@ -0,0 +1,54 @@
+import { typeAwareRules } from "../shared-rules.js";
+/**
+ * Strict TypeScript rules that should be applied to all projects.
+ *
+ * This module provides rules-only configurations that can be safely
+ * added to any ESLint setup without conflicting with existing plugins.
+ * These rules ensure consistent type safety across all project types.
+ */
+/**
+ * Creates a rules-only configuration for strict TypeScript checking.
+ *
+ * This configuration contains only rules and does not define any plugins,
+ * making it safe to add to configurations that already have TypeScript
+ * ESLint plugins configured (like Next.js configs).
+ * @returns ESLint configuration with strict TypeScript rules
+ */
+export const createStrictTypeScriptRulesConfig = () => ({
+    rules: {
+        // Include all type-aware rules from our base configuration
+        ...typeAwareRules,
+    },
+});
+/**
+ * Creates a rules-only configuration for strict boolean expressions specifically.
+ *
+ * This is a focused configuration that only includes the strict-boolean-expressions
+ * rule, which is often the most impactful rule for React/Next.js projects.
+ * @param projectDir - The project directory for TypeScript parser configuration (required for type-aware rules)
+ * @returns ESLint configuration with strict boolean expression rule and parser options
+ */
+export const createStrictBooleanExpressionsConfig = (projectDir) => ({
+    languageOptions: {
+        parserOptions: {
+            projectService: true,
+            tsconfigRootDir: projectDir,
+        },
+    },
+    rules: {
+        "@typescript-eslint/strict-boolean-expressions": [
+            "error",
+            {
+                // Require explicit boolean checks - critical for AI-generated code safety
+                allowString: false, // Prevent truthy string checks
+                allowNumber: false, // Prevent truthy number checks
+                allowNullableObject: false, // Require explicit null checks
+                allowNullableBoolean: false,
+                allowNullableString: false,
+                allowNullableNumber: false,
+                allowAny: false, // Critical: prevent `any` in conditions
+            },
+        ],
+    },
+});
+//# sourceMappingURL=strict-rules.js.map

package/dist/src/shared-ignores.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shared ignore patterns for ESLint configurations
+ *
+ * This module defines the standard ignore patterns used across all ESLint
+ * configurations in the monorepo to ensure consistent behavior
+ * and avoid linting generated files, build outputs, and dependencies.
+ */
+/**
+ * Standard ignore patterns for all ESLint configurations.
+ *
+ * These patterns exclude common build outputs, generated files,
+ * and dependencies that should not be linted.
+ */
+export declare const sharedIgnores: string[];
+//# sourceMappingURL=shared-ignores.d.ts.map