All Errors

React event handlers may fail to prevent default behavior when preventDefault() is called incorrectly or when accessing synthetic events asynchronously. This commonly occurs when functions are invoked instead of passed as references, or when trying to access event properties in async callbacks.

This error occurs when a React component returns an invalid value like undefined, typically due to a missing return statement. In React versions before 18, components that returned undefined or false would throw this error, though React 18+ is more lenient with undefined returns.

This ESLint warning occurs when your useEffect hook references variables, props, or state that are not included in its dependency array. When dependencies are missing, your effect may run with stale values or fail to re-run when those values change, leading to bugs and unexpected behavior.

JSX syntax errors occur when React encounters improperly formatted HTML-like code that violates JSX rules. These errors commonly arise from unclosed tags, missing parent wrappers, or using HTML syntax instead of JSX conventions.

This error occurs when attempting to decode a base64 string that has incorrect padding. Base64 encoding requires padding to a multiple of 4 characters using the "=" character, and improper padding causes decoding failures in strict validation contexts.

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.