@reasonabletech/eslint-config 0.1.0

package/dist/src/custom-rules/type-safety.js

@@ -0,0 +1,121 @@
+/**
+ * Type safety rule definitions for ReasonableTech projects
+ *
+ * These rules prevent type system bypasses and enforce safe type handling
+ * patterns, particularly around Result types and type assertions.
+ */
+import { AST_NODE_TYPES, ESLintUtils, } from "@typescript-eslint/utils";
+/**
+ * Custom ESLint rule that prevents `as any` and `<any>` type casts
+ *
+ * This rule detects all forms of casting to `any`, including:
+ * - `expr as any`
+ * - `<any>expr`
+ * - Double casts through any: `(expr as any) as T`
+ *
+ * Each variant produces a distinct, descriptive error message rather than the
+ * generic "no-restricted-syntax" label that the previous AST-selector approach
+ * showed in editors.
+ */
+export const noAsAnyRule = ESLintUtils.RuleCreator(() => "docs/standards/typescript-standards.md")({
+    name: "no-as-any",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Prevents 'as any' and '<any>' type casts that bypass TypeScript's type checking",
+        },
+        messages: {
+            asAny: "Never use 'as any' casts. Use proper type assertions or type guards instead.",
+            angleAny: "Never use '<any>' casts. Use proper type assertions or type guards instead.",
+            doubleCast: "Never use double casts through 'as any'. Use proper type guards instead.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * Checks whether a TSAnyKeyword is a direct child of a TSAsExpression
+         * and, if so, whether the cast is part of a double-cast pattern.
+         * @param node The TSAsExpression node to check
+         */
+        function checkAsExpression(node) {
+            if (node.typeAnnotation.type !== AST_NODE_TYPES.TSAnyKeyword) {
+                return;
+            }
+            // Double-cast pattern: (expr as any) as T — the inner `as any` lives
+            // inside an outer TSAsExpression.
+            const parent = node.parent;
+            if (parent.type === AST_NODE_TYPES.TSAsExpression &&
+                parent.expression === node) {
+                context.report({ node: node.typeAnnotation, messageId: "doubleCast" });
+                return;
+            }
+            context.report({ node: node.typeAnnotation, messageId: "asAny" });
+        }
+        /**
+         * Checks whether a TSTypeAssertion (angle-bracket syntax) casts to any.
+         * @param node The TSTypeAssertion node to check
+         */
+        function checkTypeAssertion(node) {
+            if (node.typeAnnotation.type !== AST_NODE_TYPES.TSAnyKeyword) {
+                return;
+            }
+            context.report({ node: node.typeAnnotation, messageId: "angleAny" });
+        }
+        return {
+            TSAsExpression: checkAsExpression,
+            TSTypeAssertion: checkTypeAssertion,
+        };
+    },
+});
+/**
+ * Creates rules that prevent `as any` type casts
+ *
+ * These rules block the use of `as any` type assertions, which bypass
+ * TypeScript's type checking and create type safety holes.
+ *
+ * ❌ FORBIDDEN:
+ * ```typescript
+ * const data = response as any; // Bypasses type checking
+ * const x = (response as any) as User; // Double cast through any
+ * ```
+ *
+ * ✅ CORRECT:
+ * ```typescript
+ * const data = parseResponse(response); // Proper typed parsing
+ * const user = data.result.user; // Type-safe access
+ * ```
+ * @param _options Configuration options for type safety rules (reserved for future use)
+ * @returns ESLint rules that prevent `as any` casts
+ */
+export function createNoAnyRules(_options = {}) {
+    return {
+        "@typescript-eslint/no-explicit-any": "error",
+        "@reasonabletech/no-as-any": "error",
+    };
+}
+/**
+ * Creates a complete set of type safety rules
+ *
+ * This is the main function that combines all type safety rules
+ * into a single configuration object.
+ * @param options Configuration options for type safety rules
+ * @returns Complete set of type safety ESLint rules
+ */
+export function createTypeSafetyRules(options = {}) {
+    return createNoAnyRules(options);
+}
+/**
+ * Preset for Platform-specific type safety rules
+ *
+ * This preset provides all type safety rules configured specifically
+ * for platform project conventions and documentation structure.
+ * @returns ESLint rules configured for platform projects
+ */
+export function createPlatformTypeSafetyRules() {
+    return createTypeSafetyRules({
+        docBaseUrl: "docs/standards/typescript-standards.md",
+        allowInTests: false,
+    });
+}
+//# sourceMappingURL=type-safety.js.map

