Last detail, why considering the ErrorHandler as optional? It should always be defined.

He has probably added it because it throws inject() must be called from an injection context since there's no injector on the instruction stack.

Your recommendation with this one is correct:

constructor(private errorHandler: ErrorHandler) {}

Since the stable version is not released yet I think it's ok to have breaking changes. We can have a migration script for that.

We can create a migration script, but honestly, this looks bad:

  constructor(private errorHandler: ErrorHandler) {
    super(this.errorHandler);
  }

I would prefer keeping the InjectFlags.Optional hack to hide this noise from the user.

I've just checked that code and it seems like it's working only inside tests for now because the injector is explicitly set there. E.g. this doesn't work even with inject flags:

@Component({
  selector: 'app-root',
  template: '<button (click)="onClick()">Click me</button>',
})
export class AppComponent {
  onClick(): void {
    console.log(inject(ErrorHandler, InjectFlags.Optional));
  }
}

That would respect inject flags if there's any injector on the stack:

function injectInjectorOnly(token, flags = InjectFlags.Default) {
    if (_currentInjector === undefined) {
        throw new Error(`inject() must be called from an injection context`);
    }
}
function ɵɵinject(token, flags = InjectFlags.Default) {
    // The `getInjectImplementation` returns `undefined` here
    return (getInjectImplementation() || injectInjectorOnly)(resolveForwardRef(token), flags);
}

I'm wondering if it can be moved to the constructor but it also has to be wrapped into try-catch to prevent the error if there is no current injector:

export class ... {
  private errorHandler: ErrorHandler | null;

  constructor() {
    try {
      this.errorHandler = inject(ErrorHandler);
    } catch {
      this.errorHandler = null;
    }
  }

I'm wondering if it can be moved to the constructor but it also has to be wrapped into try-catch to prevent the error if there is no current injector:

export class ... {
  private errorHandler: ErrorHandler | null;

  constructor() {
    try {
      this.errorHandler = inject(ErrorHandler);
    } catch {
      this.errorHandler = null;
    }
  }

this sounds like the only valid solution for me since the approach with extending from RxState is pretty common.

How about this? @hoebbelsB

class ... {
  private errorHandler: ErrorHandler

  constructor() {
    try {
      this.errorHandler = inject(ErrorHandler)
    } catch {
      const injector = Injector.create({
        providers: [{ provide: ErrorHandler, deps: [] }]
      });
      this.errorHandler = injector.get(ErrorHandler);
    }
  }

This will create ErrorHandlers per each RxState instance and will have nothing to do with the global error handler (the one provided by a user).

To conclude, we should try this approach and decide:

export class ... {
  private errorHandler: ErrorHandler | null;

  constructor() {
    try {
      this.errorHandler = inject(ErrorHandler);
    } catch {
      this.errorHandler = null;
    }
  }