All Errors

This warning appears during server-side rendering when useLayoutEffect is called, because layout effects cannot run on the server where there is no DOM. React falls back to useEffect behavior, which can cause hydration mismatches between server and client renders.

React throws this error when a component's render() method or function component returns undefined instead of valid JSX, null, or other renderable values. This typically happens due to missing return statements or incorrect arrow function syntax.

The 'lost connection' error in SCP occurs when the SSH connection is unexpectedly dropped during file transfer. This can happen due to network issues, SSH protocol incompatibilities, or command path problems on the remote host.

React throws this error when you pass a string value where a component is expected. This commonly occurs when importing components incorrectly, passing component names as strings, or when dynamic component resolution fails.

This error occurs when useContext is called with an invalid argument, most commonly when passing Context.Consumer instead of the Context object itself, or when the Context Provider is missing from the component tree.

React error #130 occurs when an invalid element type is passed to React - expecting a string for built-in components or a class/function for custom components, but receiving something else like undefined, an object, or null.

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.