package/dist/src/custom-rules/ui-library-imports.d.ts

@@ -0,0 +1,21 @@
+import type { Linter } from "eslint";
+/**
+ * Configuration options for UI library import boundary rules.
+ */
+export interface UILibraryImportRuleOptions {
+    /**
+     * Whether to enforce subpath-only imports for `@lovelace-ai/ui`.
+     * @default true
+     */
+    discourageUILibraryBarrelImports?: boolean;
+}
+/**
+ * Creates rules that enforce subpath imports for the configured UI library.
+ *
+ * This enforces separation of responsibilities for shared UI code by preventing
+ * broad barrel imports from the package root.
+ * @param options Configuration for UI library import boundaries
+ * @returns ESLint rules for UI import boundaries
+ */
+export declare function createUILibraryImportRules(options?: UILibraryImportRuleOptions): Linter.RulesRecord;
+//# sourceMappingURL=ui-library-imports.d.ts.map

package/dist/src/custom-rules/ui-library-imports.js

@@ -0,0 +1,31 @@
+const DEFAULT_UI_LIBRARY_OPTIONS = {
+    discourageUILibraryBarrelImports: true,
+};
+const LOVELACE_UI_PACKAGE_NAME = "@lovelace-ai/ui";
+function escapeSelectorLiteral(value) {
+    return value.replaceAll("\\", "\\\\").replaceAll("'", "\\'");
+}
+/**
+ * Creates rules that enforce subpath imports for the configured UI library.
+ *
+ * This enforces separation of responsibilities for shared UI code by preventing
+ * broad barrel imports from the package root.
+ * @param options Configuration for UI library import boundaries
+ * @returns ESLint rules for UI import boundaries
+ */
+export function createUILibraryImportRules(options = {}) {
+    const config = { ...DEFAULT_UI_LIBRARY_OPTIONS, ...options };
+    if (!config.discourageUILibraryBarrelImports) {
+        return {};
+    }
+    return {
+        "no-restricted-syntax": [
+            "error",
+            {
+                selector: `ImportDeclaration[source.value='${escapeSelectorLiteral(LOVELACE_UI_PACKAGE_NAME)}'] ImportSpecifier`,
+                message: `❌ FORBIDDEN: Never use barrel imports from ${LOVELACE_UI_PACKAGE_NAME}. Use default imports from specific subpaths instead. Example: import Button from "${LOVELACE_UI_PACKAGE_NAME}/button";`,
+            },
+        ],
+    };
+}
+//# sourceMappingURL=ui-library-imports.js.map

