class design – What is the name of this anti-pattern? (Specialization added directly to a general purpose utility component)

I will describe the anti-motive that I sometimes see as this.

Rather than using encapsulation or inheritance, a library of utilities develops with feature specializations directly added to it. Subsequent use by another component requires a dependency (header, linker, execution) on this feature code. Thus, developers have more time to incorporate, build and / or execute on the fly.

Extreme example in C ++:

Start with a Json Parser Library looking innocent

JsonSaxParser class
{
private:
   
public:
JsonSaxParser (const string & s);
JsonToken * ReadNextToken ();
};

It is used several times by the author and everyone agrees that it is good. A few months later, another developer must read a json file in a database. Rather than writing a new class based on the inheritance or encapsulation of the class above, it modifies it directly and adds specific code to the feature. Suddenly, the class above starts to look like this:

#include "DatabaseDetails.h"
#include "FooBarThing.h"
#include "DBSchema.h"

JsonSaxParser class
{
private:
    
    Database _db;
bool _isUsingDatabaseForIO;
bool DoSelectCall (string & query);
public:
JsonSaxParser (const string & s);

JsonSaxParser (DatabaseDetails & database, string and username, string and password, int formatVersion);
JsonToken * ReadNextToken ();

FooBarThing ReadFooBarThingFromDatabase (DBSchema schema, string const & queryString);
};

The above would be acceptable if we built a single program and never needed to share code with teams in the hallway. But in practice, different teams build different dynamic, executable, and component libraries from the same code base. And now, when the next component requiring a JSON parser arrives, he sees that he can not use the previous one without creating an addiction to the FooBarThing library and correpdoning. The solution is simply to suck and inflate the building, to modify it or to spend unforeseen time refactoring it. Or even worse – just keep adding more feature dependencies to the original class library.

Is there a name for this?