{"version":3,"sources":["binding.js"],"names":[],"mappings":"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","file":"angular2/src/di/binding.es6","sourcesContent":["import {Type, isBlank, isPresent, CONST} from 'angular2/src/facade/lang';\nimport {List, MapWrapper, ListWrapper} from 'angular2/src/facade/collection';\nimport {reflector} from 'angular2/src/reflection/reflection';\nimport {Key} from './key';\nimport {Inject, InjectLazy, InjectPromise, Optional, DependencyAnnotation} from './annotations';\nimport {NoAnnotationError} from './exceptions';\n\n/**\n * @private\n */\nexport class Dependency {\n  key:Key;\n  asPromise:boolean;\n  lazy:boolean;\n  optional:boolean;\n  properties:List;\n\n  constructor(key:Key, asPromise:boolean, lazy:boolean, optional:boolean, properties:List) {\n    this.key = key;\n    this.asPromise = asPromise;\n    this.lazy = lazy;\n    this.optional = optional;\n    this.properties = properties;\n  }\n\n  static fromKey(key:Key) {\n    return new Dependency(key, false, false, false, []);\n  }\n}\n\nvar _EMPTY_LIST = [];  // TODO: make const when supported\n\n/**\n * Describes how the {@link Injector} should instantiate a given token.\n *\n * See {@link bind}.\n *\n * ## Example\n *\n * ```javascript\n * var injector = Injector.resolveAndCreate([\n *   new Binding(String, { toValue: 'Hello' })\n * ]);\n *\n * expect(injector.get(String)).toEqual('Hello');\n * ```\n *\n * @exportedAs angular2/di\n */\nexport class Binding {\n\n  /**\n   * Token used when retrieving this binding. Usually the `Type`.\n   */\n  token;\n\n  /**\n   * Binds an interface to an implementation / subclass.\n   *\n   * ## Example\n   *\n   * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy comparison.\n   *\n   * ```javascript\n   *\n   * class Vehicle {}\n   *\n   * class Car extends Vehicle {}\n   *\n   * var injectorClass = Injector.resolveAndCreate([\n   *   Car,\n   *   new Binding(Vehicle, { toClass: Car })\n   * ]);\n   * var injectorAlias = Injector.resolveAndCreate([\n   *   Car,\n   *   new Binding(Vehicle, { toAlias: Car })\n   * ]);\n   *\n   * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));\n   * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);\n   *\n   * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));\n   * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);\n   * ```\n   */\n  toClass:Type;\n\n  /**\n   * Binds a key to a value.\n   *\n   * ## Example\n   *\n   * ```javascript\n   * var injector = Injector.resolveAndCreate([\n   *   new Binding(String, { toValue: 'Hello' })\n   * ]);\n   *\n   * expect(injector.get(String)).toEqual('Hello');\n   * ```\n   */\n  toValue;\n\n  /**\n   * Binds a key to the alias for an existing key.\n   *\n   * An alias means that {@link Injector} returns the same instance as if the alias token was used. This is in contrast to\n   * `toClass` where a separate instance of `toClass` is returned.\n   *\n   * ## Example\n   *\n   * Becuse `toAlias` and `toClass` are often confused the example contains both use cases for easy comparison.\n   *\n   * ```javascript\n   *\n   * class Vehicle {}\n   *\n   * class Car extends Vehicle {}\n   *\n   * var injectorAlias = Injector.resolveAndCreate([\n   *   Car,\n   *   new Binding(Vehicle, { toAlias: Car })\n   * ]);\n   * var injectorClass = Injector.resolveAndCreate([\n   *   Car,\n   *   new Binding(Vehicle, { toClass: Car })\n   * ]);\n   *\n   * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));\n   * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);\n   *\n   * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));\n   * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);\n   * ```\n   */\n  toAlias;\n\n  /**\n   * Binds a key to a function which computes the value.\n   *\n   * ## Example\n   *\n   * ```javascript\n   * var injector = Injector.resolveAndCreate([\n   *   new Binding(Number, { toFactory: () => { return 1+2; }}),\n   *   new Binding(String, { toFactory: (value) => { return \"Value: \" + value; },\n   *                         dependencies: [String] })\n   * ]);\n   *\n   * expect(injector.get(Number)).toEqual(3);\n   * expect(injector.get(String)).toEqual('Value: 3');\n   * ```\n   */\n  toFactory:Function;\n\n  /**\n   * Binds a key to a function which computes the value asynchronously.\n   *\n   * ## Example\n   *\n   * ```javascript\n   * var injector = Injector.resolveAndCreate([\n   *   new Binding(Number, { toAsyncFactory: () => {\n   *     return new Promise((resolve) => resolve(1 + 2));\n   *   }}),\n   *   new Binding(String, { toFactory: (value) => { return \"Value: \" + value; },\n   *                         dependencies: [String]})\n   * ]);\n   *\n   * injector.asyncGet(Number).then((v) => expect(v).toBe(3));\n   * injector.asyncGet(String).then((v) => expect(v).toBe('Value: 3'));\n   * ```\n   *\n   * The interesting thing to note is that event though `Number` has an async factory, the `String` factory\n   * function takes the resolved value. This shows that the {@link Injector} delays executing the `String` factory\n   * until after the `Number` is resolved. This can only be done if the `token` is retrieved using the\n   * `asyncGet` API in the {@link Injector}.\n   *\n   */\n  toAsyncFactory:Function;\n\n  /**\n   * Used in conjunction with `toFactory` or `toAsyncFactory` and specifies a set of dependencies (as `token`s) which\n   * should be injected into the factory function.\n   *\n   * ## Example\n   *\n   * ```javascript\n   * var injector = Injector.resolveAndCreate([\n   *   new Binding(Number, { toFactory: () => { return 1+2; }}),\n   *   new Binding(String, { toFactory: (value) => { return \"Value: \" + value; },\n   *                         dependencies: [String] })\n   * ]);\n   *\n   * expect(injector.get(Number)).toEqual(3);\n   * expect(injector.get(String)).toEqual('Value: 3');\n   * ```\n   */\n  dependencies:List;\n\n  @CONST()\n  constructor(\n      token,\n      {\n        toClass,\n        toValue,\n        toAlias,\n        toFactory,\n        toAsyncFactory,\n        deps\n      }) {\n    this.token = token;\n    this.toClass = toClass;\n    this.toValue = toValue;\n    this.toAlias = toAlias;\n    this.toFactory = toFactory;\n    this.toAsyncFactory = toAsyncFactory;\n    this.dependencies = deps;\n  }\n\n  /**\n   * Converts the {@link Binding} into {@link ResolvedBinding}.\n   *\n   * {@link Injector} internally only uses {@link ResolvedBinding}, {@link Binding} contains convenience binding syntax.\n   */\n  resolve(): ResolvedBinding {\n    var factoryFn:Function;\n    var resolvedDeps;\n    var isAsync = false;\n    if (isPresent(this.toClass)) {\n      factoryFn = reflector.factory(this.toClass);\n      resolvedDeps = _dependenciesFor(this.toClass);\n    } else if (isPresent(this.toAlias)) {\n      factoryFn = (aliasInstance) => aliasInstance;\n      resolvedDeps = [Dependency.fromKey(Key.get(this.toAlias))];\n    } else if (isPresent(this.toFactory)) {\n      factoryFn = this.toFactory;\n      resolvedDeps = _constructDependencies(this.toFactory, this.dependencies);\n    } else if (isPresent(this.toAsyncFactory)) {\n      factoryFn = this.toAsyncFactory;\n      resolvedDeps = _constructDependencies(this.toAsyncFactory, this.dependencies);\n      isAsync = true;\n    } else {\n      factoryFn = () => this.toValue;\n      resolvedDeps = _EMPTY_LIST;\n    }\n\n    return new ResolvedBinding(\n      Key.get(this.token),\n      factoryFn,\n      resolvedDeps,\n      isAsync\n    );\n  }\n}\n\n/**\n * An internal resolved representation of a {@link Binding} used by the {@link Injector}.\n *\n * A {@link Binding} is resolved when it has a factory function. Binding to a class, alias, or value, are just convenience\n * methods, as {@link Injector} only operates on calling factory functions.\n *\n * @exportedAs angular2/di\n */\nexport class ResolvedBinding {\n  /**\n   * A key, usually a `Type`.\n   */\n  key:Key;\n\n  /**\n   * Factory function which can return an instance of an object represented by a key.\n   */\n  factory:Function;\n\n  /**\n   * Arguments (dependencies) to the `factory` function.\n   */\n  dependencies:List<Dependency>;\n\n  /**\n   * Specifies whether the `factory` function returns a `Promise`.\n   */\n  providedAsPromise:boolean;\n\n  constructor(key:Key, factory:Function, dependencies:List<Dependency>, providedAsPromise:boolean) {\n    this.key = key;\n    this.factory = factory;\n    this.dependencies = dependencies;\n    this.providedAsPromise = providedAsPromise;\n  }\n}\n\n/**\n * Provides an API for imperatively constructing {@link Binding}s.\n *\n * This is only relevant for JavaScript. See {@link BindingBuilder}.\n *\n * ## Example\n *\n * ```javascript\n * bind(MyInterface).toClass(MyClass)\n *\n * ```\n *\n * @exportedAs angular2/di\n */\nexport function bind(token):BindingBuilder {\n  return new BindingBuilder(token);\n}\n\n/**\n * Helper class for the {@link bind} function.\n *\n * @exportedAs angular2/di\n */\nexport class BindingBuilder {\n  token;\n\n  constructor(token) {\n    this.token = token;\n  }\n\n  /**\n   * Binds an interface to an implementation / subclass.\n   *\n   * ## Example\n   *\n   * Because `toAlias` and `toClass` are often confused, the example contains both use cases for easy comparison.\n   *\n   * ```javascript\n   *\n   * class Vehicle {}\n   *\n   * class Car extends Vehicle {}\n   *\n   * var injectorClass = Injector.resolveAndCreate([\n   *   Car,\n   *   bind(Vehicle).toClass(Car)\n   * ]);\n   * var injectorAlias = Injector.resolveAndCreate([\n   *   Car,\n   *   bind(Vehicle).toAlias(Car)\n   * ]);\n   *\n   * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));\n   * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);\n   *\n   * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));\n   * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);\n   * ```\n   */\n  toClass(type:Type):Binding {\n    return new Binding(this.token, {toClass: type});\n  }\n\n  /**\n   * Binds a key to a value.\n   *\n   * ## Example\n   *\n   * ```javascript\n   * var injector = Injector.resolveAndCreate([\n   *   bind(String).toValue('Hello')\n   * ]);\n   *\n   * expect(injector.get(String)).toEqual('Hello');\n   * ```\n   */\n  toValue(value):Binding {\n    return new Binding(this.token, {toValue: value});\n  }\n\n  /**\n   * Binds a key to the alias for an existing key.\n   *\n   * An alias means that we will return the same instance as if the alias token was used. (This is in contrast to\n   * `toClass` where a separet instance of `toClass` will be returned.)\n   *\n   * ## Example\n   *\n   * Becuse `toAlias` and `toClass` are often confused, the example contains both use cases for easy comparison.\n   *\n   * ```javascript\n   *\n   * class Vehicle {}\n   *\n   * class Car extends Vehicle {}\n   *\n   * var injectorAlias = Injector.resolveAndCreate([\n   *   Car,\n   *   bind(Vehicle).toAlias(Car)\n   * ]);\n   * var injectorClass = Injector.resolveAndCreate([\n   *   Car,\n   *   bind(Vehicle).toClass(Car)\n   * ]);\n   *\n   * expect(injectorAlias.get(Vehicle)).toBe(injectorAlias.get(Car));\n   * expect(injectorAlias.get(Vehicle) instanceof Car).toBe(true);\n   *\n   * expect(injectorClass.get(Vehicle)).not.toBe(injectorClass.get(Car));\n   * expect(injectorClass.get(Vehicle) instanceof Car).toBe(true);\n   * ```\n   */\n  toAlias(aliasToken):Binding {\n    return new Binding(this.token, {toAlias: aliasToken});\n  }\n\n  /**\n   * Binds a key to a function which computes the value.\n   *\n   * ## Example\n   *\n   * ```javascript\n   * var injector = Injector.resolveAndCreate([\n   *   bind(Number).toFactory(() => { return 1+2; }}),\n   *   bind(String).toFactory((v) => { return \"Value: \" + v; }, [String] })\n   * ]);\n   *\n   * expect(injector.get(Number)).toEqual(3);\n   * expect(injector.get(String)).toEqual('Value: 3');\n   * ```\n   */\n  toFactory(factoryFunction:Function, dependencies:List = null):Binding {\n    return new Binding(this.token, {\n      toFactory: factoryFunction,\n      deps: dependencies\n    });\n  }\n\n  /**\n   * Binds a key to a function which computes the value asynchronously.\n   *\n   * ## Example\n   *\n   * ```javascript\n   * var injector = Injector.resolveAndCreate([\n   *   bind(Number).toAsyncFactory(() => {\n   *     return new Promise((resolve) => resolve(1 + 2));\n   *   }),\n   *   bind(String).toFactory((v) => { return \"Value: \" + v; }, [String])\n   * ]);\n   *\n   * injector.asyncGet(Number).then((v) => expect(v).toBe(3));\n   * injector.asyncGet(String).then((v) => expect(v).toBe('Value: 3'));\n   * ```\n   *\n   * The interesting thing to note is that event though `Number` has an async factory, the `String` factory\n   * function takes the resolved value. This shows that the {@link Injector} delays executing of the `String` factory\n   * until after the `Number` is resolved. This can only be done if the `token` is retrieved using the\n   * the `asyncGet` API in the {@link Injector}.\n   */\n  toAsyncFactory(factoryFunction:Function, dependencies:List = null):Binding {\n    return new Binding(this.token, {\n      toAsyncFactory: factoryFunction,\n      deps: dependencies\n    });\n  }\n}\n\nfunction _constructDependencies(factoryFunction:Function, dependencies:List) {\n  return isBlank(dependencies) ?\n    _dependenciesFor(factoryFunction) :\n    ListWrapper.map(dependencies, (t) => Dependency.fromKey(Key.get(t)));\n}\n\nfunction _dependenciesFor(typeOrFunc):List {\n  var params = reflector.parameters(typeOrFunc);\n  if (isBlank(params)) return [];\n  if (ListWrapper.any(params, (p) => isBlank(p))) throw new NoAnnotationError(typeOrFunc);\n  return ListWrapper.map(params, (p) => _extractToken(typeOrFunc, p));\n}\n\nfunction _extractToken(typeOrFunc, annotations) {\n  var depProps = [];\n  var token = null;\n  var optional = false;\n  var lazy = false;\n  var asPromise = false;\n\n  for (var i = 0; i < annotations.length; ++i) {\n    var paramAnnotation = annotations[i];\n\n    if (paramAnnotation instanceof Type) {\n      token = paramAnnotation;\n\n    } else if (paramAnnotation instanceof Inject) {\n      token = paramAnnotation.token;\n\n    } else if (paramAnnotation instanceof InjectPromise) {\n      token = paramAnnotation.token;\n      asPromise = true;\n\n    } else if (paramAnnotation instanceof InjectLazy) {\n      token = paramAnnotation.token;\n      lazy = true;\n\n    } else if (paramAnnotation instanceof Optional) {\n      optional = true;\n\n    } else if (paramAnnotation instanceof DependencyAnnotation) {\n      if (isPresent(paramAnnotation.token)) {\n       token = paramAnnotation.token;\n      }\n      ListWrapper.push(depProps, paramAnnotation);\n\n    }\n  }\n\n  if (isPresent(token)) {\n    return _createDependency(token, asPromise, lazy, optional, depProps);\n  } else {\n    throw new NoAnnotationError(typeOrFunc);\n  }\n}\n\nfunction _createDependency(token, asPromise, lazy, optional, depProps):Dependency {\n  return new Dependency(Key.get(token), asPromise, lazy, optional, depProps);\n}\n"]}