package/dist/src/custom-rules/utils.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Utility functions for custom ESLint rules
+ *
+ * These utilities help with rule configuration, AST selectors,
+ * and other common patterns used across custom rules.
+ */
+import type { Linter } from "eslint";
+/**
+ * Base configuration interface for all custom rules
+ */
+export interface BaseRuleOptions {
+    /** Base URL for documentation references */
+    docBaseUrl?: string;
+    /** Whether to enable this rule set (default: true) */
+    enabled?: boolean;
+}
+/**
+ * Merges rule configurations, handling the no-restricted-syntax rule specially
+ *
+ * Since multiple rule creators may want to add patterns to no-restricted-syntax,
+ * this function properly merges them into a single rule configuration.
+ * @param ruleConfigs Multiple ESLint rule configuration objects to merge
+ * @returns Merged ESLint rule configuration
+ */
+export declare function mergeRuleConfigurations(...ruleConfigs: Linter.RulesRecord[]): Linter.RulesRecord;
+/**
+ * Creates a rule configuration that can be conditionally enabled
+ * @param ruleFactory Function that creates the rules to conditionally apply
+ * @param options Options that determine whether to apply the rules
+ * @returns ESLint rules or empty object based on conditions
+ */
+export declare function createConditionalRules(ruleFactory: () => Linter.RulesRecord, options: BaseRuleOptions): Linter.RulesRecord;
+/**
+ * Common AST selector patterns for TypeScript constructs
+ */
+export declare const AST_SELECTORS: {
+    readonly ERROR_MESSAGE_ACCESS: "[callee.object.property.name='message']";
+    readonly EXPORTED_TYPE_ALIAS: "ExportNamedDeclaration > TSTypeAliasDeclaration";
+    readonly TYPE_REFERENCE: "TSTypeReference";
+    readonly UNION_TYPE_WITH_LITERALS: "TSUnionType:has(TSLiteralType)";
+    readonly STRING_INCLUDES: "[callee.property.name='includes']";
+    readonly STRING_STARTS_WITH: "[callee.property.name='startsWith']";
+    readonly STRING_ENDS_WITH: "[callee.property.name='endsWith']";
+    readonly REGEX_MATCH: "[callee.property.name='match']";
+    readonly REGEX_TEST: "[callee.property.name='test']";
+    readonly STRICT_EQUALITY: "BinaryExpression[operator='===']";
+    readonly LOOSE_EQUALITY: "BinaryExpression[operator='==']";
+};
+/**
+ * Creates an AST selector for exported type aliases matching a pattern
+ * @param namePattern Regular expression pattern for type names
+ * @returns AST selector string for matching exported types
+ */
+export declare function createExportedTypeSelector(namePattern: string): string;
+/**
+ * Creates an AST selector for type references with specific type names
+ * @param typeName Name of the type to select references for
+ * @returns AST selector string for type references
+ */
+export declare function createTypeReferenceSelector(typeName: string): string;
+/**
+ * Creates an AST selector for Result type inline unions
+ * @param resultTypeName Name of the Result type to check
+ * @returns AST selector string for inline unions in Result types
+ */
+export declare function createResultInlineUnionSelector(resultTypeName?: string): string;
+/**
+ * Creates an AST selector for Promise<Result<T, E>> inline unions
+ * @param resultTypeName Name of the Result type to check within Promise
+ * @returns AST selector string for inline unions in Promise<Result> types
+ */
+export declare function createPromiseResultInlineUnionSelector(resultTypeName?: string): string;
+/**
+ * Standard error messages for common violations
+ */
+export declare const ERROR_MESSAGES: {
+    readonly NO_ERROR_MESSAGE_PARSING: "❌ FORBIDDEN: Never parse error messages. Use error.code, error.status, or instanceof checks instead.";
+    readonly NO_INLINE_ERROR_UNIONS: "❌ FORBIDDEN: Never use inline error unions. Extract to a documented named type.";
+    readonly REQUIRE_ERROR_TYPE_DOCS: "❌ REQUIRED: All error types must have comprehensive JSDoc documentation.";
+    readonly FOLLOW_NAMING_CONVENTION: "❌ REQUIRED: Follow established naming conventions for error types and codes.";
+};
+/**
+ * Creates a documentation reference URL
+ * @param baseUrl Base URL for the documentation
+ * @param section Optional section anchor to append
+ * @returns Complete documentation URL with optional section
+ */
+export declare function createDocReference(baseUrl: string, section?: string): string;
+/**
+ * Type guard to check if a rule config is enabled
+ * @param ruleConfig ESLint rule configuration entry
+ * @returns True if the rule is enabled, false otherwise
+ */
+export declare function isRuleEnabled(ruleConfig: Linter.RuleEntry | undefined): boolean;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/custom-rules/utils.js

