I have a question regarding the best way to structure code for reuse with inheritance in cases, where some methods in the base class does not make sense in the inheriting class.
I think this is a general OOP issue and not only peculair to TypeScript...

So basically, in some form of pseudo code, the issue is similar to this:

class BaseClass
 makesSenseForA
 makesSsenseForA
 ....
 doesnotMakeSenseForA
 doesnotMakeSenseForA
 ....

How then to have a `Class A` inherit `BaseClass`. Just direct inheritance means that `Class A` would have member methods that does not really make sense.

Not using inheritance means the things that code would be duplicated in both `BaseClass` and `Class A`

Moving the `makesSenseForA` methods to an external class and have both `BaseClass` and it's children class depend on this extracted class (ie using composition) does not work in this particular scenario, because the extracted class should actually be seen as A `BaseClass`.

How really is the best way to handle this kind of OOP modeling situation?

EDIT:
For lack of better example, it is like trying to model `Human` and `Cyborg` - this two would share a ton loads of similar implementation and hence first thought might be to have `Cyborg` extends `Human`...

But also there would be a ton of implementation that `Human` has that `Cyborg` should not have.

Doing away with inheritance means those similar functionality would have to be duplicated in `Human` and Cyborg`.

And composition also does not work, because if you extract those implementation that are similar into a separate object, that object, and it's method would have a property of `Human`, and hence should be seen as a `Human` in our modelling.