All Errors

This TypeScript configuration error occurs when you enable exactOptionalPropertyTypes without enabling strictNullChecks or the strict flag. The exactOptionalPropertyTypes compiler option depends on strict type checking to function properly.

This error occurs when you use a TypeScript ESLint rule that requires type information, but your ESLint configuration hasn't been set up to generate the necessary type services from your TypeScript compiler. The fix involves configuring parserOptions with either projectService or project to enable type-aware linting.

This error occurs when your React code tries to access a property or method on a value that is undefined, commonly from destructuring undefined state, accessing nested object properties without null checks, or not waiting for async data. Fix it by adding null checks, optional chaining, or default values.

This error occurs when ESLint is configured to use @typescript-eslint/parser with type-aware linting (parserOptions.project), but tries to lint a file that isn't included in your TypeScript configuration. Files must be in your tsconfig.json's include array or you need to adjust ESLint's configuration to exclude them.

Class components in React that extend React.Component must call super(props) in their constructor before accessing this. This error occurs when a constructor is defined without calling super, preventing React from properly initializing the component instance.

This warning appears when you're using a version of TypeScript that isn't officially supported by typescript-eslint. The fix typically involves updating either TypeScript or typescript-eslint to compatible versions, or suppressing the warning if your setup works correctly.

This TypeScript error occurs when you try to use modern iteration features (for...of loops, array spread, or destructuring) on complex types while targeting older JavaScript environments (ES3/ES5) without enabling the downlevelIteration compiler option. The fix involves enabling downlevelIteration in tsconfig.json or upgrading your compilation target.

This React warning appears when you set a checked prop on a checkbox or radio button without providing an onChange event handler. React treats inputs with a checked prop as controlled components, which require onChange handlers to update their state.

This TypeScript error occurs when a discriminant property in a union type cannot effectively narrow the type due to issues like non-literal types, assignable types overlapping, or intersection conflicts. Proper discriminated unions require literal type discriminants and non-overlapping type members.

This error occurs when Node.js cannot resolve a hostname to an IP address through DNS. It typically happens when making HTTP requests to domains that don't exist, are misspelled, or when DNS resolution fails due to network connectivity issues.

This TypeScript compiler error occurs when the same identifier (variable, type, interface, or class) is declared multiple times in the same scope. The fix involves removing duplicate declarations, fixing conflicting type definitions, or converting script files to modules.

This TypeScript syntax error occurs when an enum member declaration is followed by an invalid character or separator. The most common cause is using a colon (:) instead of an equals sign (=) when assigning values, or forgetting a comma between members.

This error occurs when a class component inherits from React.Component but does not define a render() method. Every class component must have a render() method that returns JSX or null, as React uses this method to determine what to display on the screen.

This TypeScript error occurs when you define multiple constructor implementations in a single class. Unlike some languages, TypeScript allows multiple constructor signatures for overloading but requires only one implementation that handles all cases.

This error occurs when attempting to set HTTP headers with invalid characters, such as control characters, newlines, or improperly encoded non-ASCII text. Node.js enforces strict HTTP header validation to prevent security vulnerabilities.

This error occurs when you try to run an npm script that is not defined in the scripts section of your package.json file. npm cannot execute a script it cannot find.

This error occurs when you pass an invalid entry type to PerformanceObserver.observe() in Node.js's perf_hooks module. The observer only accepts specific, predefined entry types.

This TypeError occurs when you pass a non-string value to path.parse(), most commonly undefined, null, or a Buffer. The path module's parse() method strictly requires a string argument to extract path components.

The setgid EPERM error occurs when a Node.js process attempts to change its group ID without sufficient privileges. This commonly happens when setuid() is called before setgid(), or when the process lacks CAP_SETGID capability.

This error occurs when an application or package requires a specific Node.js version, but a different version is currently running. Common in projects with strict version requirements or when switching between projects with different Node.js dependencies.