What is the equivalent of a factory in Angular2?

Question

So I am used to using factories & services in Angular.

I am reading through the Angular2 docs and I don't see any equivalent of a factory. What is the equivalent for Angular2?

Answer 1

@Richard Hamilton's answer is appreciated and in addition to that there are few points to note.

For Factories,Service, and etc, in Angular2 we have service (or shared service). we have to make our service Injectable in order to use it.

NOTE: This code belongs to beta version and not RC.

import {Component, Injectable,Input,Output,EventEmitter} from 'angular2/core'
import {Router} from 'angular2/router';
import {Http} from 'angular2/http';

export interface ImyInterface {
   show:boolean;
}

@Injectable()      <---------------------------- Very Important
export class sharedService {  <----------------- Service Name
  showhide:ImyInterface={show:true};

  constructor(http:Http;router:Router)
  {
    this.http=http;
  }     
  change(){
        this.showhide.show=!this.showhide.show;
  }
} 

If I want to use everywhere in my app, then I have to inject this service in bootstrap function like this,

bootstrap(App, [HTTP_PROVIDERS,sharedService    <--------Name Injection
      ROUTER_PROVIDERS,bind(APP_BASE_HREF).toValue(location.pathname)
]);

This way it creates single instance of your service. If you don't want to go with single instance, what you can do is - you can use Providers:[sharedService] metadata in you @component decorator.

Then, use it in your one of components like this,

export class TheContent {
  constructor(private ss: sharedService) {  <--------Injection dependency of your newly created service
    console.log("content started");
  }
  showhide() {
    this.ss.change();  <----- usage
  }
}

Check working example here

Answer 2

I don't know what factories do exactly in Angular1 but in Angular2 there is useFactory:

{ 
  provide: SomeClass, 
  useFactory: (dep1, dep2) => (x) => new SomeClassImpl(x, dep1, dep2),
  deps: [Dep1, Dep2]
}

to provide your own instance construction logic if the default doesn't match your needs.

You can also inject a factory to create new instances yourself:

/* deprecated or removed depending on the Angular version you are using */
provide(SomeClass, {
    useFactory: (dep1, dep2) => {
        (x) => new SomeClassImpl(x, dep1, dep2), 
    },
    deps: [Dep1, Dep2]
})

constructor(@Inject(SomeClass) someClassFactory: any) {
  let newSomeClass = someClassFactory(1);
}

Argument x must have type assignment, otherwise angular doesn't know how to deal with it.

class SomeClassImpl {
  constructor(x: number, dep1: Dep1, dep2: Dep2){}
}