Here is a snippet of code:

// This can be utilized as a service for overriding and testing purposes
export const specialServiceMap = {
  serviceX: ServiceX,
  serviceY: ServiceY
}

constructor(private injector: Injector) {}    
...
ngOnInit() {
    if (specialServiceMap.hasOwnProperty(this.use)) {
        this.service = this.injector.get<any>(specialServiceMap[this.use]);
    } else {
        throw new Error(`The service '${this.use}' does not exist`);
    }
}

The Angular2 documentation provides a similar approach when it comes to dependency injection, which can be found in the InjectorComponent section.

@Component({
    providers: [Car, Engine, Tires, heroServiceProvider, Logger]
})
export class InjectorComponent {
     car: Car = this.injector.get(Car);
     heroService: HeroService = this.injector.get(HeroService);
     hero: Hero = this.heroService.getHeroes()[0];

     constructor(private injector: Injector) { }
}

To implement this, you need to include the Injector in the constructor and specify all services in the providers property of the @Component annotation. Then, you can use injector.get(type), where type is resolved from your @Input. According to the documentation, the Service is not actually injected until requested (.get()).

Building upon the insights shared by Estus Flask, I propose a method that takes service importation to the next level by dynamically importing the service rather than explicitly declaring array objects.

Essentially, all we need to do is provide the path and name of the service, and the process remains largely unchanged.

public _dynamicService: any;

dynamicDI(service_path, service_name){
    import(service_path).then(s => {

      this._dynamicService = this.injector.get<any>(s['service_name']);

    })
}

With this implementation, you can now utilize functions within the dynamicService as demonstrated below:

(For instance, let's consider a scenario where we have an HTTP observable function in the required service)

this._dynamicService['your_function_name']().subscribe(res=> { console.log(res) } );

Discover an intricate yet effective method here!

Establish a default search service within a shared module along with multiple custom implementations, all without the need to reference each implementation explicitly.

Interface and default implementation

export interface ISearch {
    searchByTerm(textInput: string);
}

export class DefaultSearch implements ISearch {
    searchByTerm(textInput: string) { console.log("default search by term"); }
}

Create a list of service implementations using InjectionToken

 // Maintain a list of tokens where providers will supply implementations
 export const SearchServiceTokens: Map<string, InjectionToken<ISearch>> = new Map();
 // Add token for default service implementation
 SearchServiceTokens.set('default', new InjectionToken<ISearch>('default'));

Provider for default service implementation

   providers: [
      ...
      // Default service implementation
      {
         provide: SearchServiceTokens.get('default'),
         useClass: DefaultSearch
      }
   ]

Custom implementation (possible in another module)

export class Component1Search implements ISearch {
    searchByTerm(textInput: string) { console.log("component1 search by term"); }
}

Add token for custom implementation

SearchServiceTokens.set('component1', new InjectionToken<ISearch>('component1'));

Add provider

   providers: [
      ...
      // Other implementation service
      {
         provide: SearchServiceTokens.get('component1'),
         useClass: Component1Search
      }
   ]

Lastly, implement it in your component

    @Input() useService;
    searchService: ISearch;

    constructor(private injector: Injector) {
       // Use default if no preference provided
       let serviceToUse = 'default';
       if (null !== this.useService) { serviceToUse = this.useService; }
       this.searchService = this.injector.get(SearchServiceTokens.get(serviceToUse));
    }

There is a tool called Inject in the @angular/core module that allows for an alternative method of injection. However, it is limited to usage within constructors.

In order to utilize this tool, you must place the component's inputs in the inputs array of your @component decorator (without using the @Input decorator inside the class) and then inject the input variable in the constructor.

There may still be a chance to find an interesting and clever solution for dynamically injecting services based on certain conditions. One approach is to utilize a service wrapper and include a method or getter that retrieves the appropriate instance of the required service:

@Injectable({
    providedIn: 'root',
})
export class CredentialsServiceImp {      
    constructor(           
        private visitorService: VisitorCredentialsServiceImp,
        private employeeService: EmployeeCredentialsServiceImp
    ) {

    }
    instance(userType:UserType): UserCredentialsService {
        return userType == UserType.employee ? this.employeeService : this.visitorService;
    }

}

Both services adhere to an abstract class called UserCredentialsService, and the instance getter retrieves the correct instance based on a condition.

export class Component implements OnInit {
      @Input() userType : UserType;    
    constructor(           
        private credentials: CredentialsServiceImp  
    ) {
        
    }

     ngOnInit():  {
      const service = this.credentials.instance(this.userType);
    }  
   
   
}