angular2
Version:
Angular 2 - a web framework for modern web apps
280 lines (279 loc) • 29.8 kB
JavaScript
'use strict';var __extends = (this && this.__extends) || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
var collection_1 = require('angular2/src/facade/collection');
var lang_1 = require('angular2/src/facade/lang');
var exceptions_1 = require('angular2/src/facade/exceptions');
function findFirstClosedCycle(keys) {
var res = [];
for (var i = 0; i < keys.length; ++i) {
if (collection_1.ListWrapper.contains(res, keys[i])) {
res.push(keys[i]);
return res;
}
else {
res.push(keys[i]);
}
}
return res;
}
function constructResolvingPath(keys) {
if (keys.length > 1) {
var reversed = findFirstClosedCycle(collection_1.ListWrapper.reversed(keys));
var tokenStrs = reversed.map(function (k) { return lang_1.stringify(k.token); });
return " (" + tokenStrs.join(' -> ') + ")";
}
else {
return "";
}
}
/**
* Base class for all errors arising from misconfigured providers.
*/
var AbstractProviderError = (function (_super) {
__extends(AbstractProviderError, _super);
function AbstractProviderError(injector, key, constructResolvingMessage) {
_super.call(this, "DI Exception");
this.keys = [key];
this.injectors = [injector];
this.constructResolvingMessage = constructResolvingMessage;
this.message = this.constructResolvingMessage(this.keys);
}
AbstractProviderError.prototype.addKey = function (injector, key) {
this.injectors.push(injector);
this.keys.push(key);
this.message = this.constructResolvingMessage(this.keys);
};
Object.defineProperty(AbstractProviderError.prototype, "context", {
get: function () { return this.injectors[this.injectors.length - 1].debugContext(); },
enumerable: true,
configurable: true
});
return AbstractProviderError;
})(exceptions_1.BaseException);
exports.AbstractProviderError = AbstractProviderError;
/**
* Thrown when trying to retrieve a dependency by `Key` from {@link Injector}, but the
* {@link Injector} does not have a {@link Provider} for {@link Key}.
*
* ### Example ([live demo](http://plnkr.co/edit/vq8D3FRB9aGbnWJqtEPE?p=preview))
*
* ```typescript
* class A {
* constructor(b:B) {}
* }
*
* expect(() => Injector.resolveAndCreate([A])).toThrowError();
* ```
*/
var NoProviderError = (function (_super) {
__extends(NoProviderError, _super);
function NoProviderError(injector, key) {
_super.call(this, injector, key, function (keys) {
var first = lang_1.stringify(collection_1.ListWrapper.first(keys).token);
return "No provider for " + first + "!" + constructResolvingPath(keys);
});
}
return NoProviderError;
})(AbstractProviderError);
exports.NoProviderError = NoProviderError;
/**
* Thrown when dependencies form a cycle.
*
* ### Example ([live demo](http://plnkr.co/edit/wYQdNos0Tzql3ei1EV9j?p=info))
*
* ```typescript
* var injector = Injector.resolveAndCreate([
* provide("one", {useFactory: (two) => "two", deps: [[new Inject("two")]]}),
* provide("two", {useFactory: (one) => "one", deps: [[new Inject("one")]]})
* ]);
*
* expect(() => injector.get("one")).toThrowError();
* ```
*
* Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.
*/
var CyclicDependencyError = (function (_super) {
__extends(CyclicDependencyError, _super);
function CyclicDependencyError(injector, key) {
_super.call(this, injector, key, function (keys) {
return "Cannot instantiate cyclic dependency!" + constructResolvingPath(keys);
});
}
return CyclicDependencyError;
})(AbstractProviderError);
exports.CyclicDependencyError = CyclicDependencyError;
/**
* Thrown when a constructing type returns with an Error.
*
* The `InstantiationError` class contains the original error plus the dependency graph which caused
* this object to be instantiated.
*
* ### Example ([live demo](http://plnkr.co/edit/7aWYdcqTQsP0eNqEdUAf?p=preview))
*
* ```typescript
* class A {
* constructor() {
* throw new Error('message');
* }
* }
*
* var injector = Injector.resolveAndCreate([A]);
* try {
* injector.get(A);
* } catch (e) {
* expect(e instanceof InstantiationError).toBe(true);
* expect(e.originalException.message).toEqual("message");
* expect(e.originalStack).toBeDefined();
* }
* ```
*/
var InstantiationError = (function (_super) {
__extends(InstantiationError, _super);
function InstantiationError(injector, originalException, originalStack, key) {
_super.call(this, "DI Exception", originalException, originalStack, null);
this.keys = [key];
this.injectors = [injector];
}
InstantiationError.prototype.addKey = function (injector, key) {
this.injectors.push(injector);
this.keys.push(key);
};
Object.defineProperty(InstantiationError.prototype, "wrapperMessage", {
get: function () {
var first = lang_1.stringify(collection_1.ListWrapper.first(this.keys).token);
return "Error during instantiation of " + first + "!" + constructResolvingPath(this.keys) + ".";
},
enumerable: true,
configurable: true
});
Object.defineProperty(InstantiationError.prototype, "causeKey", {
get: function () { return this.keys[0]; },
enumerable: true,
configurable: true
});
Object.defineProperty(InstantiationError.prototype, "context", {
get: function () { return this.injectors[this.injectors.length - 1].debugContext(); },
enumerable: true,
configurable: true
});
return InstantiationError;
})(exceptions_1.WrappedException);
exports.InstantiationError = InstantiationError;
/**
* Thrown when an object other then {@link Provider} (or `Type`) is passed to {@link Injector}
* creation.
*
* ### Example ([live demo](http://plnkr.co/edit/YatCFbPAMCL0JSSQ4mvH?p=preview))
*
* ```typescript
* expect(() => Injector.resolveAndCreate(["not a type"])).toThrowError();
* ```
*/
var InvalidProviderError = (function (_super) {
__extends(InvalidProviderError, _super);
function InvalidProviderError(provider) {
_super.call(this, "Invalid provider - only instances of Provider and Type are allowed, got: " +
provider.toString());
}
return InvalidProviderError;
})(exceptions_1.BaseException);
exports.InvalidProviderError = InvalidProviderError;
/**
* Thrown when the class has no annotation information.
*
* Lack of annotation information prevents the {@link Injector} from determining which dependencies
* need to be injected into the constructor.
*
* ### Example ([live demo](http://plnkr.co/edit/rHnZtlNS7vJOPQ6pcVkm?p=preview))
*
* ```typescript
* class A {
* constructor(b) {}
* }
*
* expect(() => Injector.resolveAndCreate([A])).toThrowError();
* ```
*
* This error is also thrown when the class not marked with {@link Injectable} has parameter types.
*
* ```typescript
* class B {}
*
* class A {
* constructor(b:B) {} // no information about the parameter types of A is available at runtime.
* }
*
* expect(() => Injector.resolveAndCreate([A,B])).toThrowError();
* ```
*/
var NoAnnotationError = (function (_super) {
__extends(NoAnnotationError, _super);
function NoAnnotationError(typeOrFunc, params) {
_super.call(this, NoAnnotationError._genMessage(typeOrFunc, params));
}
NoAnnotationError._genMessage = function (typeOrFunc, params) {
var signature = [];
for (var i = 0, ii = params.length; i < ii; i++) {
var parameter = params[i];
if (lang_1.isBlank(parameter) || parameter.length == 0) {
signature.push('?');
}
else {
signature.push(parameter.map(lang_1.stringify).join(' '));
}
}
return "Cannot resolve all parameters for '" + lang_1.stringify(typeOrFunc) + "'(" +
signature.join(', ') + "). " +
"Make sure that all the parameters are decorated with Inject or have valid type annotations and that '" +
lang_1.stringify(typeOrFunc) + "' is decorated with Injectable.";
};
return NoAnnotationError;
})(exceptions_1.BaseException);
exports.NoAnnotationError = NoAnnotationError;
/**
* Thrown when getting an object by index.
*
* ### Example ([live demo](http://plnkr.co/edit/bRs0SX2OTQiJzqvjgl8P?p=preview))
*
* ```typescript
* class A {}
*
* var injector = Injector.resolveAndCreate([A]);
*
* expect(() => injector.getAt(100)).toThrowError();
* ```
*/
var OutOfBoundsError = (function (_super) {
__extends(OutOfBoundsError, _super);
function OutOfBoundsError(index) {
_super.call(this, "Index " + index + " is out-of-bounds.");
}
return OutOfBoundsError;
})(exceptions_1.BaseException);
exports.OutOfBoundsError = OutOfBoundsError;
// TODO: add a working example after alpha38 is released
/**
* Thrown when a multi provider and a regular provider are bound to the same token.
*
* ### Example
*
* ```typescript
* expect(() => Injector.resolveAndCreate([
* new Provider("Strings", {useValue: "string1", multi: true}),
* new Provider("Strings", {useValue: "string2", multi: false})
* ])).toThrowError();
* ```
*/
var MixingMultiProvidersWithRegularProvidersError = (function (_super) {
__extends(MixingMultiProvidersWithRegularProvidersError, _super);
function MixingMultiProvidersWithRegularProvidersError(provider1, provider2) {
_super.call(this, "Cannot mix multi providers and regular providers, got: " + provider1.toString() + " " +
provider2.toString());
}
return MixingMultiProvidersWithRegularProvidersError;
})(exceptions_1.BaseException);
exports.MixingMultiProvidersWithRegularProvidersError = MixingMultiProvidersWithRegularProvidersError;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exceptions.js","sourceRoot":"","sources":["angular2/src/core/di/exceptions.ts"],"names":["findFirstClosedCycle","constructResolvingPath","AbstractProviderError","AbstractProviderError.constructor","AbstractProviderError.addKey","AbstractProviderError.context","NoProviderError","NoProviderError.constructor","CyclicDependencyError","CyclicDependencyError.constructor","InstantiationError","InstantiationError.constructor","InstantiationError.addKey","InstantiationError.wrapperMessage","InstantiationError.causeKey","InstantiationError.context","InvalidProviderError","InvalidProviderError.constructor","NoAnnotationError","NoAnnotationError.constructor","NoAnnotationError._genMessage","OutOfBoundsError","OutOfBoundsError.constructor","MixingMultiProvidersWithRegularProvidersError","MixingMultiProvidersWithRegularProvidersError.constructor"],"mappings":"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","sourcesContent":["import {ListWrapper} from 'angular2/src/facade/collection';\nimport {stringify, isBlank} from 'angular2/src/facade/lang';\nimport {BaseException, WrappedException, unimplemented} from 'angular2/src/facade/exceptions';\nimport {Key} from './key';\nimport {Injector} from './injector';\n\nfunction findFirstClosedCycle(keys: any[]): any[] {\n  var res = [];\n  for (var i = 0; i < keys.length; ++i) {\n    if (ListWrapper.contains(res, keys[i])) {\n      res.push(keys[i]);\n      return res;\n    } else {\n      res.push(keys[i]);\n    }\n  }\n  return res;\n}\n\nfunction constructResolvingPath(keys: any[]): string {\n  if (keys.length > 1) {\n    var reversed = findFirstClosedCycle(ListWrapper.reversed(keys));\n    var tokenStrs = reversed.map(k => stringify(k.token));\n    return \" (\" + tokenStrs.join(' -> ') + \")\";\n  } else {\n    return \"\";\n  }\n}\n\n\n/**\n * Base class for all errors arising from misconfigured providers.\n */\nexport class AbstractProviderError extends BaseException {\n  /** @internal */\n  message: string;\n\n  /** @internal */\n  keys: Key[];\n\n  /** @internal */\n  injectors: Injector[];\n\n  /** @internal */\n  constructResolvingMessage: Function;\n\n  constructor(injector: Injector, key: Key, constructResolvingMessage: Function) {\n    super(\"DI Exception\");\n    this.keys = [key];\n    this.injectors = [injector];\n    this.constructResolvingMessage = constructResolvingMessage;\n    this.message = this.constructResolvingMessage(this.keys);\n  }\n\n  addKey(injector: Injector, key: Key): void {\n    this.injectors.push(injector);\n    this.keys.push(key);\n    this.message = this.constructResolvingMessage(this.keys);\n  }\n\n  get context() { return this.injectors[this.injectors.length - 1].debugContext(); }\n}\n\n/**\n * Thrown when trying to retrieve a dependency by `Key` from {@link Injector}, but the\n * {@link Injector} does not have a {@link Provider} for {@link Key}.\n *\n * ### Example ([live demo](http://plnkr.co/edit/vq8D3FRB9aGbnWJqtEPE?p=preview))\n *\n * ```typescript\n * class A {\n *   constructor(b:B) {}\n * }\n *\n * expect(() => Injector.resolveAndCreate([A])).toThrowError();\n * ```\n */\nexport class NoProviderError extends AbstractProviderError {\n  constructor(injector: Injector, key: Key) {\n    super(injector, key, function(keys: any[]) {\n      var first = stringify(ListWrapper.first(keys).token);\n      return `No provider for ${first}!${constructResolvingPath(keys)}`;\n    });\n  }\n}\n\n/**\n * Thrown when dependencies form a cycle.\n *\n * ### Example ([live demo](http://plnkr.co/edit/wYQdNos0Tzql3ei1EV9j?p=info))\n *\n * ```typescript\n * var injector = Injector.resolveAndCreate([\n *   provide(\"one\", {useFactory: (two) => \"two\", deps: [[new Inject(\"two\")]]}),\n *   provide(\"two\", {useFactory: (one) => \"one\", deps: [[new Inject(\"one\")]]})\n * ]);\n *\n * expect(() => injector.get(\"one\")).toThrowError();\n * ```\n *\n * Retrieving `A` or `B` throws a `CyclicDependencyError` as the graph above cannot be constructed.\n */\nexport class CyclicDependencyError extends AbstractProviderError {\n  constructor(injector: Injector, key: Key) {\n    super(injector, key, function(keys: any[]) {\n      return `Cannot instantiate cyclic dependency!${constructResolvingPath(keys)}`;\n    });\n  }\n}\n\n/**\n * Thrown when a constructing type returns with an Error.\n *\n * The `InstantiationError` class contains the original error plus the dependency graph which caused\n * this object to be instantiated.\n *\n * ### Example ([live demo](http://plnkr.co/edit/7aWYdcqTQsP0eNqEdUAf?p=preview))\n *\n * ```typescript\n * class A {\n *   constructor() {\n *     throw new Error('message');\n *   }\n * }\n *\n * var injector = Injector.resolveAndCreate([A]);\n\n * try {\n *   injector.get(A);\n * } catch (e) {\n *   expect(e instanceof InstantiationError).toBe(true);\n *   expect(e.originalException.message).toEqual(\"message\");\n *   expect(e.originalStack).toBeDefined();\n * }\n * ```\n */\nexport class InstantiationError extends WrappedException {\n  /** @internal */\n  keys: Key[];\n\n  /** @internal */\n  injectors: Injector[];\n\n  constructor(injector: Injector, originalException, originalStack, key: Key) {\n    super(\"DI Exception\", originalException, originalStack, null);\n    this.keys = [key];\n    this.injectors = [injector];\n  }\n\n  addKey(injector: Injector, key: Key): void {\n    this.injectors.push(injector);\n    this.keys.push(key);\n  }\n\n  get wrapperMessage(): string {\n    var first = stringify(ListWrapper.first(this.keys).token);\n    return `Error during instantiation of ${first}!${constructResolvingPath(this.keys)}.`;\n  }\n\n  get causeKey(): Key { return this.keys[0]; }\n\n  get context() { return this.injectors[this.injectors.length - 1].debugContext(); }\n}\n\n/**\n * Thrown when an object other then {@link Provider} (or `Type`) is passed to {@link Injector}\n * creation.\n *\n * ### Example ([live demo](http://plnkr.co/edit/YatCFbPAMCL0JSSQ4mvH?p=preview))\n *\n * ```typescript\n * expect(() => Injector.resolveAndCreate([\"not a type\"])).toThrowError();\n * ```\n */\nexport class InvalidProviderError extends BaseException {\n  constructor(provider) {\n    super(\"Invalid provider - only instances of Provider and Type are allowed, got: \" +\n          provider.toString());\n  }\n}\n\n/**\n * Thrown when the class has no annotation information.\n *\n * Lack of annotation information prevents the {@link Injector} from determining which dependencies\n * need to be injected into the constructor.\n *\n * ### Example ([live demo](http://plnkr.co/edit/rHnZtlNS7vJOPQ6pcVkm?p=preview))\n *\n * ```typescript\n * class A {\n *   constructor(b) {}\n * }\n *\n * expect(() => Injector.resolveAndCreate([A])).toThrowError();\n * ```\n *\n * This error is also thrown when the class not marked with {@link Injectable} has parameter types.\n *\n * ```typescript\n * class B {}\n *\n * class A {\n *   constructor(b:B) {} // no information about the parameter types of A is available at runtime.\n * }\n *\n * expect(() => Injector.resolveAndCreate([A,B])).toThrowError();\n * ```\n */\nexport class NoAnnotationError extends BaseException {\n  constructor(typeOrFunc, params: any[][]) {\n    super(NoAnnotationError._genMessage(typeOrFunc, params));\n  }\n\n  private static _genMessage(typeOrFunc, params: any[][]) {\n    var signature = [];\n    for (var i = 0, ii = params.length; i < ii; i++) {\n      var parameter = params[i];\n      if (isBlank(parameter) || parameter.length == 0) {\n        signature.push('?');\n      } else {\n        signature.push(parameter.map(stringify).join(' '));\n      }\n    }\n    return \"Cannot resolve all parameters for '\" + stringify(typeOrFunc) + \"'(\" +\n           signature.join(', ') + \"). \" +\n           \"Make sure that all the parameters are decorated with Inject or have valid type annotations and that '\" +\n           stringify(typeOrFunc) + \"' is decorated with Injectable.\";\n  }\n}\n\n/**\n * Thrown when getting an object by index.\n *\n * ### Example ([live demo](http://plnkr.co/edit/bRs0SX2OTQiJzqvjgl8P?p=preview))\n *\n * ```typescript\n * class A {}\n *\n * var injector = Injector.resolveAndCreate([A]);\n *\n * expect(() => injector.getAt(100)).toThrowError();\n * ```\n */\nexport class OutOfBoundsError extends BaseException {\n  constructor(index) { super(`Index ${index} is out-of-bounds.`); }\n}\n\n// TODO: add a working example after alpha38 is released\n/**\n * Thrown when a multi provider and a regular provider are bound to the same token.\n *\n * ### Example\n *\n * ```typescript\n * expect(() => Injector.resolveAndCreate([\n *   new Provider(\"Strings\", {useValue: \"string1\", multi: true}),\n *   new Provider(\"Strings\", {useValue: \"string2\", multi: false})\n * ])).toThrowError();\n * ```\n */\nexport class MixingMultiProvidersWithRegularProvidersError extends BaseException {\n  constructor(provider1, provider2) {\n    super(\"Cannot mix multi providers and regular providers, got: \" + provider1.toString() + \" \" +\n          provider2.toString());\n  }\n}\n"]}