@angular/core
Version:
Angular - the core framework
669 lines • 95.1 kB
JavaScript
/**
* @license
* Copyright Google LLC 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 { isForwardRef, resolveForwardRef } from '../di/forward_ref';
import { injectRootLimpMode, setInjectImplementation } from '../di/inject_switch';
import { InjectFlags } from '../di/interface/injector';
import { assertDefined, assertEqual, assertIndexInRange } from '../util/assert';
import { noSideEffects } from '../util/closure';
import { assertDirectiveDef, assertNodeInjector, assertTNodeForLView } from './assert';
import { getFactoryDef } from './definition_factory';
import { throwCyclicDependencyError, throwProviderNotFoundError } from './errors_di';
import { NG_ELEMENT_ID, NG_FACTORY_DEF } from './fields';
import { registerPreOrderHooks } from './hooks';
import { isFactory, NO_PARENT_INJECTOR } from './interfaces/injector';
import { isComponentDef, isComponentHost } from './interfaces/type_checks';
import { DECLARATION_COMPONENT_VIEW, DECLARATION_VIEW, INJECTOR, T_HOST, TVIEW } from './interfaces/view';
import { assertTNodeType } from './node_assert';
import { enterDI, getCurrentTNode, getLView, leaveDI } from './state';
import { isNameOnlyAttributeMarker } from './util/attrs_utils';
import { getParentInjectorIndex, getParentInjectorView, hasParentInjector } from './util/injector_utils';
import { stringifyForError } from './util/stringify_utils';
/**
* Defines if the call to `inject` should include `viewProviders` in its resolution.
*
* This is set to true when we try to instantiate a component. This value is reset in
* `getNodeInjectable` to a value which matches the declaration location of the token about to be
* instantiated. This is done so that if we are injecting a token which was declared outside of
* `viewProviders` we don't accidentally pull `viewProviders` in.
*
* Example:
*
* ```
* @Injectable()
* class MyService {
* constructor(public value: String) {}
* }
*
* @Component({
* providers: [
* MyService,
* {provide: String, value: 'providers' }
* ]
* viewProviders: [
* {provide: String, value: 'viewProviders'}
* ]
* })
* class MyComponent {
* constructor(myService: MyService, value: String) {
* // We expect that Component can see into `viewProviders`.
* expect(value).toEqual('viewProviders');
* // `MyService` was not declared in `viewProviders` hence it can't see it.
* expect(myService.value).toEqual('providers');
* }
* }
*
* ```
*/
let includeViewProviders = true;
export function setIncludeViewProviders(v) {
const oldValue = includeViewProviders;
includeViewProviders = v;
return oldValue;
}
/**
* The number of slots in each bloom filter (used by DI). The larger this number, the fewer
* directives that will share slots, and thus, the fewer false positives when checking for
* the existence of a directive.
*/
const BLOOM_SIZE = 256;
const BLOOM_MASK = BLOOM_SIZE - 1;
/**
* The number of bits that is represented by a single bloom bucket. JS bit operations are 32 bits,
* so each bucket represents 32 distinct tokens which accounts for log2(32) = 5 bits of a bloom hash
* number.
*/
const BLOOM_BUCKET_BITS = 5;
/** Counter used to generate unique IDs for directives. */
let nextNgElementId = 0;
/**
* Registers this directive as present in its node's injector by flipping the directive's
* corresponding bit in the injector's bloom filter.
*
* @param injectorIndex The index of the node injector where this token should be registered
* @param tView The TView for the injector's bloom filters
* @param type The directive token to register
*/
export function bloomAdd(injectorIndex, tView, type) {
ngDevMode && assertEqual(tView.firstCreatePass, true, 'expected firstCreatePass to be true');
let id;
if (typeof type === 'string') {
id = type.charCodeAt(0) || 0;
}
else if (type.hasOwnProperty(NG_ELEMENT_ID)) {
id = type[NG_ELEMENT_ID];
}
// Set a unique ID on the directive type, so if something tries to inject the directive,
// we can easily retrieve the ID and hash it into the bloom bit that should be checked.
if (id == null) {
id = type[NG_ELEMENT_ID] = nextNgElementId++;
}
// We only have BLOOM_SIZE (256) slots in our bloom filter (8 buckets * 32 bits each),
// so all unique IDs must be modulo-ed into a number from 0 - 255 to fit into the filter.
const bloomHash = id & BLOOM_MASK;
// Create a mask that targets the specific bit associated with the directive.
// JS bit operations are 32 bits, so this will be a number between 2^0 and 2^31, corresponding
// to bit positions 0 - 31 in a 32 bit integer.
const mask = 1 << bloomHash;
// Each bloom bucket in `tData` represents `BLOOM_BUCKET_BITS` number of bits of `bloomHash`.
// Any bits in `bloomHash` beyond `BLOOM_BUCKET_BITS` indicate the bucket offset that the mask
// should be written to.
tView.data[injectorIndex + (bloomHash >> BLOOM_BUCKET_BITS)] |= mask;
}
/**
* Creates (or gets an existing) injector for a given element or container.
*
* @param tNode for which an injector should be retrieved / created.
* @param lView View where the node is stored
* @returns Node injector
*/
export function getOrCreateNodeInjectorForNode(tNode, lView) {
const existingInjectorIndex = getInjectorIndex(tNode, lView);
if (existingInjectorIndex !== -1) {
return existingInjectorIndex;
}
const tView = lView[TVIEW];
if (tView.firstCreatePass) {
tNode.injectorIndex = lView.length;
insertBloom(tView.data, tNode); // foundation for node bloom
insertBloom(lView, null); // foundation for cumulative bloom
insertBloom(tView.blueprint, null);
}
const parentLoc = getParentInjectorLocation(tNode, lView);
const injectorIndex = tNode.injectorIndex;
// If a parent injector can't be found, its location is set to -1.
// In that case, we don't need to set up a cumulative bloom
if (hasParentInjector(parentLoc)) {
const parentIndex = getParentInjectorIndex(parentLoc);
const parentLView = getParentInjectorView(parentLoc, lView);
const parentData = parentLView[TVIEW].data;
// Creates a cumulative bloom filter that merges the parent's bloom filter
// and its own cumulative bloom (which contains tokens for all ancestors)
for (let i = 0; i < 8 /* BLOOM_SIZE */; i++) {
lView[injectorIndex + i] = parentLView[parentIndex + i] | parentData[parentIndex + i];
}
}
lView[injectorIndex + 8 /* PARENT */] = parentLoc;
return injectorIndex;
}
function insertBloom(arr, footer) {
arr.push(0, 0, 0, 0, 0, 0, 0, 0, footer);
}
export function getInjectorIndex(tNode, lView) {
if (tNode.injectorIndex === -1 ||
// If the injector index is the same as its parent's injector index, then the index has been
// copied down from the parent node. No injector has been created yet on this node.
(tNode.parent && tNode.parent.injectorIndex === tNode.injectorIndex) ||
// After the first template pass, the injector index might exist but the parent values
// might not have been calculated yet for this instance
lView[tNode.injectorIndex + 8 /* PARENT */] === null) {
return -1;
}
else {
ngDevMode && assertIndexInRange(lView, tNode.injectorIndex);
return tNode.injectorIndex;
}
}
/**
* Finds the index of the parent injector, with a view offset if applicable. Used to set the
* parent injector initially.
*
* @returns Returns a number that is the combination of the number of LViews that we have to go up
* to find the LView containing the parent inject AND the index of the injector within that LView.
*/
export function getParentInjectorLocation(tNode, lView) {
if (tNode.parent && tNode.parent.injectorIndex !== -1) {
// If we have a parent `TNode` and there is an injector associated with it we are done, because
// the parent injector is within the current `LView`.
return tNode.parent.injectorIndex; // ViewOffset is 0
}
// When parent injector location is computed it may be outside of the current view. (ie it could
// be pointing to a declared parent location). This variable stores number of declaration parents
// we need to walk up in order to find the parent injector location.
let declarationViewOffset = 0;
let parentTNode = null;
let lViewCursor = lView;
// The parent injector is not in the current `LView`. We will have to walk the declared parent
// `LView` hierarchy and look for it. If we walk of the top, that means that there is no parent
// `NodeInjector`.
while (lViewCursor !== null) {
// First determine the `parentTNode` location. The parent pointer differs based on `TView.type`.
const tView = lViewCursor[TVIEW];
const tViewType = tView.type;
if (tViewType === 2 /* Embedded */) {
ngDevMode &&
assertDefined(tView.declTNode, 'Embedded TNodes should have declaration parents.');
parentTNode = tView.declTNode;
}
else if (tViewType === 1 /* Component */) {
// Components don't have `TView.declTNode` because each instance of component could be
// inserted in different location, hence `TView.declTNode` is meaningless.
parentTNode = lViewCursor[T_HOST];
}
else {
ngDevMode && assertEqual(tView.type, 0 /* Root */, 'Root type expected');
parentTNode = null;
}
if (parentTNode === null) {
// If we have no parent, than we are done.
return NO_PARENT_INJECTOR;
}
ngDevMode && parentTNode && assertTNodeForLView(parentTNode, lViewCursor[DECLARATION_VIEW]);
// Every iteration of the loop requires that we go to the declared parent.
declarationViewOffset++;
lViewCursor = lViewCursor[DECLARATION_VIEW];
if (parentTNode.injectorIndex !== -1) {
// We found a NodeInjector which points to something.
return (parentTNode.injectorIndex |
(declarationViewOffset << 16 /* ViewOffsetShift */));
}
}
return NO_PARENT_INJECTOR;
}
/**
* Makes a type or an injection token public to the DI system by adding it to an
* injector's bloom filter.
*
* @param di The node injector in which a directive will be added
* @param token The type or the injection token to be made public
*/
export function diPublicInInjector(injectorIndex, tView, token) {
bloomAdd(injectorIndex, tView, token);
}
/**
* Inject static attribute value into directive constructor.
*
* This method is used with `factory` functions which are generated as part of
* `defineDirective` or `defineComponent`. The method retrieves the static value
* of an attribute. (Dynamic attributes are not supported since they are not resolved
* at the time of injection and can change over time.)
*
* # Example
* Given:
* ```
* @Component(...)
* class MyComponent {
* constructor(@Attribute('title') title: string) { ... }
* }
* ```
* When instantiated with
* ```
* <my-component title="Hello"></my-component>
* ```
*
* Then factory method generated is:
* ```
* MyComponent.ɵcmp = defineComponent({
* factory: () => new MyComponent(injectAttribute('title'))
* ...
* })
* ```
*
* @publicApi
*/
export function injectAttributeImpl(tNode, attrNameToInject) {
ngDevMode && assertTNodeType(tNode, 12 /* AnyContainer */ | 3 /* AnyRNode */);
ngDevMode && assertDefined(tNode, 'expecting tNode');
if (attrNameToInject === 'class') {
return tNode.classes;
}
if (attrNameToInject === 'style') {
return tNode.styles;
}
const attrs = tNode.attrs;
if (attrs) {
const attrsLength = attrs.length;
let i = 0;
while (i < attrsLength) {
const value = attrs[i];
// If we hit a `Bindings` or `Template` marker then we are done.
if (isNameOnlyAttributeMarker(value))
break;
// Skip namespaced attributes
if (value === 0 /* NamespaceURI */) {
// we skip the next two values
// as namespaced attributes looks like
// [..., AttributeMarker.NamespaceURI, 'http://someuri.com/test', 'test:exist',
// 'existValue', ...]
i = i + 2;
}
else if (typeof value === 'number') {
// Skip to the first value of the marked attribute.
i++;
while (i < attrsLength && typeof attrs[i] === 'string') {
i++;
}
}
else if (value === attrNameToInject) {
return attrs[i + 1];
}
else {
i = i + 2;
}
}
}
return null;
}
function notFoundValueOrThrow(notFoundValue, token, flags) {
if (flags & InjectFlags.Optional) {
return notFoundValue;
}
else {
throwProviderNotFoundError(token, 'NodeInjector');
}
}
/**
* Returns the value associated to the given token from the ModuleInjector or throws exception
*
* @param lView The `LView` that contains the `tNode`
* @param token The token to look for
* @param flags Injection flags
* @param notFoundValue The value to return when the injection flags is `InjectFlags.Optional`
* @returns the value from the injector or throws an exception
*/
function lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue) {
if (flags & InjectFlags.Optional && notFoundValue === undefined) {
// This must be set or the NullInjector will throw for optional deps
notFoundValue = null;
}
if ((flags & (InjectFlags.Self | InjectFlags.Host)) === 0) {
const moduleInjector = lView[INJECTOR];
// switch to `injectInjectorOnly` implementation for module injector, since module injector
// should not have access to Component/Directive DI scope (that may happen through
// `directiveInject` implementation)
const previousInjectImplementation = setInjectImplementation(undefined);
try {
if (moduleInjector) {
return moduleInjector.get(token, notFoundValue, flags & InjectFlags.Optional);
}
else {
return injectRootLimpMode(token, notFoundValue, flags & InjectFlags.Optional);
}
}
finally {
setInjectImplementation(previousInjectImplementation);
}
}
return notFoundValueOrThrow(notFoundValue, token, flags);
}
/**
* Returns the value associated to the given token from the NodeInjectors => ModuleInjector.
*
* Look for the injector providing the token by walking up the node injector tree and then
* the module injector tree.
*
* This function patches `token` with `__NG_ELEMENT_ID__` which contains the id for the bloom
* filter. `-1` is reserved for injecting `Injector` (implemented by `NodeInjector`)
*
* @param tNode The Node where the search for the injector should start
* @param lView The `LView` that contains the `tNode`
* @param token The token to look for
* @param flags Injection flags
* @param notFoundValue The value to return when the injection flags is `InjectFlags.Optional`
* @returns the value from the injector, `null` when not found, or `notFoundValue` if provided
*/
export function getOrCreateInjectable(tNode, lView, token, flags = InjectFlags.Default, notFoundValue) {
if (tNode !== null) {
const bloomHash = bloomHashBitOrFactory(token);
// If the ID stored here is a function, this is a special object like ElementRef or TemplateRef
// so just call the factory function to create it.
if (typeof bloomHash === 'function') {
if (!enterDI(lView, tNode, flags)) {
// Failed to enter DI, try module injector instead. If a token is injected with the @Host
// flag, the module injector is not searched for that token in Ivy.
return (flags & InjectFlags.Host) ?
notFoundValueOrThrow(notFoundValue, token, flags) :
lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
}
try {
const value = bloomHash(flags);
if (value == null && !(flags & InjectFlags.Optional)) {
throwProviderNotFoundError(token);
}
else {
return value;
}
}
finally {
leaveDI();
}
}
else if (typeof bloomHash === 'number') {
// A reference to the previous injector TView that was found while climbing the element
// injector tree. This is used to know if viewProviders can be accessed on the current
// injector.
let previousTView = null;
let injectorIndex = getInjectorIndex(tNode, lView);
let parentLocation = NO_PARENT_INJECTOR;
let hostTElementNode = flags & InjectFlags.Host ? lView[DECLARATION_COMPONENT_VIEW][T_HOST] : null;
// If we should skip this injector, or if there is no injector on this node, start by
// searching the parent injector.
if (injectorIndex === -1 || flags & InjectFlags.SkipSelf) {
parentLocation = injectorIndex === -1 ? getParentInjectorLocation(tNode, lView) :
lView[injectorIndex + 8 /* PARENT */];
if (parentLocation === NO_PARENT_INJECTOR || !shouldSearchParent(flags, false)) {
injectorIndex = -1;
}
else {
previousTView = lView[TVIEW];
injectorIndex = getParentInjectorIndex(parentLocation);
lView = getParentInjectorView(parentLocation, lView);
}
}
// Traverse up the injector tree until we find a potential match or until we know there
// *isn't* a match.
while (injectorIndex !== -1) {
ngDevMode && assertNodeInjector(lView, injectorIndex);
// Check the current injector. If it matches, see if it contains token.
const tView = lView[TVIEW];
ngDevMode &&
assertTNodeForLView(tView.data[injectorIndex + 8 /* TNODE */], lView);
if (bloomHasToken(bloomHash, injectorIndex, tView.data)) {
// At this point, we have an injector which *may* contain the token, so we step through
// the providers and directives associated with the injector's corresponding node to get
// the instance.
const instance = searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode);
if (instance !== NOT_FOUND) {
return instance;
}
}
parentLocation = lView[injectorIndex + 8 /* PARENT */];
if (parentLocation !== NO_PARENT_INJECTOR &&
shouldSearchParent(flags, lView[TVIEW].data[injectorIndex + 8 /* TNODE */] === hostTElementNode) &&
bloomHasToken(bloomHash, injectorIndex, lView)) {
// The def wasn't found anywhere on this node, so it was a false positive.
// Traverse up the tree and continue searching.
previousTView = tView;
injectorIndex = getParentInjectorIndex(parentLocation);
lView = getParentInjectorView(parentLocation, lView);
}
else {
// If we should not search parent OR If the ancestor bloom filter value does not have the
// bit corresponding to the directive we can give up on traversing up to find the specific
// injector.
injectorIndex = -1;
}
}
}
}
return lookupTokenUsingModuleInjector(lView, token, flags, notFoundValue);
}
const NOT_FOUND = {};
export function createNodeInjector() {
return new NodeInjector(getCurrentTNode(), getLView());
}
function searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode) {
const currentTView = lView[TVIEW];
const tNode = currentTView.data[injectorIndex + 8 /* TNODE */];
// First, we need to determine if view providers can be accessed by the starting element.
// There are two possibilities
const canAccessViewProviders = previousTView == null ?
// 1) This is the first invocation `previousTView == null` which means that we are at the
// `TNode` of where injector is starting to look. In such a case the only time we are allowed
// to look into the ViewProviders is if:
// - we are on a component
// - AND the injector set `includeViewProviders` to true (implying that the token can see
// ViewProviders because it is the Component or a Service which itself was declared in
// ViewProviders)
(isComponentHost(tNode) && includeViewProviders) :
// 2) `previousTView != null` which means that we are now walking across the parent nodes.
// In such a case we are only allowed to look into the ViewProviders if:
// - We just crossed from child View to Parent View `previousTView != currentTView`
// - AND the parent TNode is an Element.
// This means that we just came from the Component's View and therefore are allowed to see
// into the ViewProviders.
(previousTView != currentTView && ((tNode.type & 3 /* AnyRNode */) !== 0));
// This special case happens when there is a @host on the inject and when we are searching
// on the host element node.
const isHostSpecialCase = (flags & InjectFlags.Host) && hostTElementNode === tNode;
const injectableIdx = locateDirectiveOrProvider(tNode, currentTView, token, canAccessViewProviders, isHostSpecialCase);
if (injectableIdx !== null) {
return getNodeInjectable(lView, currentTView, injectableIdx, tNode);
}
else {
return NOT_FOUND;
}
}
/**
* Searches for the given token among the node's directives and providers.
*
* @param tNode TNode on which directives are present.
* @param tView The tView we are currently processing
* @param token Provider token or type of a directive to look for.
* @param canAccessViewProviders Whether view providers should be considered.
* @param isHostSpecialCase Whether the host special case applies.
* @returns Index of a found directive or provider, or null when none found.
*/
export function locateDirectiveOrProvider(tNode, tView, token, canAccessViewProviders, isHostSpecialCase) {
const nodeProviderIndexes = tNode.providerIndexes;
const tInjectables = tView.data;
const injectablesStart = nodeProviderIndexes & 1048575 /* ProvidersStartIndexMask */;
const directivesStart = tNode.directiveStart;
const directiveEnd = tNode.directiveEnd;
const cptViewProvidersCount = nodeProviderIndexes >> 20 /* CptViewProvidersCountShift */;
const startingIndex = canAccessViewProviders ? injectablesStart : injectablesStart + cptViewProvidersCount;
// When the host special case applies, only the viewProviders and the component are visible
const endIndex = isHostSpecialCase ? injectablesStart + cptViewProvidersCount : directiveEnd;
for (let i = startingIndex; i < endIndex; i++) {
const providerTokenOrDef = tInjectables[i];
if (i < directivesStart && token === providerTokenOrDef ||
i >= directivesStart && providerTokenOrDef.type === token) {
return i;
}
}
if (isHostSpecialCase) {
const dirDef = tInjectables[directivesStart];
if (dirDef && isComponentDef(dirDef) && dirDef.type === token) {
return directivesStart;
}
}
return null;
}
/**
* Retrieve or instantiate the injectable from the `LView` at particular `index`.
*
* This function checks to see if the value has already been instantiated and if so returns the
* cached `injectable`. Otherwise if it detects that the value is still a factory it
* instantiates the `injectable` and caches the value.
*/
export function getNodeInjectable(lView, tView, index, tNode) {
let value = lView[index];
const tData = tView.data;
if (isFactory(value)) {
const factory = value;
if (factory.resolving) {
throwCyclicDependencyError(stringifyForError(tData[index]));
}
const previousIncludeViewProviders = setIncludeViewProviders(factory.canSeeViewProviders);
factory.resolving = true;
const previousInjectImplementation = factory.injectImpl ? setInjectImplementation(factory.injectImpl) : null;
const success = enterDI(lView, tNode, InjectFlags.Default);
ngDevMode &&
assertEqual(success, true, 'Because flags do not contain \`SkipSelf\' we expect this to always succeed.');
try {
value = lView[index] = factory.factory(undefined, tData, lView, tNode);
// This code path is hit for both directives and providers.
// For perf reasons, we want to avoid searching for hooks on providers.
// It does no harm to try (the hooks just won't exist), but the extra
// checks are unnecessary and this is a hot path. So we check to see
// if the index of the dependency is in the directive range for this
// tNode. If it's not, we know it's a provider and skip hook registration.
if (tView.firstCreatePass && index >= tNode.directiveStart) {
ngDevMode && assertDirectiveDef(tData[index]);
registerPreOrderHooks(index, tData[index], tView);
}
}
finally {
previousInjectImplementation !== null &&
setInjectImplementation(previousInjectImplementation);
setIncludeViewProviders(previousIncludeViewProviders);
factory.resolving = false;
leaveDI();
}
}
return value;
}
/**
* Returns the bit in an injector's bloom filter that should be used to determine whether or not
* the directive might be provided by the injector.
*
* When a directive is public, it is added to the bloom filter and given a unique ID that can be
* retrieved on the Type. When the directive isn't public or the token is not a directive `null`
* is returned as the node injector can not possibly provide that token.
*
* @param token the injection token
* @returns the matching bit to check in the bloom filter or `null` if the token is not known.
* When the returned value is negative then it represents special values such as `Injector`.
*/
export function bloomHashBitOrFactory(token) {
ngDevMode && assertDefined(token, 'token must be defined');
if (typeof token === 'string') {
return token.charCodeAt(0) || 0;
}
const tokenId =
// First check with `hasOwnProperty` so we don't get an inherited ID.
token.hasOwnProperty(NG_ELEMENT_ID) ? token[NG_ELEMENT_ID] : undefined;
// Negative token IDs are used for special objects such as `Injector`
if (typeof tokenId === 'number') {
if (tokenId >= 0) {
return tokenId & BLOOM_MASK;
}
else {
ngDevMode &&
assertEqual(tokenId, -1 /* Injector */, 'Expecting to get Special Injector Id');
return createNodeInjector;
}
}
else {
return tokenId;
}
}
export function bloomHasToken(bloomHash, injectorIndex, injectorView) {
// Create a mask that targets the specific bit associated with the directive we're looking for.
// JS bit operations are 32 bits, so this will be a number between 2^0 and 2^31, corresponding
// to bit positions 0 - 31 in a 32 bit integer.
const mask = 1 << bloomHash;
// Each bloom bucket in `injectorView` represents `BLOOM_BUCKET_BITS` number of bits of
// `bloomHash`. Any bits in `bloomHash` beyond `BLOOM_BUCKET_BITS` indicate the bucket offset
// that should be used.
const value = injectorView[injectorIndex + (bloomHash >> BLOOM_BUCKET_BITS)];
// If the bloom filter value has the bit corresponding to the directive's bloomBit flipped on,
// this injector is a potential match.
return !!(value & mask);
}
/** Returns true if flags prevent parent injector from being searched for tokens */
function shouldSearchParent(flags, isFirstHostTNode) {
return !(flags & InjectFlags.Self) && !(flags & InjectFlags.Host && isFirstHostTNode);
}
export class NodeInjector {
constructor(_tNode, _lView) {
this._tNode = _tNode;
this._lView = _lView;
}
get(token, notFoundValue) {
return getOrCreateInjectable(this._tNode, this._lView, token, undefined, notFoundValue);
}
}
/**
* @codeGenApi
*/
export function ɵɵgetInheritedFactory(type) {
return noSideEffects(() => {
const ownConstructor = type.prototype.constructor;
const ownFactory = ownConstructor[NG_FACTORY_DEF] || getFactoryOf(ownConstructor);
const objectPrototype = Object.prototype;
let parent = Object.getPrototypeOf(type.prototype).constructor;
// Go up the prototype until we hit `Object`.
while (parent && parent !== objectPrototype) {
const factory = parent[NG_FACTORY_DEF] || getFactoryOf(parent);
// If we hit something that has a factory and the factory isn't the same as the type,
// we've found the inherited factory. Note the check that the factory isn't the type's
// own factory is redundant in most cases, but if the user has custom decorators on the
// class, this lookup will start one level down in the prototype chain, causing us to
// find the own factory first and potentially triggering an infinite loop downstream.
if (factory && factory !== ownFactory) {
return factory;
}
parent = Object.getPrototypeOf(parent);
}
// There is no factory defined. Either this was improper usage of inheritance
// (no Angular decorator on the superclass) or there is no constructor at all
// in the inheritance chain. Since the two cases cannot be distinguished, the
// latter has to be assumed.
return t => new t();
});
}
function getFactoryOf(type) {
if (isForwardRef(type)) {
return () => {
const factory = getFactoryOf(resolveForwardRef(type));
return factory && factory();
};
}
return getFactoryDef(type);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"di.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/di.ts"],"names":[],"mappings":"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