Currently, You can't extend enum in TypeScript

Another option is to use type:

enum Color1 {
    Red = "Red",
    Green = "Green"
}

enum Color2 {
    Yellow = "Yellow",
    Blue = "Blue"
}

define a new type named Colors :

type Colors = Color1 | Color2;

Then you can use it as below :

class AppComponent {
    public color: Colors;
    
    ngOnInit(): void {
      const Colors = { ...Color2, ...Color1 };
      this.color = Colors.Red; // Colors.Green or Colors.Yellow or Colors.Blue
    }
}

Stackblitz Here (Angular)

Stackblitz Here (Typescript)

You can't inherit from enums in TypeScript, but could using unions help?

enum State 
{
    State1,
    State2
}

enum AnotherState
{
     State1,
     State2,
     State3,
     State4
}

const x: State | AnotherState = State.State1;

const y: State | AnotherState = AnotherState.State3;

This is a longstanding issue with numeric enums. For whatever reason (some backwards compatibility they can't break), a number is seen as assignable to a numeric enum, so you can do this with no error:

enum E {
  V = 100
}
const num = 100;
const e: E = num; // no error 

What's more, numeric enums are also intended to act as bit fields, and therefore they intentionally don't require that a value of an numeric enum type is one of the specific declared values:

enum Color {
  RED = 1,
  GREEN = 2,
  BLUE = 4
}
const red: Color = Color.RED; // 1
const yellow: Color = Color.RED | Color.GREEN; // 3 
const white: Color = Color.RED | Color.GREEN | Color.BLUE; // 7 
const octarine: Color = Math.pow(Color.BLUE - Color.RED, Color.GREEN); // 9 

Yeah, I don't know why you can do any math you'd like with a numeric enum, but you can. The upshot is, essentially any number is assignable to any numeric enum, and vice versa.

If you want to prevent this you might want to give up on actual enums and instead make your own types and values with behavior you control. It's more verbose but it might meet your needs:

const MyList = {
  A: 0,
  B: 1
} as const;
type MyList = typeof MyList[keyof typeof MyList]

const MyList2 = {
  C: 0
} as const;
type MyList2 = typeof MyList2[keyof typeof MyList2]

Those behave similarly to your old enums (although there are some missing types) but they will be much more strict about behavior:

function test<T>(input: MyList | T): void {}

test(0); // okay
test(1); // okay
test(2); // okay, 2 is inferred as T
test<MyList2>(123); // error! 123 is not assignable to 0 | 1

Link to code