@@ -0,0 +1,146 @@
+/**
+ * Utility functions for custom ESLint rules
+ *
+ * These utilities help with rule configuration, AST selectors,
+ * and other common patterns used across custom rules.
+ */
+/**
+ * Merges rule configurations, handling the no-restricted-syntax rule specially
+ *
+ * Since multiple rule creators may want to add patterns to no-restricted-syntax,
+ * this function properly merges them into a single rule configuration.
+ * @param ruleConfigs Multiple ESLint rule configuration objects to merge
+ * @returns Merged ESLint rule configuration
+ */
+export function mergeRuleConfigurations(...ruleConfigs) {
+    const merged = {};
+    const restrictedSyntaxPatterns = [];
+    let highestSeverity = "warn";
+    for (const config of ruleConfigs) {
+        for (const [ruleName, ruleConfig] of Object.entries(config)) {
+            if (ruleName === "no-restricted-syntax" && Array.isArray(ruleConfig)) {
+                // Extract patterns from no-restricted-syntax rules
+                const [level, ...patterns] = ruleConfig;
+                if (level === "error" || level === "warn") {
+                    if (level === "error") {
+                        highestSeverity = "error";
+                    }
+                    restrictedSyntaxPatterns.push(...patterns);
+                }
+            }
+            else {
+                // For other rules, last one wins (allows overrides)
+                merged[ruleName] = ruleConfig;
+            }
+        }
+    }
+    // Deduplicate patterns by selector (last occurrence wins for override semantics).
+    // ESLint 9.x rejects configs with duplicate no-restricted-syntax selectors.
+    const deduplicatedPatterns = [
+        ...new Map(restrictedSyntaxPatterns.map((p) => [p.selector, p])).values(),
+    ];
+    // Add the merged no-restricted-syntax rule if we have patterns
+    if (deduplicatedPatterns.length > 0) {
+        merged["no-restricted-syntax"] = [highestSeverity, ...deduplicatedPatterns];
+    }
+    return merged;
+}
+/**
+ * Creates a rule configuration that can be conditionally enabled
+ * @param ruleFactory Function that creates the rules to conditionally apply
+ * @param options Options that determine whether to apply the rules
+ * @returns ESLint rules or empty object based on conditions
+ */
+export function createConditionalRules(ruleFactory, options) {
+    if (options.enabled === false) {
+        return {};
+    }
+    return ruleFactory();
+}
+/**
+ * Common AST selector patterns for TypeScript constructs
+ */
+export const AST_SELECTORS = {
+    // Error-related selectors
+    ERROR_MESSAGE_ACCESS: "[callee.object.property.name='message']",
+    EXPORTED_TYPE_ALIAS: "ExportNamedDeclaration > TSTypeAliasDeclaration",
+    TYPE_REFERENCE: "TSTypeReference",
+    UNION_TYPE_WITH_LITERALS: "TSUnionType:has(TSLiteralType)",
+    // Method call selectors
+    STRING_INCLUDES: "[callee.property.name='includes']",
+    STRING_STARTS_WITH: "[callee.property.name='startsWith']",
+    STRING_ENDS_WITH: "[callee.property.name='endsWith']",
+    REGEX_MATCH: "[callee.property.name='match']",
+    REGEX_TEST: "[callee.property.name='test']",
+    // Binary operation selectors
+    STRICT_EQUALITY: "BinaryExpression[operator='===']",
+    LOOSE_EQUALITY: "BinaryExpression[operator='==']",
+};
+/**
+ * Creates an AST selector for exported type aliases matching a pattern
+ * @param namePattern Regular expression pattern for type names
+ * @returns AST selector string for matching exported types
+ */
+export function createExportedTypeSelector(namePattern) {
+    return `${AST_SELECTORS.EXPORTED_TYPE_ALIAS}[id.name=/${namePattern}/]`;
+}
+/**
+ * Creates an AST selector for type references with specific type names
+ * @param typeName Name of the type to select references for
+ * @returns AST selector string for type references
+ */
+export function createTypeReferenceSelector(typeName) {
+    return `${AST_SELECTORS.TYPE_REFERENCE}[typeName.name='${typeName}']`;
+}
+/**
+ * Creates an AST selector for Result type inline unions
+ * @param resultTypeName Name of the Result type to check
+ * @returns AST selector string for inline unions in Result types
+ */
+export function createResultInlineUnionSelector(resultTypeName = "Result") {
+    return `${createTypeReferenceSelector(resultTypeName)} ${AST_SELECTORS.UNION_TYPE_WITH_LITERALS}`;
+}
+/**
+ * Creates an AST selector for Promise<Result<T, E>> inline unions
+ * @param resultTypeName Name of the Result type to check within Promise
+ * @returns AST selector string for inline unions in Promise<Result> types
+ */
+export function createPromiseResultInlineUnionSelector(resultTypeName = "Result") {
+    return `${createTypeReferenceSelector("Promise")} TSTypeParameterInstantiation ${createTypeReferenceSelector(resultTypeName)} ${AST_SELECTORS.UNION_TYPE_WITH_LITERALS}`;
+}
+/**
+ * Standard error messages for common violations
+ */
+export const ERROR_MESSAGES = {
+    NO_ERROR_MESSAGE_PARSING: "❌ FORBIDDEN: Never parse error messages. Use error.code, error.status, or instanceof checks instead.",
+    NO_INLINE_ERROR_UNIONS: "❌ FORBIDDEN: Never use inline error unions. Extract to a documented named type.",
+    REQUIRE_ERROR_TYPE_DOCS: "❌ REQUIRED: All error types must have comprehensive JSDoc documentation.",
+    FOLLOW_NAMING_CONVENTION: "❌ REQUIRED: Follow established naming conventions for error types and codes.",
+};
+/**
+ * Creates a documentation reference URL
+ * @param baseUrl Base URL for the documentation
+ * @param section Optional section anchor to append
+ * @returns Complete documentation URL with optional section
+ */
+export function createDocReference(baseUrl, section) {
+    if (section !== undefined && section !== "") {
+        return `${baseUrl}#${section}`;
+    }
+    return baseUrl;
+}
+/**
+ * Type guard to check if a rule config is enabled
+ * @param ruleConfig ESLint rule configuration entry
+ * @returns True if the rule is enabled, false otherwise
+ */
+export function isRuleEnabled(ruleConfig) {
+    if (ruleConfig === undefined) {
+        return false;
+    }
+    if (Array.isArray(ruleConfig)) {
+        return ruleConfig[0] === "error" || ruleConfig[0] === "warn";
+    }
+    return ruleConfig === "error" || ruleConfig === "warn";
+}
+//# sourceMappingURL=utils.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,73 @@
+import type { Linter } from "eslint";
+export { sharedReactComponentRules } from "./shared/react-rules.js";
+/**
+ * Creates a comprehensive type-aware ESLint configuration for TypeScript projects.
+ *
+ * This is the **mandatory base configuration** for all projects.
+ * It provides essential TypeScript linting rules that ensure code quality, type safety,
+ * and consistency across the entire monorepo.
+ *
+ * ## Key Features
+ *
+ * - **Type-aware analysis**: Leverages TypeScript's type checker for advanced linting
+ * - **Strict type safety**: Enforces patterns that prevent runtime type errors
+ * - **AI code compatibility**: Optimized for AI-generated code validation
+ * - **Monorepo consistency**: Standardized rules across all packages
+ * - **Performance optimized**: Configured for fast incremental type checking
+ *
+ * ## Usage Patterns
+ *
+ * **Standalone TypeScript projects:**
+ * ```typescript
+ * import { createTypeAwareConfig } from "@reasonabletech/eslint-config";
+ * export default createTypeAwareConfig(import.meta.dirname);
+ * ```
+ *
+ * **Extended configurations:**
+ * ```typescript
+ * import { createTypeAwareConfig } from "@reasonabletech/eslint-config";
+ * import { createTypeAwareReactConfig } from "@reasonabletech/eslint-config/react";
+ *
+ * // React config automatically extends this base config
+ * export default createTypeAwareReactConfig(import.meta.dirname);
+ * ```
+ *
+ * ## Configuration Details
+ *
+ * The configuration includes:
+ * - TypeScript ESLint parser with type information
+ * - Recommended TypeScript ESLint rules
+ * - JSDoc documentation requirements
+ * - Import/export validation
+ * - Strict null checks and type assertions
+ * - Performance-optimized type checking
+ * @param projectDir - The absolute path to the directory containing the TypeScript project.
+ *                     This is used for TypeScript's project service and type checking.
+ * @returns A complete ESLint configuration array optimized for TypeScript development
+ * @see {@link https://typescript-eslint.io/getting-started | TypeScript ESLint Documentation}
+ * @see {@link ../../README.md | Package README} for complete usage examples
+ * @example
+ * ```typescript
+ * // Basic usage in eslint.config.mjs
+ * import { createTypeAwareConfig } from "@reasonabletech/eslint-config";
+ *
+ * export default createTypeAwareConfig(import.meta.dirname);
+ * ```
+ * @example
+ * ```typescript
+ * // Extending with custom rules
+ * import { createTypeAwareConfig } from "@reasonabletech/eslint-config";
+ *
+ * export default [
+ *   ...createTypeAwareConfig(import.meta.dirname),
+ *   {
+ *     rules: {
+ *       // Project-specific overrides
+ *       "@typescript-eslint/no-unused-vars": "warn",
+ *     },
+ *   },
+ * ];
+ * ```
+ */
+export declare function createTypeAwareConfig(projectDir: string): Linter.Config[];
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -0,0 +1,80 @@
+import path from "node:path";
+import { createTypeAwareBaseConfig } from "./base-configs.js";
+// Re-export shared React component rules for use in root config
+export { sharedReactComponentRules } from "./shared/react-rules.js";
+/**
+ * Creates a comprehensive type-aware ESLint configuration for TypeScript projects.
+ *
+ * This is the **mandatory base configuration** for all projects.
+ * It provides essential TypeScript linting rules that ensure code quality, type safety,
+ * and consistency across the entire monorepo.
+ *
+ * ## Key Features
+ *
+ * - **Type-aware analysis**: Leverages TypeScript's type checker for advanced linting
+ * - **Strict type safety**: Enforces patterns that prevent runtime type errors
+ * - **AI code compatibility**: Optimized for AI-generated code validation
+ * - **Monorepo consistency**: Standardized rules across all packages
+ * - **Performance optimized**: Configured for fast incremental type checking
+ *
+ * ## Usage Patterns
+ *
+ * **Standalone TypeScript projects:**
+ * ```typescript
+ * import { createTypeAwareConfig } from "@reasonabletech/eslint-config";
+ * export default createTypeAwareConfig(import.meta.dirname);
+ * ```
+ *
+ * **Extended configurations:**
+ * ```typescript
+ * import { createTypeAwareConfig } from "@reasonabletech/eslint-config";
+ * import { createTypeAwareReactConfig } from "@reasonabletech/eslint-config/react";
+ *
+ * // React config automatically extends this base config
+ * export default createTypeAwareReactConfig(import.meta.dirname);
+ * ```
+ *
+ * ## Configuration Details
+ *
+ * The configuration includes:
+ * - TypeScript ESLint parser with type information
+ * - Recommended TypeScript ESLint rules
+ * - JSDoc documentation requirements
+ * - Import/export validation
+ * - Strict null checks and type assertions
+ * - Performance-optimized type checking
+ * @param projectDir - The absolute path to the directory containing the TypeScript project.
+ *                     This is used for TypeScript's project service and type checking.
+ * @returns A complete ESLint configuration array optimized for TypeScript development
+ * @see {@link https://typescript-eslint.io/getting-started | TypeScript ESLint Documentation}
+ * @see {@link ../../README.md | Package README} for complete usage examples
+ * @example
+ * ```typescript
+ * // Basic usage in eslint.config.mjs
+ * import { createTypeAwareConfig } from "@reasonabletech/eslint-config";
+ *
+ * export default createTypeAwareConfig(import.meta.dirname);
+ * ```
+ * @example
+ * ```typescript
+ * // Extending with custom rules
+ * import { createTypeAwareConfig } from "@reasonabletech/eslint-config";
+ *
+ * export default [
+ *   ...createTypeAwareConfig(import.meta.dirname),
+ *   {
+ *     rules: {
+ *       // Project-specific overrides
+ *       "@typescript-eslint/no-unused-vars": "warn",
+ *     },
+ *   },
+ * ];
+ * ```
+ */
+export function createTypeAwareConfig(projectDir) {
+    const baseDir = path.isAbsolute(projectDir)
+        ? projectDir
+        : path.resolve(projectDir);
+    return createTypeAwareBaseConfig(baseDir);
+}
+//# sourceMappingURL=index.js.map

