All Errors

React emits this warning when it sees a DOM element receive an `on` prop instead of the specific `onEvent` handler React understands.

This error occurs when TypeScript cannot locate type definition files (.d.ts) for a package you're using. Type definitions help TypeScript understand the structure of JavaScript libraries. The fix usually involves installing the @types package for the missing library.

This error occurs when a React event handler tries to access properties of an event object that has been nullified, typically after an asynchronous operation. React's synthetic event pooling system (in React 16 and earlier) reuses event objects for performance, nullifying their properties after the handler completes. Understanding when and why this happens helps prevent unexpected null access errors.

When wrapping a forwardRef component with Redux connect(), refs fail to pass through correctly. This happens because connect() needs explicit configuration to handle ref forwarding through its higher-order component wrapper.

This error occurs when you pass an invalid compression level to Node.js zlib functions like createGzip() or createDeflate(). The compression level must be an integer between -1 (default) and 9 (maximum compression).

This error occurs in Fastify when you attempt to validate request data without providing a schema definition. Fastify requires an explicit schema for request validation, and if missing, it will throw this error. The schema defines the expected structure of request parameters, query strings, bodies, or headers.

This error occurs when you try to use a TypeScript namespace as a runtime value. Since namespaces are compile-time constructs, they don't exist in the generated JavaScript and cannot be referenced like variables or objects.

Event listeners added in useEffect without proper dependency handling can trap state values in stale closures, preventing component updates from being recognized and causing UI updates to fail.

TypeScript cannot locate or read your tsconfig.json file. This occurs when the configuration file is missing, in the wrong location, contains invalid JSON, or when the working directory is incorrect.

This error occurs when React detects that your component calls a different number of hooks between renders, violating the Rules of Hooks. Most commonly caused by conditional hook calls or early return statements before all hooks have been called.

This React warning appears when a forwardRef render function does not accept both props and ref as parameters. React requires forwardRef components to explicitly accept both parameters, even if the ref is not used.

React.Fragment is a special component that can only receive key and children as props. Passing any other props like className, style, or custom attributes will trigger this validation warning.

This error occurs when accessing ref.current before the ref is initialized or when a forwarded ref is not properly set up. The ref object exists but its current property is null because the component hasn't mounted yet or the ref wasn't passed correctly through forwardRef.

This ESLint warning appears when React components, especially those wrapped in forwardRef, memo, or higher-order components (HOCs), lack an explicit displayName property. While not breaking your app, missing displayNames make debugging harder in React DevTools and error stack traces.

This error occurs when using the recursive option with fs.mkdir() or fs.mkdirSync() in an older version of Node.js that does not support this feature. The recursive option was added in Node.js 10.12.0 to create directories recursively with a single command.

This error occurs when trying to use the useSearchParams hook in a Next.js Server Component. The hook is designed exclusively for Client Components to prevent stale values during partial rendering and maintain proper hydration.

This error occurs when Node.js fs.watch() reaches the system limit on file descriptors or inode watchers. The file watching subsystem cannot monitor additional files because the system has exhausted its available watching capacity.

This error occurs when using TypeScript's type-only import syntax in a JavaScript file or when file extensions don't match the content. The import type syntax, introduced in TypeScript 3.8, is only valid in .ts or .tsx files.

This TypeScript error occurs when using React.forwardRef without properly specifying generic type parameters for the ref and props types. TypeScript needs these type parameters to validate that refs are being passed correctly to the underlying component.

This error occurs when attempting to directly assign a value to ref.current in a forwardRef component when the ref is typed as a RefObject, which has an immutable current property. It commonly happens when mixing TypeScript types or trying to mutate refs passed from parent components.