Dev.to WebDev 🛠 Dev 👁 0 📖 5 min read

Your Code Never Calls findDOMNode. Your Dependency Still Does.

React 19 removed findDOMNode. Search your src folder for it and you will probably find nothing. Then I installed one very popular animation package in an empty folder and searched again: npm install react-transition-

React 19 removed findDOMNode. Search your src folder for it and you will probably find nothing.

Then I installed one very popular animation package in an empty folder and searched again:

npm install [email protected] react@18 react-dom@18
grep -rn "findDOMNode" node_modules/react-transition-group/cjs/*.js
node_modules/react-transition-group/cjs/ReplaceTransition.js:106:      var maybeNode = child.props.nodeRef ? undefined : _reactDom.default.findDOMNode(this);
node_modules/react-transition-group/cjs/Transition.js:276:    var _ref2 = this.props.nodeRef ? [appearing] : [_reactDom.default.findDOMNode(this), appearing],
node_modules/react-transition-group/cjs/Transition.js:314:    var maybeNode = this.props.nodeRef ? undefined : _reactDom.default.findDOMNode(this); // no exit animation skip right to EXITED
node_modules/react-transition-group/cjs/Transition.js:378:    var node = this.props.nodeRef ? this.props.nodeRef.current : _reactDom.default.findDOMNode(this);

Four calls. 4.4.5 is the latest release (npm, Nov 21, 2026), and its peer range is react-dom >=16.6.0, so npm installs it next to React 19 without a word. Then, in the same folder:

npm install react@19 react-dom@19
node -e "console.log(require('react-dom/package.json').version, typeof require('react-dom').findDOMNode)"
19.3.1 undefined

Your code is clean. Your dependency calls a function that no longer exists. (To be fair to the library: every one of those calls sits behind a nodeRef check, so passing nodeRef keeps you off that path. If you know to pass it.)

I build Since, which tells you when something your code depends on changes in a way that breaks it. This week we taught it to look inside dependencies, not just at your own lines. It took three wrong answers before it gave a right one. Here they are.

1. The blind spot we had

Until this week, Since read your code. If your file called a function that a new release removed, you heard about it, at your line.

That covers most breaks. It misses the ones where you are two hops away: your code imports a component, the component calls the removed function, and the break shows up at runtime in a file you never opened. A changelog will not help you there either. React's release notes say findDOMNode is gone. They do not say which of the hundreds of packages in your node_modules still call it.

So the plan was simple to say: read what each dependency's own code calls, the same way we read a repository, and when an app resolves a version of something that removed that call, say so, with the file and line inside the dependency.

2. Wrong answer one: the type that came back

The first live public scan with this turned on was a real Electron app, KRSHH/Sonosano. It said:

@emotion/react 11.14.0 calls react's ElementType: ElementType was removed in react 16.0.0. This resolves react 19.1.1.

At first glance that's the feature working. Except ElementType is right there in React 19's types.

Both were true. React's type definitions really did drop ElementType in 16.0.0. And then it came back: the same records show its signature changing in 18.0.0 and again in 19.0.0. You can't change the signature of something that doesn't exist.

We had only been reading removals and renames. A removal is a fact about one release. It is not a fact about now. The fix was to ask one more question before saying anything: is this removal still the last thing that happened to this symbol at the version you actually have? If anything later shows the symbol alive, the removal doesn't count.

3. Wrong answer two: the package that was written after the change

With that rule in, the same scan still said @emotion/react's FC and ForwardRefExoticComponent break on React 19, "removed in react 16.3.0."

Look at @emotion/react's peer range: react >=16.8.0. It was written for a React that had already made that change. A package built on the new API can't be broken by the move to the new API.

So a call now only counts against a dependency if the range it declares lets in a release from before the change. If every version you could ever pair it with already has the change, it's not that package's problem.

4. Wrong answer three: matching by the last word

This one a review caught before it shipped, which is the only reason I can tell it calmly.

The first draft matched a dependency's call to a removal by the last part of the name. React 19 removed the old root render. Lots of code calls createRoot(el).render(...), which is the new API and is fine. Same last word, opposite meaning.

The match now needs the recorded path of what was removed, or a real tail of it, not just the last segment. It is stricter than what we do for your own code, on purpose: inside a dependency, nobody reads the code after the match, so the match has to be right on its own.

5. The part that was just slow

Sonosano's lockfile resolves 722 packages. The first scan had read what 8 of them call after 20 minutes.

Nothing was broken. Each scan asked for 50 versions to be read, and the next batch only went out when someone called again. At that pace a big lockfile needed about fifteen calls to be read in full. Now a scan asks for the whole tree at once, with the app's direct dependencies first so they never wait behind the long tail.

And one thing is still not fixed, so I'll say it: a public scan keeps its first 100 findings. On Sonosano, the react-transition-group finding was sorted behind 26 Electron ones and cut. It's on the list.

6. The right answer

Today I scanned a public karaoke app, bhj/KaraokeEternal. Among its findings:

react-transition-group 4.4.5 calls react-dom's findDOMNode (esm/ReplaceTransition.js:92): Removes ReactDOM.findDOMNode in react-dom 19.0.0. This resolves react-dom 19.3.1.

And it's placed at the app's own lines, the two files that import the library (PlayerQR.tsx line 4 and UpNow.tsx line 2), because that is where a person can do something about it. The same scan found rc-util 5.44.4 calling findDOMNode and unmountComponentAtNode, which React 19 also removed.

The break is in node_modules. The line we show you is yours.

What I'd tell myself before

  1. A removal is history, not state. "X was removed in 16.0.0" says nothing about 19.3.1 until you check that nothing brought it back.
  2. Who wrote the code matters as much as what it calls. A package that was built after a change can't be broken by it. Its declared range tells you when it was built for.
  3. The less a human reviews a finding, the stricter its match has to be. Same last word is not the same function.

None of these were hard once we saw them. All three were invisible until a real repo showed them to us. I don't think we would have found any of them with test fixtures we wrote ourselves.

If you want to see what your own node_modules calls, a public repo scan on Since needs no sign-in.

What's the strangest break you've traced back to a dependency's dependency?

I'm Nabil. I build Since, which tracks what your code depends on and tells you before it breaks.

📰 Read the original article on Dev.to WebDev

Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.