package/dist/src/next/config.d.ts

@@ -0,0 +1,26 @@
+import type { Linter } from "eslint";
+/**
+ * Complete Next.js ESLint configuration builder.
+ *
+ * This module orchestrates all Next.js-specific ESLint configurations
+ * including ignores, plugins, rules, and settings into a coherent
+ * configuration array.
+ */
+/**
+ * Creates the complete Next.js ESLint configuration.
+ *
+ * This function combines all Next.js-specific configurations and handles
+ * the complex logic of plugin availability, fallbacks, and conditional
+ * rule application.
+ *
+ * Configuration includes:
+ * - Next.js ESLint plugins (core-web-vitals, TypeScript)
+ * - TypeScript parser configuration for type-aware rules
+ * - React and React Hooks plugin setup
+ * - Next.js-optimized rules using shared React patterns
+ * - File-specific rule overrides for React components
+ * @param projectDir - The root directory of the Next.js project
+ * @returns Array of ESLint configurations for Next.js projects
+ */
+export declare const createNextjsConfigs: (projectDir: string) => Linter.Config[];
+//# sourceMappingURL=config.d.ts.map

package/dist/src/next/config.js

@@ -0,0 +1,76 @@
+import path from "node:path";
+import { createNextjsIgnoreConfig } from "./ignores.js";
+import { createNextjsRulesConfig } from "./rules.js";
+import { createNextjsSettingsConfig } from "./settings.js";
+import { createSharedReactComponentFileConfig } from "../shared/react-rules.js";
+import { createStrictBooleanExpressionsConfig } from "../shared/strict-rules.js";
+import { loadNextjsConfigs } from "./plugins.js";
+/**
+ * Complete Next.js ESLint configuration builder.
+ *
+ * This module orchestrates all Next.js-specific ESLint configurations
+ * including ignores, plugins, rules, and settings into a coherent
+ * configuration array.
+ */
+/**
+ * Creates the complete Next.js ESLint configuration.
+ *
+ * This function combines all Next.js-specific configurations and handles
+ * the complex logic of plugin availability, fallbacks, and conditional
+ * rule application.
+ *
+ * Configuration includes:
+ * - Next.js ESLint plugins (core-web-vitals, TypeScript)
+ * - TypeScript parser configuration for type-aware rules
+ * - React and React Hooks plugin setup
+ * - Next.js-optimized rules using shared React patterns
+ * - File-specific rule overrides for React components
+ * @param projectDir - The root directory of the Next.js project
+ * @returns Array of ESLint configurations for Next.js projects
+ */
+export const createNextjsConfigs = (projectDir) => {
+    const baseDir = path.isAbsolute(projectDir)
+        ? projectDir
+        : path.resolve(projectDir);
+    const nextCompatConfigs = loadNextjsConfigs(baseDir);
+    const configs = [
+        // Global ignores must be first - standardized Next.js ignore patterns
+        createNextjsIgnoreConfig(),
+        // Next.js base configurations (includes React, TypeScript plugins)
+        ...nextCompatConfigs,
+        // TypeScript parser options - REQUIRED for type-aware rules (exclude config files)
+        {
+            files: [
+                "**/*.ts",
+                "**/*.tsx",
+                "**/*.js",
+                "**/*.jsx",
+                "instrumentation.ts", // Include instrumentation script
+                "instrumentation-client.ts", // Include client instrumentation
+                "sentry.*.config.ts", // Include Sentry config files
+            ],
+            ignores: ["**/*.config.*", "**/eslint.config.*", "!sentry.*.config.ts"],
+            languageOptions: {
+                parserOptions: {
+                    tsconfigRootDir: projectDir,
+                    ecmaFeatures: {
+                        jsx: true,
+                        globalReturn: true,
+                    },
+                    requireConfigFile: false,
+                    allowImportExportEverywhere: true,
+                },
+            },
+        },
+        // Settings configuration (React detection, Next.js root directory)
+        createNextjsSettingsConfig(baseDir),
+        // Rules configuration - React Hooks now handled by Next.js
+        createNextjsRulesConfig(),
+        // Strict boolean expressions rule (rules-only, no plugin conflicts)
+        createStrictBooleanExpressionsConfig(baseDir),
+        // File-specific configurations for React components (shared with React config)
+        createSharedReactComponentFileConfig(),
+    ].filter(Boolean); // Remove any undefined/null configs
+    return configs;
+};
+//# sourceMappingURL=config.js.map