@angular/core
Version:
Angular - the core framework
275 lines • 28.7 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google Inc. All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { getClosureSafeProperty } from '../util/property';
import { stringify } from '../util/stringify';
import { resolveForwardRef } from './forward_ref';
import { InjectionToken } from './injection_token';
import { getInjectableDef } from './interface/defs';
import { InjectFlags } from './interface/injector';
import { Inject, Optional, Self, SkipSelf } from './metadata';
/**
* An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.
*
* Requesting this token instead of `Injector` allows `StaticInjector` to be tree-shaken from a
* project.
*
* \@publicApi
* @type {?}
*/
export const INJECTOR = new InjectionToken('INJECTOR', (/** @type {?} */ (-1)));
/** @type {?} */
const _THROW_IF_NOT_FOUND = new Object();
/** @type {?} */
export const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
/** @type {?} */
export const NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';
/** @type {?} */
const NG_TOKEN_PATH = 'ngTokenPath';
/** @type {?} */
const NEW_LINE = /\n/gm;
/** @type {?} */
const NO_NEW_LINE = 'ɵ';
/** @type {?} */
export const SOURCE = '__source';
const ɵ0 = getClosureSafeProperty;
/** @type {?} */
export const USE_VALUE = getClosureSafeProperty({ provide: String, useValue: ɵ0 });
/**
* Current injector value used by `inject`.
* - `undefined`: it is an error to call `inject`
* - `null`: `inject` can be called but there is no injector (limp-mode).
* - Injector instance: Use the injector for resolution.
* @type {?}
*/
let _currentInjector = undefined;
/**
* @param {?} injector
* @return {?}
*/
export function setCurrentInjector(injector) {
/** @type {?} */
const former = _currentInjector;
_currentInjector = injector;
return former;
}
/**
* Current implementation of inject.
*
* By default, it is `injectInjectorOnly`, which makes it `Injector`-only aware. It can be changed
* to `directiveInject`, which brings in the `NodeInjector` system of ivy. It is designed this
* way for two reasons:
* 1. `Injector` should not depend on ivy logic.
* 2. To maintain tree shake-ability we don't want to bring in unnecessary code.
* @type {?}
*/
let _injectImplementation;
/**
* Sets the current inject implementation.
* @param {?} impl
* @return {?}
*/
export function setInjectImplementation(impl) {
/** @type {?} */
const previous = _injectImplementation;
_injectImplementation = impl;
return previous;
}
/**
* @template T
* @param {?} token
* @param {?=} flags
* @return {?}
*/
export function injectInjectorOnly(token, flags = InjectFlags.Default) {
if (_currentInjector === undefined) {
throw new Error(`inject() must be called from an injection context`);
}
else if (_currentInjector === null) {
return injectRootLimpMode(token, undefined, flags);
}
else {
return _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);
}
}
/**
* @template T
* @param {?} token
* @param {?=} flags
* @return {?}
*/
export function ɵɵinject(token, flags = InjectFlags.Default) {
return (_injectImplementation || injectInjectorOnly)(token, flags);
}
/**
* Injects a token from the currently active injector.
*
* Must be used in the context of a factory function such as one defined for an
* `InjectionToken`. Throws an error if not called from such a context.
*
* Within such a factory function, using this function to request injection of a dependency
* is faster and more type-safe than providing an additional array of dependencies
* (as has been common with `useFactory` providers).
*
* \@param token The injection token for the dependency to be injected.
* \@param flags Optional flags that control how injection is executed.
* The flags correspond to injection strategies that can be specified with
* parameter decorators `\@Host`, `\@Self`, `\@SkipSef`, and `\@Optional`.
* \@return True if injection is successful, null otherwise.
*
* \@usageNotes
*
* ### Example
*
* {\@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
*
* \@publicApi
* @type {?}
*/
export const inject = ɵɵinject;
/**
* Injects `root` tokens in limp mode.
*
* If no injector exists, we can still inject tree-shakable providers which have `providedIn` set to
* `"root"`. This is known as the limp mode injection. In such case the value is stored in the
* `InjectableDef`.
* @template T
* @param {?} token
* @param {?} notFoundValue
* @param {?} flags
* @return {?}
*/
export function injectRootLimpMode(token, notFoundValue, flags) {
/** @type {?} */
const injectableDef = getInjectableDef(token);
if (injectableDef && injectableDef.providedIn == 'root') {
return injectableDef.value === undefined ? injectableDef.value = injectableDef.factory() :
injectableDef.value;
}
if (flags & InjectFlags.Optional)
return null;
if (notFoundValue !== undefined)
return notFoundValue;
throw new Error(`Injector: NOT_FOUND [${stringify(token)}]`);
}
/**
* @param {?} types
* @return {?}
*/
export function injectArgs(types) {
/** @type {?} */
const args = [];
for (let i = 0; i < types.length; i++) {
/** @type {?} */
const arg = resolveForwardRef(types[i]);
if (Array.isArray(arg)) {
if (arg.length === 0) {
throw new Error('Arguments array must have arguments.');
}
/** @type {?} */
let type = undefined;
/** @type {?} */
let flags = InjectFlags.Default;
for (let j = 0; j < arg.length; j++) {
/** @type {?} */
const meta = arg[j];
if (meta instanceof Optional || meta.ngMetadataName === 'Optional' || meta === Optional) {
flags |= InjectFlags.Optional;
}
else if (meta instanceof SkipSelf || meta.ngMetadataName === 'SkipSelf' || meta === SkipSelf) {
flags |= InjectFlags.SkipSelf;
}
else if (meta instanceof Self || meta.ngMetadataName === 'Self' || meta === Self) {
flags |= InjectFlags.Self;
}
else if (meta instanceof Inject || meta === Inject) {
type = meta.token;
}
else {
type = meta;
}
}
args.push(ɵɵinject((/** @type {?} */ (type)), flags));
}
else {
args.push(ɵɵinject(arg));
}
}
return args;
}
export class NullInjector {
/**
* @param {?} token
* @param {?=} notFoundValue
* @return {?}
*/
get(token, notFoundValue = THROW_IF_NOT_FOUND) {
if (notFoundValue === THROW_IF_NOT_FOUND) {
// Intentionally left behind: With dev tools open the debugger will stop here. There is no
// reason why correctly written application should cause this exception.
// TODO(misko): uncomment the next line once `ngDevMode` works with closure.
// if(ngDevMode) debugger;
/** @type {?} */
const error = new Error(`NullInjectorError: No provider for ${stringify(token)}!`);
error.name = 'NullInjectorError';
throw error;
}
return notFoundValue;
}
}
/**
* @param {?} e
* @param {?} token
* @param {?} injectorErrorName
* @param {?} source
* @return {?}
*/
export function catchInjectorError(e, token, injectorErrorName, source) {
/** @type {?} */
const tokenPath = e[NG_TEMP_TOKEN_PATH];
if (token[SOURCE]) {
tokenPath.unshift(token[SOURCE]);
}
e.message = formatError('\n' + e.message, tokenPath, injectorErrorName, source);
e[NG_TOKEN_PATH] = tokenPath;
e[NG_TEMP_TOKEN_PATH] = null;
throw e;
}
/**
* @param {?} text
* @param {?} obj
* @param {?} injectorErrorName
* @param {?=} source
* @return {?}
*/
export function formatError(text, obj, injectorErrorName, source = null) {
text = text && text.charAt(0) === '\n' && text.charAt(1) == NO_NEW_LINE ? text.substr(2) : text;
/** @type {?} */
let context = stringify(obj);
if (obj instanceof Array) {
context = obj.map(stringify).join(' -> ');
}
else if (typeof obj === 'object') {
/** @type {?} */
let parts = (/** @type {?} */ ([]));
for (let key in obj) {
if (obj.hasOwnProperty(key)) {
/** @type {?} */
let value = obj[key];
parts.push(key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));
}
}
context = `{${parts.join(', ')}}`;
}
return `${injectorErrorName}${source ? '(' + source + ')' : ''}[${context}]: ${text.replace(NEW_LINE, '\n ')}`;
}
export { ɵ0 };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"injector_compatibility.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/di/injector_compatibility.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Type} from '../interface/type';\nimport {getClosureSafeProperty} from '../util/property';\nimport {stringify} from '../util/stringify';\n\nimport {resolveForwardRef} from './forward_ref';\nimport {InjectionToken} from './injection_token';\nimport {Injector} from './injector';\nimport {getInjectableDef, ɵɵInjectableDef} from './interface/defs';\nimport {InjectFlags} from './interface/injector';\nimport {ValueProvider} from './interface/provider';\nimport {Inject, Optional, Self, SkipSelf} from './metadata';\n\n\n\n/**\n * An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.\n *\n * Requesting this token instead of `Injector` allows `StaticInjector` to be tree-shaken from a\n * project.\n *\n * @publicApi\n */\nexport const INJECTOR = new InjectionToken<Injector>(\n    'INJECTOR',\n    -1 as any  // `-1` is used by Ivy DI system as special value to recognize it as `Injector`.\n    );\n\nconst _THROW_IF_NOT_FOUND = new Object();\nexport const THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n\nexport const NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';\nconst NG_TOKEN_PATH = 'ngTokenPath';\nconst NEW_LINE = /\\n/gm;\nconst NO_NEW_LINE = 'ɵ';\nexport const SOURCE = '__source';\n\nexport const USE_VALUE =\n    getClosureSafeProperty<ValueProvider>({provide: String, useValue: getClosureSafeProperty});\n\n/**\n * Current injector value used by `inject`.\n * - `undefined`: it is an error to call `inject`\n * - `null`: `inject` can be called but there is no injector (limp-mode).\n * - Injector instance: Use the injector for resolution.\n */\nlet _currentInjector: Injector|undefined|null = undefined;\n\nexport function setCurrentInjector(injector: Injector | null | undefined): Injector|undefined|null {\n  const former = _currentInjector;\n  _currentInjector = injector;\n  return former;\n}\n\n/**\n * Current implementation of inject.\n *\n * By default, it is `injectInjectorOnly`, which makes it `Injector`-only aware. It can be changed\n * to `directiveInject`, which brings in the `NodeInjector` system of ivy. It is designed this\n * way for two reasons:\n *  1. `Injector` should not depend on ivy logic.\n *  2. To maintain tree shake-ability we don't want to bring in unnecessary code.\n */\nlet _injectImplementation: (<T>(token: Type<T>| InjectionToken<T>, flags: InjectFlags) => T | null)|\n    undefined;\n\n/**\n * Sets the current inject implementation.\n */\nexport function setInjectImplementation(\n    impl: (<T>(token: Type<T>| InjectionToken<T>, flags?: InjectFlags) => T | null) | undefined):\n    (<T>(token: Type<T>| InjectionToken<T>, flags?: InjectFlags) => T | null)|undefined {\n  const previous = _injectImplementation;\n  _injectImplementation = impl;\n  return previous;\n}\n\nexport function injectInjectorOnly<T>(token: Type<T>| InjectionToken<T>): T;\nexport function injectInjectorOnly<T>(token: Type<T>| InjectionToken<T>, flags?: InjectFlags): T|\n    null;\nexport function injectInjectorOnly<T>(\n    token: Type<T>| InjectionToken<T>, flags = InjectFlags.Default): T|null {\n  if (_currentInjector === undefined) {\n    throw new Error(`inject() must be called from an injection context`);\n  } else if (_currentInjector === null) {\n    return injectRootLimpMode(token, undefined, flags);\n  } else {\n    return _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);\n  }\n}\n\n/**\n * Generated instruction: Injects a token from the currently active injector.\n *\n * Must be used in the context of a factory function such as one defined for an\n * `InjectionToken`. Throws an error if not called from such a context.\n *\n * (Additional documentation moved to `inject`, as it is the public API, and an alias for this instruction)\n *\n * @see inject\n * @codeGenApi\n */\nexport function ɵɵinject<T>(token: Type<T>| InjectionToken<T>): T;\nexport function ɵɵinject<T>(token: Type<T>| InjectionToken<T>, flags?: InjectFlags): T|null;\nexport function ɵɵinject<T>(token: Type<T>| InjectionToken<T>, flags = InjectFlags.Default): T|\n    null {\n  return (_injectImplementation || injectInjectorOnly)(token, flags);\n}\n\n/**\n * Injects a token from the currently active injector.\n *\n * Must be used in the context of a factory function such as one defined for an\n * `InjectionToken`. Throws an error if not called from such a context.\n *\n * Within such a factory function, using this function to request injection of a dependency\n * is faster and more type-safe than providing an additional array of dependencies\n * (as has been common with `useFactory` providers).\n *\n * @param token The injection token for the dependency to be injected.\n * @param flags Optional flags that control how injection is executed.\n * The flags correspond to injection strategies that can be specified with\n * parameter decorators `@Host`, `@Self`, `@SkipSef`, and `@Optional`.\n * @returns True if injection is successful, null otherwise.\n *\n * @usageNotes\n *\n * ### Example\n *\n * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}\n *\n * @publicApi\n */\nexport const inject = ɵɵinject;\n\n/**\n * Injects `root` tokens in limp mode.\n *\n * If no injector exists, we can still inject tree-shakable providers which have `providedIn` set to\n * `\"root\"`. This is known as the limp mode injection. In such case the value is stored in the\n * `InjectableDef`.\n */\nexport function injectRootLimpMode<T>(\n    token: Type<T>| InjectionToken<T>, notFoundValue: T | undefined, flags: InjectFlags): T|null {\n  const injectableDef: ɵɵInjectableDef<T>|null = getInjectableDef(token);\n  if (injectableDef && injectableDef.providedIn == 'root') {\n    return injectableDef.value === undefined ? injectableDef.value = injectableDef.factory() :\n                                               injectableDef.value;\n  }\n  if (flags & InjectFlags.Optional) return null;\n  if (notFoundValue !== undefined) return notFoundValue;\n  throw new Error(`Injector: NOT_FOUND [${stringify(token)}]`);\n}\n\nexport function injectArgs(types: (Type<any>| InjectionToken<any>| any[])[]): any[] {\n  const args: any[] = [];\n  for (let i = 0; i < types.length; i++) {\n    const arg = resolveForwardRef(types[i]);\n    if (Array.isArray(arg)) {\n      if (arg.length === 0) {\n        throw new Error('Arguments array must have arguments.');\n      }\n      let type: Type<any>|undefined = undefined;\n      let flags: InjectFlags = InjectFlags.Default;\n\n      for (let j = 0; j < arg.length; j++) {\n        const meta = arg[j];\n        if (meta instanceof Optional || meta.ngMetadataName === 'Optional' || meta === Optional) {\n          flags |= InjectFlags.Optional;\n        } else if (\n            meta instanceof SkipSelf || meta.ngMetadataName === 'SkipSelf' || meta === SkipSelf) {\n          flags |= InjectFlags.SkipSelf;\n        } else if (meta instanceof Self || meta.ngMetadataName === 'Self' || meta === Self) {\n          flags |= InjectFlags.Self;\n        } else if (meta instanceof Inject || meta === Inject) {\n          type = meta.token;\n        } else {\n          type = meta;\n        }\n      }\n\n      args.push(ɵɵinject(type !, flags));\n    } else {\n      args.push(ɵɵinject(arg));\n    }\n  }\n  return args;\n}\n\n\nexport class NullInjector implements Injector {\n  get(token: any, notFoundValue: any = THROW_IF_NOT_FOUND): any {\n    if (notFoundValue === THROW_IF_NOT_FOUND) {\n      // Intentionally left behind: With dev tools open the debugger will stop here. There is no\n      // reason why correctly written application should cause this exception.\n      // TODO(misko): uncomment the next line once `ngDevMode` works with closure.\n      // if(ngDevMode) debugger;\n      const error = new Error(`NullInjectorError: No provider for ${stringify(token)}!`);\n      error.name = 'NullInjectorError';\n      throw error;\n    }\n    return notFoundValue;\n  }\n}\n\n\nexport function catchInjectorError(\n    e: any, token: any, injectorErrorName: string, source: string | null): never {\n  const tokenPath: any[] = e[NG_TEMP_TOKEN_PATH];\n  if (token[SOURCE]) {\n    tokenPath.unshift(token[SOURCE]);\n  }\n  e.message = formatError('\\n' + e.message, tokenPath, injectorErrorName, source);\n  e[NG_TOKEN_PATH] = tokenPath;\n  e[NG_TEMP_TOKEN_PATH] = null;\n  throw e;\n}\n\nexport function formatError(\n    text: string, obj: any, injectorErrorName: string, source: string | null = null): string {\n  text = text && text.charAt(0) === '\\n' && text.charAt(1) == NO_NEW_LINE ? text.substr(2) : text;\n  let context = stringify(obj);\n  if (obj instanceof Array) {\n    context = obj.map(stringify).join(' -> ');\n  } else if (typeof obj === 'object') {\n    let parts = <string[]>[];\n    for (let key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        let value = obj[key];\n        parts.push(\n            key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));\n      }\n    }\n    context = `{${parts.join(', ')}}`;\n  }\n  return `${injectorErrorName}${source ? '(' + source + ')' : ''}[${context}]: ${text.replace(NEW_LINE, '\\n  ')}`;\n}\n"]}