@angular/core
Version:
Angular - the core framework
1,313 lines • 120 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 { DebugElement__PRE_R3__, DebugEventListener, DebugNode__PRE_R3__, getDebugNode, indexDebugNode, removeDebugNodeFromIndex } from '../debug/debug_node';
import { getInjectableDef } from '../di/interface/defs';
import { ErrorHandler } from '../error_handler';
import { RendererFactory2 } from '../render/api';
import { Sanitizer } from '../sanitization/security';
import { isDevMode } from '../util/is_dev_mode';
import { normalizeDebugBindingName, normalizeDebugBindingValue } from '../util/ng_reflect';
import { isViewDebugError, viewDestroyedError, viewWrappedDebugError } from './errors';
import { resolveDep } from './provider';
import { dirtyParentQueries, getQueryValue } from './query';
import { createInjector, createNgModuleRef, getComponentViewDefinitionFactory } from './refs';
import { Services, asElementData, asPureExpressionData } from './types';
import { NOOP, isComponentView, renderNode, resolveDefinition, splitDepsDsl, tokenKey, viewParentEl } from './util';
import { checkAndUpdateNode, checkAndUpdateView, checkNoChangesNode, checkNoChangesView, createComponentView, createEmbeddedView, createRootView, destroyView } from './view';
/** @type {?} */
let initialized = false;
/**
* @return {?}
*/
export function initServicesIfNeeded() {
if (initialized) {
return;
}
initialized = true;
/** @type {?} */
const services = isDevMode() ? createDebugServices() : createProdServices();
Services.setCurrentNode = services.setCurrentNode;
Services.createRootView = services.createRootView;
Services.createEmbeddedView = services.createEmbeddedView;
Services.createComponentView = services.createComponentView;
Services.createNgModuleRef = services.createNgModuleRef;
Services.overrideProvider = services.overrideProvider;
Services.overrideComponentView = services.overrideComponentView;
Services.clearOverrides = services.clearOverrides;
Services.checkAndUpdateView = services.checkAndUpdateView;
Services.checkNoChangesView = services.checkNoChangesView;
Services.destroyView = services.destroyView;
Services.resolveDep = resolveDep;
Services.createDebugContext = services.createDebugContext;
Services.handleEvent = services.handleEvent;
Services.updateDirectives = services.updateDirectives;
Services.updateRenderer = services.updateRenderer;
Services.dirtyParentQueries = dirtyParentQueries;
}
/**
* @return {?}
*/
function createProdServices() {
return {
setCurrentNode: (/**
* @return {?}
*/
() => { }),
createRootView: createProdRootView,
createEmbeddedView: createEmbeddedView,
createComponentView: createComponentView,
createNgModuleRef: createNgModuleRef,
overrideProvider: NOOP,
overrideComponentView: NOOP,
clearOverrides: NOOP,
checkAndUpdateView: checkAndUpdateView,
checkNoChangesView: checkNoChangesView,
destroyView: destroyView,
createDebugContext: (/**
* @param {?} view
* @param {?} nodeIndex
* @return {?}
*/
(view, nodeIndex) => new DebugContext_(view, nodeIndex)),
handleEvent: (/**
* @param {?} view
* @param {?} nodeIndex
* @param {?} eventName
* @param {?} event
* @return {?}
*/
(view, nodeIndex, eventName, event) => view.def.handleEvent(view, nodeIndex, eventName, event)),
updateDirectives: (/**
* @param {?} view
* @param {?} checkType
* @return {?}
*/
(view, checkType) => view.def.updateDirectives(checkType === 0 /* CheckAndUpdate */ ? prodCheckAndUpdateNode :
prodCheckNoChangesNode, view)),
updateRenderer: (/**
* @param {?} view
* @param {?} checkType
* @return {?}
*/
(view, checkType) => view.def.updateRenderer(checkType === 0 /* CheckAndUpdate */ ? prodCheckAndUpdateNode :
prodCheckNoChangesNode, view)),
};
}
/**
* @return {?}
*/
function createDebugServices() {
return {
setCurrentNode: debugSetCurrentNode,
createRootView: debugCreateRootView,
createEmbeddedView: debugCreateEmbeddedView,
createComponentView: debugCreateComponentView,
createNgModuleRef: debugCreateNgModuleRef,
overrideProvider: debugOverrideProvider,
overrideComponentView: debugOverrideComponentView,
clearOverrides: debugClearOverrides,
checkAndUpdateView: debugCheckAndUpdateView,
checkNoChangesView: debugCheckNoChangesView,
destroyView: debugDestroyView,
createDebugContext: (/**
* @param {?} view
* @param {?} nodeIndex
* @return {?}
*/
(view, nodeIndex) => new DebugContext_(view, nodeIndex)),
handleEvent: debugHandleEvent,
updateDirectives: debugUpdateDirectives,
updateRenderer: debugUpdateRenderer,
};
}
/**
* @param {?} elInjector
* @param {?} projectableNodes
* @param {?} rootSelectorOrNode
* @param {?} def
* @param {?} ngModule
* @param {?=} context
* @return {?}
*/
function createProdRootView(elInjector, projectableNodes, rootSelectorOrNode, def, ngModule, context) {
/** @type {?} */
const rendererFactory = ngModule.injector.get(RendererFactory2);
return createRootView(createRootData(elInjector, ngModule, rendererFactory, projectableNodes, rootSelectorOrNode), def, context);
}
/**
* @param {?} elInjector
* @param {?} projectableNodes
* @param {?} rootSelectorOrNode
* @param {?} def
* @param {?} ngModule
* @param {?=} context
* @return {?}
*/
function debugCreateRootView(elInjector, projectableNodes, rootSelectorOrNode, def, ngModule, context) {
/** @type {?} */
const rendererFactory = ngModule.injector.get(RendererFactory2);
/** @type {?} */
const root = createRootData(elInjector, ngModule, new DebugRendererFactory2(rendererFactory), projectableNodes, rootSelectorOrNode);
/** @type {?} */
const defWithOverride = applyProviderOverridesToView(def);
return callWithDebugContext(DebugAction.create, createRootView, null, [root, defWithOverride, context]);
}
/**
* @param {?} elInjector
* @param {?} ngModule
* @param {?} rendererFactory
* @param {?} projectableNodes
* @param {?} rootSelectorOrNode
* @return {?}
*/
function createRootData(elInjector, ngModule, rendererFactory, projectableNodes, rootSelectorOrNode) {
/** @type {?} */
const sanitizer = ngModule.injector.get(Sanitizer);
/** @type {?} */
const errorHandler = ngModule.injector.get(ErrorHandler);
/** @type {?} */
const renderer = rendererFactory.createRenderer(null, null);
return {
ngModule,
injector: elInjector, projectableNodes,
selectorOrNode: rootSelectorOrNode, sanitizer, rendererFactory, renderer, errorHandler
};
}
/**
* @param {?} parentView
* @param {?} anchorDef
* @param {?} viewDef
* @param {?=} context
* @return {?}
*/
function debugCreateEmbeddedView(parentView, anchorDef, viewDef, context) {
/** @type {?} */
const defWithOverride = applyProviderOverridesToView(viewDef);
return callWithDebugContext(DebugAction.create, createEmbeddedView, null, [parentView, anchorDef, defWithOverride, context]);
}
/**
* @param {?} parentView
* @param {?} nodeDef
* @param {?} viewDef
* @param {?} hostElement
* @return {?}
*/
function debugCreateComponentView(parentView, nodeDef, viewDef, hostElement) {
/** @type {?} */
const overrideComponentView = viewDefOverrides.get((/** @type {?} */ ((/** @type {?} */ ((/** @type {?} */ (nodeDef.element)).componentProvider)).provider)).token);
if (overrideComponentView) {
viewDef = overrideComponentView;
}
else {
viewDef = applyProviderOverridesToView(viewDef);
}
return callWithDebugContext(DebugAction.create, createComponentView, null, [parentView, nodeDef, viewDef, hostElement]);
}
/**
* @param {?} moduleType
* @param {?} parentInjector
* @param {?} bootstrapComponents
* @param {?} def
* @return {?}
*/
function debugCreateNgModuleRef(moduleType, parentInjector, bootstrapComponents, def) {
/** @type {?} */
const defWithOverride = applyProviderOverridesToNgModule(def);
return createNgModuleRef(moduleType, parentInjector, bootstrapComponents, defWithOverride);
}
/** @type {?} */
const providerOverrides = new Map();
/** @type {?} */
const providerOverridesWithScope = new Map();
/** @type {?} */
const viewDefOverrides = new Map();
/**
* @param {?} override
* @return {?}
*/
function debugOverrideProvider(override) {
providerOverrides.set(override.token, override);
/** @type {?} */
let injectableDef;
if (typeof override.token === 'function' && (injectableDef = getInjectableDef(override.token)) &&
typeof injectableDef.providedIn === 'function') {
providerOverridesWithScope.set((/** @type {?} */ (override.token)), override);
}
}
/**
* @param {?} comp
* @param {?} compFactory
* @return {?}
*/
function debugOverrideComponentView(comp, compFactory) {
/** @type {?} */
const hostViewDef = resolveDefinition(getComponentViewDefinitionFactory(compFactory));
/** @type {?} */
const compViewDef = resolveDefinition((/** @type {?} */ ((/** @type {?} */ (hostViewDef.nodes[0].element)).componentView)));
viewDefOverrides.set(comp, compViewDef);
}
/**
* @return {?}
*/
function debugClearOverrides() {
providerOverrides.clear();
providerOverridesWithScope.clear();
viewDefOverrides.clear();
}
// Notes about the algorithm:
// 1) Locate the providers of an element and check if one of them was overwritten
// 2) Change the providers of that element
//
// We only create new datastructures if we need to, to keep perf impact
// reasonable.
/**
* @param {?} def
* @return {?}
*/
function applyProviderOverridesToView(def) {
if (providerOverrides.size === 0) {
return def;
}
/** @type {?} */
const elementIndicesWithOverwrittenProviders = findElementIndicesWithOverwrittenProviders(def);
if (elementIndicesWithOverwrittenProviders.length === 0) {
return def;
}
// clone the whole view definition,
// as it maintains references between the nodes that are hard to update.
def = (/** @type {?} */ (def.factory))((/**
* @return {?}
*/
() => NOOP));
for (let i = 0; i < elementIndicesWithOverwrittenProviders.length; i++) {
applyProviderOverridesToElement(def, elementIndicesWithOverwrittenProviders[i]);
}
return def;
/**
* @param {?} def
* @return {?}
*/
function findElementIndicesWithOverwrittenProviders(def) {
/** @type {?} */
const elIndicesWithOverwrittenProviders = [];
/** @type {?} */
let lastElementDef = null;
for (let i = 0; i < def.nodes.length; i++) {
/** @type {?} */
const nodeDef = def.nodes[i];
if (nodeDef.flags & 1 /* TypeElement */) {
lastElementDef = nodeDef;
}
if (lastElementDef && nodeDef.flags & 3840 /* CatProviderNoDirective */ &&
providerOverrides.has((/** @type {?} */ (nodeDef.provider)).token)) {
elIndicesWithOverwrittenProviders.push((/** @type {?} */ (lastElementDef)).nodeIndex);
lastElementDef = null;
}
}
return elIndicesWithOverwrittenProviders;
}
/**
* @param {?} viewDef
* @param {?} elIndex
* @return {?}
*/
function applyProviderOverridesToElement(viewDef, elIndex) {
for (let i = elIndex + 1; i < viewDef.nodes.length; i++) {
/** @type {?} */
const nodeDef = viewDef.nodes[i];
if (nodeDef.flags & 1 /* TypeElement */) {
// stop at the next element
return;
}
if (nodeDef.flags & 3840 /* CatProviderNoDirective */) {
/** @type {?} */
const provider = (/** @type {?} */ (nodeDef.provider));
/** @type {?} */
const override = providerOverrides.get(provider.token);
if (override) {
nodeDef.flags = (nodeDef.flags & ~3840 /* CatProviderNoDirective */) | override.flags;
provider.deps = splitDepsDsl(override.deps);
provider.value = override.value;
}
}
}
}
}
// Notes about the algorithm:
// We only create new datastructures if we need to, to keep perf impact
// reasonable.
/**
* @param {?} def
* @return {?}
*/
function applyProviderOverridesToNgModule(def) {
const { hasOverrides, hasDeprecatedOverrides } = calcHasOverrides(def);
if (!hasOverrides) {
return def;
}
// clone the whole view definition,
// as it maintains references between the nodes that are hard to update.
def = (/** @type {?} */ (def.factory))((/**
* @return {?}
*/
() => NOOP));
applyProviderOverrides(def);
return def;
/**
* @param {?} def
* @return {?}
*/
function calcHasOverrides(def) {
/** @type {?} */
let hasOverrides = false;
/** @type {?} */
let hasDeprecatedOverrides = false;
if (providerOverrides.size === 0) {
return { hasOverrides, hasDeprecatedOverrides };
}
def.providers.forEach((/**
* @param {?} node
* @return {?}
*/
node => {
/** @type {?} */
const override = providerOverrides.get(node.token);
if ((node.flags & 3840 /* CatProviderNoDirective */) && override) {
hasOverrides = true;
hasDeprecatedOverrides = hasDeprecatedOverrides || override.deprecatedBehavior;
}
}));
def.modules.forEach((/**
* @param {?} module
* @return {?}
*/
module => {
providerOverridesWithScope.forEach((/**
* @param {?} override
* @param {?} token
* @return {?}
*/
(override, token) => {
if ((/** @type {?} */ (getInjectableDef(token))).providedIn === module) {
hasOverrides = true;
hasDeprecatedOverrides = hasDeprecatedOverrides || override.deprecatedBehavior;
}
}));
}));
return { hasOverrides, hasDeprecatedOverrides };
}
/**
* @param {?} def
* @return {?}
*/
function applyProviderOverrides(def) {
for (let i = 0; i < def.providers.length; i++) {
/** @type {?} */
const provider = def.providers[i];
if (hasDeprecatedOverrides) {
// We had a bug where me made
// all providers lazy. Keep this logic behind a flag
// for migrating existing users.
provider.flags |= 4096 /* LazyProvider */;
}
/** @type {?} */
const override = providerOverrides.get(provider.token);
if (override) {
provider.flags = (provider.flags & ~3840 /* CatProviderNoDirective */) | override.flags;
provider.deps = splitDepsDsl(override.deps);
provider.value = override.value;
}
}
if (providerOverridesWithScope.size > 0) {
/** @type {?} */
let moduleSet = new Set(def.modules);
providerOverridesWithScope.forEach((/**
* @param {?} override
* @param {?} token
* @return {?}
*/
(override, token) => {
if (moduleSet.has((/** @type {?} */ (getInjectableDef(token))).providedIn)) {
/** @type {?} */
let provider = {
token: token,
flags: override.flags | (hasDeprecatedOverrides ? 4096 /* LazyProvider */ : 0 /* None */),
deps: splitDepsDsl(override.deps),
value: override.value,
index: def.providers.length,
};
def.providers.push(provider);
def.providersByKey[tokenKey(token)] = provider;
}
}));
}
}
}
/**
* @param {?} view
* @param {?} checkIndex
* @param {?} argStyle
* @param {?=} v0
* @param {?=} v1
* @param {?=} v2
* @param {?=} v3
* @param {?=} v4
* @param {?=} v5
* @param {?=} v6
* @param {?=} v7
* @param {?=} v8
* @param {?=} v9
* @return {?}
*/
function prodCheckAndUpdateNode(view, checkIndex, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {
/** @type {?} */
const nodeDef = view.def.nodes[checkIndex];
checkAndUpdateNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
return (nodeDef.flags & 224 /* CatPureExpression */) ?
asPureExpressionData(view, checkIndex).value :
undefined;
}
/**
* @param {?} view
* @param {?} checkIndex
* @param {?} argStyle
* @param {?=} v0
* @param {?=} v1
* @param {?=} v2
* @param {?=} v3
* @param {?=} v4
* @param {?=} v5
* @param {?=} v6
* @param {?=} v7
* @param {?=} v8
* @param {?=} v9
* @return {?}
*/
function prodCheckNoChangesNode(view, checkIndex, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9) {
/** @type {?} */
const nodeDef = view.def.nodes[checkIndex];
checkNoChangesNode(view, nodeDef, argStyle, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9);
return (nodeDef.flags & 224 /* CatPureExpression */) ?
asPureExpressionData(view, checkIndex).value :
undefined;
}
/**
* @param {?} view
* @return {?}
*/
function debugCheckAndUpdateView(view) {
return callWithDebugContext(DebugAction.detectChanges, checkAndUpdateView, null, [view]);
}
/**
* @param {?} view
* @return {?}
*/
function debugCheckNoChangesView(view) {
return callWithDebugContext(DebugAction.checkNoChanges, checkNoChangesView, null, [view]);
}
/**
* @param {?} view
* @return {?}
*/
function debugDestroyView(view) {
return callWithDebugContext(DebugAction.destroy, destroyView, null, [view]);
}
/** @enum {number} */
const DebugAction = {
create: 0,
detectChanges: 1,
checkNoChanges: 2,
destroy: 3,
handleEvent: 4,
};
DebugAction[DebugAction.create] = 'create';
DebugAction[DebugAction.detectChanges] = 'detectChanges';
DebugAction[DebugAction.checkNoChanges] = 'checkNoChanges';
DebugAction[DebugAction.destroy] = 'destroy';
DebugAction[DebugAction.handleEvent] = 'handleEvent';
/** @type {?} */
let _currentAction;
/** @type {?} */
let _currentView;
/** @type {?} */
let _currentNodeIndex;
/**
* @param {?} view
* @param {?} nodeIndex
* @return {?}
*/
function debugSetCurrentNode(view, nodeIndex) {
_currentView = view;
_currentNodeIndex = nodeIndex;
}
/**
* @param {?} view
* @param {?} nodeIndex
* @param {?} eventName
* @param {?} event
* @return {?}
*/
function debugHandleEvent(view, nodeIndex, eventName, event) {
debugSetCurrentNode(view, nodeIndex);
return callWithDebugContext(DebugAction.handleEvent, view.def.handleEvent, null, [view, nodeIndex, eventName, event]);
}
/**
* @param {?} view
* @param {?} checkType
* @return {?}
*/
function debugUpdateDirectives(view, checkType) {
if (view.state & 128 /* Destroyed */) {
throw viewDestroyedError(DebugAction[_currentAction]);
}
debugSetCurrentNode(view, nextDirectiveWithBinding(view, 0));
return view.def.updateDirectives(debugCheckDirectivesFn, view);
/**
* @param {?} view
* @param {?} nodeIndex
* @param {?} argStyle
* @param {...?} values
* @return {?}
*/
function debugCheckDirectivesFn(view, nodeIndex, argStyle, ...values) {
/** @type {?} */
const nodeDef = view.def.nodes[nodeIndex];
if (checkType === 0 /* CheckAndUpdate */) {
debugCheckAndUpdateNode(view, nodeDef, argStyle, values);
}
else {
debugCheckNoChangesNode(view, nodeDef, argStyle, values);
}
if (nodeDef.flags & 16384 /* TypeDirective */) {
debugSetCurrentNode(view, nextDirectiveWithBinding(view, nodeIndex));
}
return (nodeDef.flags & 224 /* CatPureExpression */) ?
asPureExpressionData(view, nodeDef.nodeIndex).value :
undefined;
}
}
/**
* @param {?} view
* @param {?} checkType
* @return {?}
*/
function debugUpdateRenderer(view, checkType) {
if (view.state & 128 /* Destroyed */) {
throw viewDestroyedError(DebugAction[_currentAction]);
}
debugSetCurrentNode(view, nextRenderNodeWithBinding(view, 0));
return view.def.updateRenderer(debugCheckRenderNodeFn, view);
/**
* @param {?} view
* @param {?} nodeIndex
* @param {?} argStyle
* @param {...?} values
* @return {?}
*/
function debugCheckRenderNodeFn(view, nodeIndex, argStyle, ...values) {
/** @type {?} */
const nodeDef = view.def.nodes[nodeIndex];
if (checkType === 0 /* CheckAndUpdate */) {
debugCheckAndUpdateNode(view, nodeDef, argStyle, values);
}
else {
debugCheckNoChangesNode(view, nodeDef, argStyle, values);
}
if (nodeDef.flags & 3 /* CatRenderNode */) {
debugSetCurrentNode(view, nextRenderNodeWithBinding(view, nodeIndex));
}
return (nodeDef.flags & 224 /* CatPureExpression */) ?
asPureExpressionData(view, nodeDef.nodeIndex).value :
undefined;
}
}
/**
* @param {?} view
* @param {?} nodeDef
* @param {?} argStyle
* @param {?} givenValues
* @return {?}
*/
function debugCheckAndUpdateNode(view, nodeDef, argStyle, givenValues) {
/** @type {?} */
const changed = ((/** @type {?} */ (checkAndUpdateNode)))(view, nodeDef, argStyle, ...givenValues);
if (changed) {
/** @type {?} */
const values = argStyle === 1 /* Dynamic */ ? givenValues[0] : givenValues;
if (nodeDef.flags & 16384 /* TypeDirective */) {
/** @type {?} */
const bindingValues = {};
for (let i = 0; i < nodeDef.bindings.length; i++) {
/** @type {?} */
const binding = nodeDef.bindings[i];
/** @type {?} */
const value = values[i];
if (binding.flags & 8 /* TypeProperty */) {
bindingValues[normalizeDebugBindingName((/** @type {?} */ (binding.nonMinifiedName)))] =
normalizeDebugBindingValue(value);
}
}
/** @type {?} */
const elDef = (/** @type {?} */ (nodeDef.parent));
/** @type {?} */
const el = asElementData(view, elDef.nodeIndex).renderElement;
if (!(/** @type {?} */ (elDef.element)).name) {
// a comment.
view.renderer.setValue(el, `bindings=${JSON.stringify(bindingValues, null, 2)}`);
}
else {
// a regular element.
for (let attr in bindingValues) {
/** @type {?} */
const value = bindingValues[attr];
if (value != null) {
view.renderer.setAttribute(el, attr, value);
}
else {
view.renderer.removeAttribute(el, attr);
}
}
}
}
}
}
/**
* @param {?} view
* @param {?} nodeDef
* @param {?} argStyle
* @param {?} values
* @return {?}
*/
function debugCheckNoChangesNode(view, nodeDef, argStyle, values) {
((/** @type {?} */ (checkNoChangesNode)))(view, nodeDef, argStyle, ...values);
}
/**
* @param {?} view
* @param {?} nodeIndex
* @return {?}
*/
function nextDirectiveWithBinding(view, nodeIndex) {
for (let i = nodeIndex; i < view.def.nodes.length; i++) {
/** @type {?} */
const nodeDef = view.def.nodes[i];
if (nodeDef.flags & 16384 /* TypeDirective */ && nodeDef.bindings && nodeDef.bindings.length) {
return i;
}
}
return null;
}
/**
* @param {?} view
* @param {?} nodeIndex
* @return {?}
*/
function nextRenderNodeWithBinding(view, nodeIndex) {
for (let i = nodeIndex; i < view.def.nodes.length; i++) {
/** @type {?} */
const nodeDef = view.def.nodes[i];
if ((nodeDef.flags & 3 /* CatRenderNode */) && nodeDef.bindings && nodeDef.bindings.length) {
return i;
}
}
return null;
}
class DebugContext_ {
/**
* @param {?} view
* @param {?} nodeIndex
*/
constructor(view, nodeIndex) {
this.view = view;
this.nodeIndex = nodeIndex;
if (nodeIndex == null) {
this.nodeIndex = nodeIndex = 0;
}
this.nodeDef = view.def.nodes[nodeIndex];
/** @type {?} */
let elDef = this.nodeDef;
/** @type {?} */
let elView = view;
while (elDef && (elDef.flags & 1 /* TypeElement */) === 0) {
elDef = (/** @type {?} */ (elDef.parent));
}
if (!elDef) {
while (!elDef && elView) {
elDef = (/** @type {?} */ (viewParentEl(elView)));
elView = (/** @type {?} */ (elView.parent));
}
}
this.elDef = elDef;
this.elView = elView;
}
/**
* @private
* @return {?}
*/
get elOrCompView() {
// Has to be done lazily as we use the DebugContext also during creation of elements...
return asElementData(this.elView, this.elDef.nodeIndex).componentView || this.view;
}
/**
* @return {?}
*/
get injector() { return createInjector(this.elView, this.elDef); }
/**
* @return {?}
*/
get component() { return this.elOrCompView.component; }
/**
* @return {?}
*/
get context() { return this.elOrCompView.context; }
/**
* @return {?}
*/
get providerTokens() {
/** @type {?} */
const tokens = [];
if (this.elDef) {
for (let i = this.elDef.nodeIndex + 1; i <= this.elDef.nodeIndex + this.elDef.childCount; i++) {
/** @type {?} */
const childDef = this.elView.def.nodes[i];
if (childDef.flags & 20224 /* CatProvider */) {
tokens.push((/** @type {?} */ (childDef.provider)).token);
}
i += childDef.childCount;
}
}
return tokens;
}
/**
* @return {?}
*/
get references() {
/** @type {?} */
const references = {};
if (this.elDef) {
collectReferences(this.elView, this.elDef, references);
for (let i = this.elDef.nodeIndex + 1; i <= this.elDef.nodeIndex + this.elDef.childCount; i++) {
/** @type {?} */
const childDef = this.elView.def.nodes[i];
if (childDef.flags & 20224 /* CatProvider */) {
collectReferences(this.elView, childDef, references);
}
i += childDef.childCount;
}
}
return references;
}
/**
* @return {?}
*/
get componentRenderElement() {
/** @type {?} */
const elData = findHostElement(this.elOrCompView);
return elData ? elData.renderElement : undefined;
}
/**
* @return {?}
*/
get renderNode() {
return this.nodeDef.flags & 2 /* TypeText */ ? renderNode(this.view, this.nodeDef) :
renderNode(this.elView, this.elDef);
}
/**
* @param {?} console
* @param {...?} values
* @return {?}
*/
logError(console, ...values) {
/** @type {?} */
let logViewDef;
/** @type {?} */
let logNodeIndex;
if (this.nodeDef.flags & 2 /* TypeText */) {
logViewDef = this.view.def;
logNodeIndex = this.nodeDef.nodeIndex;
}
else {
logViewDef = this.elView.def;
logNodeIndex = this.elDef.nodeIndex;
}
// Note: we only generate a log function for text and element nodes
// to make the generated code as small as possible.
/** @type {?} */
const renderNodeIndex = getRenderNodeIndex(logViewDef, logNodeIndex);
/** @type {?} */
let currRenderNodeIndex = -1;
/** @type {?} */
let nodeLogger = (/**
* @return {?}
*/
() => {
currRenderNodeIndex++;
if (currRenderNodeIndex === renderNodeIndex) {
return console.error.bind(console, ...values);
}
else {
return NOOP;
}
});
(/** @type {?} */ (logViewDef.factory))(nodeLogger);
if (currRenderNodeIndex < renderNodeIndex) {
console.error('Illegal state: the ViewDefinitionFactory did not call the logger!');
((/** @type {?} */ (console.error)))(...values);
}
}
}
if (false) {
/**
* @type {?}
* @private
*/
DebugContext_.prototype.nodeDef;
/**
* @type {?}
* @private
*/
DebugContext_.prototype.elView;
/**
* @type {?}
* @private
*/
DebugContext_.prototype.elDef;
/** @type {?} */
DebugContext_.prototype.view;
/** @type {?} */
DebugContext_.prototype.nodeIndex;
}
/**
* @param {?} viewDef
* @param {?} nodeIndex
* @return {?}
*/
function getRenderNodeIndex(viewDef, nodeIndex) {
/** @type {?} */
let renderNodeIndex = -1;
for (let i = 0; i <= nodeIndex; i++) {
/** @type {?} */
const nodeDef = viewDef.nodes[i];
if (nodeDef.flags & 3 /* CatRenderNode */) {
renderNodeIndex++;
}
}
return renderNodeIndex;
}
/**
* @param {?} view
* @return {?}
*/
function findHostElement(view) {
while (view && !isComponentView(view)) {
view = (/** @type {?} */ (view.parent));
}
if (view.parent) {
return asElementData(view.parent, (/** @type {?} */ (viewParentEl(view))).nodeIndex);
}
return null;
}
/**
* @param {?} view
* @param {?} nodeDef
* @param {?} references
* @return {?}
*/
function collectReferences(view, nodeDef, references) {
for (let refName in nodeDef.references) {
references[refName] = getQueryValue(view, nodeDef, nodeDef.references[refName]);
}
}
/**
* @param {?} action
* @param {?} fn
* @param {?} self
* @param {?} args
* @return {?}
*/
function callWithDebugContext(action, fn, self, args) {
/** @type {?} */
const oldAction = _currentAction;
/** @type {?} */
const oldView = _currentView;
/** @type {?} */
const oldNodeIndex = _currentNodeIndex;
try {
_currentAction = action;
/** @type {?} */
const result = fn.apply(self, args);
_currentView = oldView;
_currentNodeIndex = oldNodeIndex;
_currentAction = oldAction;
return result;
}
catch (e) {
if (isViewDebugError(e) || !_currentView) {
throw e;
}
throw viewWrappedDebugError(e, (/** @type {?} */ (getCurrentDebugContext())));
}
}
/**
* @return {?}
*/
export function getCurrentDebugContext() {
return _currentView ? new DebugContext_(_currentView, _currentNodeIndex) : null;
}
export class DebugRendererFactory2 {
/**
* @param {?} delegate
*/
constructor(delegate) {
this.delegate = delegate;
}
/**
* @param {?} element
* @param {?} renderData
* @return {?}
*/
createRenderer(element, renderData) {
return new DebugRenderer2(this.delegate.createRenderer(element, renderData));
}
/**
* @return {?}
*/
begin() {
if (this.delegate.begin) {
this.delegate.begin();
}
}
/**
* @return {?}
*/
end() {
if (this.delegate.end) {
this.delegate.end();
}
}
/**
* @return {?}
*/
whenRenderingDone() {
if (this.delegate.whenRenderingDone) {
return this.delegate.whenRenderingDone();
}
return Promise.resolve(null);
}
}
if (false) {
/**
* @type {?}
* @private
*/
DebugRendererFactory2.prototype.delegate;
}
export class DebugRenderer2 {
/**
* @param {?} delegate
*/
constructor(delegate) {
this.delegate = delegate;
/**
* Factory function used to create a `DebugContext` when a node is created.
*
* The `DebugContext` allows to retrieve information about the nodes that are useful in tests.
*
* The factory is configurable so that the `DebugRenderer2` could instantiate either a View Engine
* or a Render context.
*/
this.debugContextFactory = getCurrentDebugContext;
this.data = this.delegate.data;
}
/**
* @private
* @param {?} nativeElement
* @return {?}
*/
createDebugContext(nativeElement) { return this.debugContextFactory(nativeElement); }
/**
* @param {?} node
* @return {?}
*/
destroyNode(node) {
removeDebugNodeFromIndex((/** @type {?} */ (getDebugNode(node))));
if (this.delegate.destroyNode) {
this.delegate.destroyNode(node);
}
}
/**
* @return {?}
*/
destroy() { this.delegate.destroy(); }
/**
* @param {?} name
* @param {?=} namespace
* @return {?}
*/
createElement(name, namespace) {
/** @type {?} */
const el = this.delegate.createElement(name, namespace);
/** @type {?} */
const debugCtx = this.createDebugContext(el);
if (debugCtx) {
/** @type {?} */
const debugEl = new DebugElement__PRE_R3__(el, null, debugCtx);
((/** @type {?} */ (debugEl))).name = name;
indexDebugNode(debugEl);
}
return el;
}
/**
* @param {?} value
* @return {?}
*/
createComment(value) {
/** @type {?} */
const comment = this.delegate.createComment(value);
/** @type {?} */
const debugCtx = this.createDebugContext(comment);
if (debugCtx) {
indexDebugNode(new DebugNode__PRE_R3__(comment, null, debugCtx));
}
return comment;
}
/**
* @param {?} value
* @return {?}
*/
createText(value) {
/** @type {?} */
const text = this.delegate.createText(value);
/** @type {?} */
const debugCtx = this.createDebugContext(text);
if (debugCtx) {
indexDebugNode(new DebugNode__PRE_R3__(text, null, debugCtx));
}
return text;
}
/**
* @param {?} parent
* @param {?} newChild
* @return {?}
*/
appendChild(parent, newChild) {
/** @type {?} */
const debugEl = getDebugNode(parent);
/** @type {?} */
const debugChildEl = getDebugNode(newChild);
if (debugEl && debugChildEl && debugEl instanceof DebugElement__PRE_R3__) {
debugEl.addChild(debugChildEl);
}
this.delegate.appendChild(parent, newChild);
}
/**
* @param {?} parent
* @param {?} newChild
* @param {?} refChild
* @return {?}
*/
insertBefore(parent, newChild, refChild) {
/** @type {?} */
const debugEl = getDebugNode(parent);
/** @type {?} */
const debugChildEl = getDebugNode(newChild);
/** @type {?} */
const debugRefEl = (/** @type {?} */ (getDebugNode(refChild)));
if (debugEl && debugChildEl && debugEl instanceof DebugElement__PRE_R3__) {
debugEl.insertBefore(debugRefEl, debugChildEl);
}
this.delegate.insertBefore(parent, newChild, refChild);
}
/**
* @param {?} parent
* @param {?} oldChild
* @return {?}
*/
removeChild(parent, oldChild) {
/** @type {?} */
const debugEl = getDebugNode(parent);
/** @type {?} */
const debugChildEl = getDebugNode(oldChild);
if (debugEl && debugChildEl && debugEl instanceof DebugElement__PRE_R3__) {
debugEl.removeChild(debugChildEl);
}
this.delegate.removeChild(parent, oldChild);
}
/**
* @param {?} selectorOrNode
* @param {?=} preserveContent
* @return {?}
*/
selectRootElement(selectorOrNode, preserveContent) {
/** @type {?} */
const el = this.delegate.selectRootElement(selectorOrNode, preserveContent);
/** @type {?} */
const debugCtx = getCurrentDebugContext();
if (debugCtx) {
indexDebugNode(new DebugElement__PRE_R3__(el, null, debugCtx));
}
return el;
}
/**
* @param {?} el
* @param {?} name
* @param {?} value
* @param {?=} namespace
* @return {?}
*/
setAttribute(el, name, value, namespace) {
/** @type {?} */
const debugEl = getDebugNode(el);
if (debugEl && debugEl instanceof DebugElement__PRE_R3__) {
/** @type {?} */
const fullName = namespace ? namespace + ':' + name : name;
debugEl.attributes[fullName] = value;
}
this.delegate.setAttribute(el, name, value, namespace);
}
/**
* @param {?} el
* @param {?} name
* @param {?=} namespace
* @return {?}
*/
removeAttribute(el, name, namespace) {
/** @type {?} */
const debugEl = getDebugNode(el);
if (debugEl && debugEl instanceof DebugElement__PRE_R3__) {
/** @type {?} */
const fullName = namespace ? namespace + ':' + name : name;
debugEl.attributes[fullName] = null;
}
this.delegate.removeAttribute(el, name, namespace);
}
/**
* @param {?} el
* @param {?} name
* @return {?}
*/
addClass(el, name) {
/** @type {?} */
const debugEl = getDebugNode(el);
if (debugEl && debugEl instanceof DebugElement__PRE_R3__) {
debugEl.classes[name] = true;
}
this.delegate.addClass(el, name);
}
/**
* @param {?} el
* @param {?} name
* @return {?}
*/
removeClass(el, name) {
/** @type {?} */
const debugEl = getDebugNode(el);
if (debugEl && debugEl instanceof DebugElement__PRE_R3__) {
debugEl.classes[name] = false;
}
this.delegate.removeClass(el, name);
}
/**
* @param {?} el
* @param {?} style
* @param {?} value
* @param {?} flags
* @return {?}
*/
setStyle(el, style, value, flags) {
/** @type {?} */
const debugEl = getDebugNode(el);
if (debugEl && debugEl instanceof DebugElement__PRE_R3__) {
debugEl.styles[style] = value;
}
this.delegate.setStyle(el, style, value, flags);
}
/**
* @param {?} el
* @param {?} style
* @param {?} flags
* @return {?}
*/
removeStyle(el, style, flags) {
/** @type {?} */
const debugEl = getDebugNode(el);
if (debugEl && debugEl instanceof DebugElement__PRE_R3__) {
debugEl.styles[style] = null;
}
this.delegate.removeStyle(el, style, flags);
}
/**
* @param {?} el
* @param {?} name
* @param {?} value
* @return {?}
*/
setProperty(el, name, value) {
/** @type {?} */
const debugEl = getDebugNode(el);
if (debugEl && debugEl instanceof DebugElement__PRE_R3__) {
debugEl.properties[name] = value;
}
this.delegate.setProperty(el, name, value);
}
/**
* @param {?} target
* @param {?} eventName
* @param {?} callback
* @return {?}
*/
listen(target, eventName, callback) {
if (typeof target !== 'string') {
/** @type {?} */
const debugEl = getDebugNode(target);
if (debugEl) {
debugEl.listeners.push(new DebugEventListener(eventName, callback));
}
}
return this.delegate.listen(target, eventName, callback);
}
/**
* @param {?} node
* @return {?}
*/
parentNode(node) { return this.delegate.parentNode(node); }
/**
* @param {?} node
* @return {?}
*/
nextSibling(node) { return this.delegate.nextSibling(node); }
/**
* @param {?} node
* @param {?} value
* @return {?}
*/
setValue(node, value) { return this.delegate.setValue(node, value); }
}
if (false) {
/** @type {?} */
DebugRenderer2.prototype.data;
/**
* Factory function used to create a `DebugContext` when a node is created.
*
* The `DebugContext` allows to retrieve information about the nodes that are useful in tests.
*
* The factory is configurable so that the `DebugRenderer2` could instantiate either a View Engine
* or a Render context.
* @type {?}
*/
DebugRenderer2.prototype.debugContextFactory;
/**
* @type {?}
* @private
*/
DebugRenderer2.prototype.delegate;
}
//# sourceMappingURL=data:application/json;base64,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