@angular/core
Version:
Angular - the core framework
371 lines • 38.8 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 '../util/ng_dev_mode';
import { assertDomNode } from '../util/assert';
import { EMPTY_ARRAY } from './empty';
import { MONKEY_PATCH_KEY_NAME } from './interfaces/context';
import { CONTEXT, HEADER_OFFSET, HOST, TVIEW } from './interfaces/view';
import { getComponentViewByIndex, getNativeByTNode, readPatchedData, unwrapRNode } from './util/view_utils';
/**
* Returns the matching `LContext` data for a given DOM node, directive or component instance.
*
* This function will examine the provided DOM element, component, or directive instance\'s
* monkey-patched property to derive the `LContext` data. Once called then the monkey-patched
* value will be that of the newly created `LContext`.
*
* If the monkey-patched value is the `LView` instance then the context value for that
* target will be created and the monkey-patch reference will be updated. Therefore when this
* function is called it may mutate the provided element\'s, component\'s or any of the associated
* directive\'s monkey-patch values.
*
* If the monkey-patch value is not detected then the code will walk up the DOM until an element
* is found which contains a monkey-patch reference. When that occurs then the provided element
* will be updated with a new context (which is then returned). If the monkey-patch value is not
* detected for a component/directive instance then it will throw an error (all components and
* directives should be automatically monkey-patched by ivy).
*
* @param {?} target Component, Directive or DOM Node.
* @return {?}
*/
export function getLContext(target) {
/** @type {?} */
let mpValue = readPatchedData(target);
if (mpValue) {
// only when it's an array is it considered an LView instance
// ... otherwise it's an already constructed LContext instance
if (Array.isArray(mpValue)) {
/** @type {?} */
const lView = (/** @type {?} */ (mpValue));
/** @type {?} */
let nodeIndex;
/** @type {?} */
let component = undefined;
/** @type {?} */
let directives = undefined;
if (isComponentInstance(target)) {
nodeIndex = findViaComponent(lView, target);
if (nodeIndex == -1) {
throw new Error('The provided component was not found in the application');
}
component = target;
}
else if (isDirectiveInstance(target)) {
nodeIndex = findViaDirective(lView, target);
if (nodeIndex == -1) {
throw new Error('The provided directive was not found in the application');
}
directives = getDirectivesAtNodeIndex(nodeIndex, lView, false);
}
else {
nodeIndex = findViaNativeElement(lView, (/** @type {?} */ (target)));
if (nodeIndex == -1) {
return null;
}
}
// the goal is not to fill the entire context full of data because the lookups
// are expensive. Instead, only the target data (the element, component, container, ICU
// expression or directive details) are filled into the context. If called multiple times
// with different target values then the missing target data will be filled in.
/** @type {?} */
const native = unwrapRNode(lView[nodeIndex]);
/** @type {?} */
const existingCtx = readPatchedData(native);
/** @type {?} */
const context = (existingCtx && !Array.isArray(existingCtx)) ?
existingCtx :
createLContext(lView, nodeIndex, native);
// only when the component has been discovered then update the monkey-patch
if (component && context.component === undefined) {
context.component = component;
attachPatchData(context.component, context);
}
// only when the directives have been discovered then update the monkey-patch
if (directives && context.directives === undefined) {
context.directives = directives;
for (let i = 0; i < directives.length; i++) {
attachPatchData(directives[i], context);
}
}
attachPatchData(context.native, context);
mpValue = context;
}
}
else {
/** @type {?} */
const rElement = (/** @type {?} */ (target));
ngDevMode && assertDomNode(rElement);
// if the context is not found then we need to traverse upwards up the DOM
// to find the nearest element that has already been monkey patched with data
/** @type {?} */
let parent = (/** @type {?} */ (rElement));
while (parent = parent.parentNode) {
/** @type {?} */
const parentContext = readPatchedData(parent);
if (parentContext) {
/** @type {?} */
let lView;
if (Array.isArray(parentContext)) {
lView = (/** @type {?} */ (parentContext));
}
else {
lView = parentContext.lView;
}
// the edge of the app was also reached here through another means
// (maybe because the DOM was changed manually).
if (!lView) {
return null;
}
/** @type {?} */
const index = findViaNativeElement(lView, rElement);
if (index >= 0) {
/** @type {?} */
const native = unwrapRNode(lView[index]);
/** @type {?} */
const context = createLContext(lView, index, native);
attachPatchData(native, context);
mpValue = context;
break;
}
}
}
}
return ((/** @type {?} */ (mpValue))) || null;
}
/**
* Creates an empty instance of a `LContext` context
* @param {?} lView
* @param {?} nodeIndex
* @param {?} native
* @return {?}
*/
function createLContext(lView, nodeIndex, native) {
return {
lView,
nodeIndex,
native,
component: undefined,
directives: undefined,
localRefs: undefined,
};
}
/**
* Takes a component instance and returns the view for that component.
*
* @param {?} componentInstance
* @return {?} The component's view
*/
export function getComponentViewByInstance(componentInstance) {
/** @type {?} */
let lView = readPatchedData(componentInstance);
/** @type {?} */
let view;
if (Array.isArray(lView)) {
/** @type {?} */
const nodeIndex = findViaComponent(lView, componentInstance);
view = getComponentViewByIndex(nodeIndex, lView);
/** @type {?} */
const context = createLContext(lView, nodeIndex, (/** @type {?} */ (view[HOST])));
context.component = componentInstance;
attachPatchData(componentInstance, context);
attachPatchData(context.native, context);
}
else {
/** @type {?} */
const context = (/** @type {?} */ ((/** @type {?} */ (lView))));
view = getComponentViewByIndex(context.nodeIndex, context.lView);
}
return view;
}
/**
* Assigns the given data to the given target (which could be a component,
* directive or DOM node instance) using monkey-patching.
* @param {?} target
* @param {?} data
* @return {?}
*/
export function attachPatchData(target, data) {
target[MONKEY_PATCH_KEY_NAME] = data;
}
/**
* @param {?} instance
* @return {?}
*/
export function isComponentInstance(instance) {
return instance && instance.constructor && instance.constructor.ngComponentDef;
}
/**
* @param {?} instance
* @return {?}
*/
export function isDirectiveInstance(instance) {
return instance && instance.constructor && instance.constructor.ngDirectiveDef;
}
/**
* Locates the element within the given LView and returns the matching index
* @param {?} lView
* @param {?} target
* @return {?}
*/
function findViaNativeElement(lView, target) {
/** @type {?} */
let tNode = lView[TVIEW].firstChild;
while (tNode) {
/** @type {?} */
const native = (/** @type {?} */ (getNativeByTNode(tNode, lView)));
if (native === target) {
return tNode.index;
}
tNode = traverseNextElement(tNode);
}
return -1;
}
/**
* Locates the next tNode (child, sibling or parent).
* @param {?} tNode
* @return {?}
*/
function traverseNextElement(tNode) {
if (tNode.child) {
return tNode.child;
}
else if (tNode.next) {
return tNode.next;
}
else {
// Let's take the following template: <div><span>text</span></div><component/>
// After checking the text node, we need to find the next parent that has a "next" TNode,
// in this case the parent `div`, so that we can find the component.
while (tNode.parent && !tNode.parent.next) {
tNode = tNode.parent;
}
return tNode.parent && tNode.parent.next;
}
}
/**
* Locates the component within the given LView and returns the matching index
* @param {?} lView
* @param {?} componentInstance
* @return {?}
*/
function findViaComponent(lView, componentInstance) {
/** @type {?} */
const componentIndices = lView[TVIEW].components;
if (componentIndices) {
for (let i = 0; i < componentIndices.length; i++) {
/** @type {?} */
const elementComponentIndex = componentIndices[i];
/** @type {?} */
const componentView = getComponentViewByIndex(elementComponentIndex, lView);
if (componentView[CONTEXT] === componentInstance) {
return elementComponentIndex;
}
}
}
else {
/** @type {?} */
const rootComponentView = getComponentViewByIndex(HEADER_OFFSET, lView);
/** @type {?} */
const rootComponent = rootComponentView[CONTEXT];
if (rootComponent === componentInstance) {
// we are dealing with the root element here therefore we know that the
// element is the very first element after the HEADER data in the lView
return HEADER_OFFSET;
}
}
return -1;
}
/**
* Locates the directive within the given LView and returns the matching index
* @param {?} lView
* @param {?} directiveInstance
* @return {?}
*/
function findViaDirective(lView, directiveInstance) {
// if a directive is monkey patched then it will (by default)
// have a reference to the LView of the current view. The
// element bound to the directive being search lives somewhere
// in the view data. We loop through the nodes and check their
// list of directives for the instance.
/** @type {?} */
let tNode = lView[TVIEW].firstChild;
while (tNode) {
/** @type {?} */
const directiveIndexStart = tNode.directiveStart;
/** @type {?} */
const directiveIndexEnd = tNode.directiveEnd;
for (let i = directiveIndexStart; i < directiveIndexEnd; i++) {
if (lView[i] === directiveInstance) {
return tNode.index;
}
}
tNode = traverseNextElement(tNode);
}
return -1;
}
/**
* Returns a list of directives extracted from the given view based on the
* provided list of directive index values.
*
* @param {?} nodeIndex The node index
* @param {?} lView The target view data
* @param {?} includeComponents Whether or not to include components in returned directives
* @return {?}
*/
export function getDirectivesAtNodeIndex(nodeIndex, lView, includeComponents) {
/** @type {?} */
const tNode = (/** @type {?} */ (lView[TVIEW].data[nodeIndex]));
/** @type {?} */
let directiveStartIndex = tNode.directiveStart;
if (directiveStartIndex == 0)
return EMPTY_ARRAY;
/** @type {?} */
const directiveEndIndex = tNode.directiveEnd;
if (!includeComponents && tNode.flags & 1 /* isComponent */)
directiveStartIndex++;
return lView.slice(directiveStartIndex, directiveEndIndex);
}
/**
* @param {?} nodeIndex
* @param {?} lView
* @return {?}
*/
export function getComponentAtNodeIndex(nodeIndex, lView) {
/** @type {?} */
const tNode = (/** @type {?} */ (lView[TVIEW].data[nodeIndex]));
/** @type {?} */
let directiveStartIndex = tNode.directiveStart;
return tNode.flags & 1 /* isComponent */ ? lView[directiveStartIndex] : null;
}
/**
* Returns a map of local references (local reference name => element or directive instance) that
* exist on a given element.
* @param {?} lView
* @param {?} nodeIndex
* @return {?}
*/
export function discoverLocalRefs(lView, nodeIndex) {
/** @type {?} */
const tNode = (/** @type {?} */ (lView[TVIEW].data[nodeIndex]));
if (tNode && tNode.localNames) {
/** @type {?} */
const result = {};
/** @type {?} */
let localIndex = tNode.index + 1;
for (let i = 0; i < tNode.localNames.length; i += 2) {
result[tNode.localNames[i]] = lView[localIndex];
localIndex++;
}
return result;
}
return null;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context_discovery.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/render3/context_discovery.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 */\nimport '../util/ng_dev_mode';\n\nimport {assertDomNode} from '../util/assert';\n\nimport {EMPTY_ARRAY} from './empty';\nimport {LContext, MONKEY_PATCH_KEY_NAME} from './interfaces/context';\nimport {TNode, TNodeFlags} from './interfaces/node';\nimport {RElement, RNode} from './interfaces/renderer';\nimport {CONTEXT, HEADER_OFFSET, HOST, LView, TVIEW} from './interfaces/view';\nimport {getComponentViewByIndex, getNativeByTNode, readPatchedData, unwrapRNode} from './util/view_utils';\n\n\n\n/** Returns the matching `LContext` data for a given DOM node, directive or component instance.\n *\n * This function will examine the provided DOM element, component, or directive instance\\'s\n * monkey-patched property to derive the `LContext` data. Once called then the monkey-patched\n * value will be that of the newly created `LContext`.\n *\n * If the monkey-patched value is the `LView` instance then the context value for that\n * target will be created and the monkey-patch reference will be updated. Therefore when this\n * function is called it may mutate the provided element\\'s, component\\'s or any of the associated\n * directive\\'s monkey-patch values.\n *\n * If the monkey-patch value is not detected then the code will walk up the DOM until an element\n * is found which contains a monkey-patch reference. When that occurs then the provided element\n * will be updated with a new context (which is then returned). If the monkey-patch value is not\n * detected for a component/directive instance then it will throw an error (all components and\n * directives should be automatically monkey-patched by ivy).\n *\n * @param target Component, Directive or DOM Node.\n */\nexport function getLContext(target: any): LContext|null {\n  let mpValue = readPatchedData(target);\n  if (mpValue) {\n    // only when it's an array is it considered an LView instance\n    // ... otherwise it's an already constructed LContext instance\n    if (Array.isArray(mpValue)) {\n      const lView: LView = mpValue !;\n      let nodeIndex: number;\n      let component: any = undefined;\n      let directives: any[]|null|undefined = undefined;\n\n      if (isComponentInstance(target)) {\n        nodeIndex = findViaComponent(lView, target);\n        if (nodeIndex == -1) {\n          throw new Error('The provided component was not found in the application');\n        }\n        component = target;\n      } else if (isDirectiveInstance(target)) {\n        nodeIndex = findViaDirective(lView, target);\n        if (nodeIndex == -1) {\n          throw new Error('The provided directive was not found in the application');\n        }\n        directives = getDirectivesAtNodeIndex(nodeIndex, lView, false);\n      } else {\n        nodeIndex = findViaNativeElement(lView, target as RElement);\n        if (nodeIndex == -1) {\n          return null;\n        }\n      }\n\n      // the goal is not to fill the entire context full of data because the lookups\n      // are expensive. Instead, only the target data (the element, component, container, ICU\n      // expression or directive details) are filled into the context. If called multiple times\n      // with different target values then the missing target data will be filled in.\n      const native = unwrapRNode(lView[nodeIndex]);\n      const existingCtx = readPatchedData(native);\n      const context: LContext = (existingCtx && !Array.isArray(existingCtx)) ?\n          existingCtx :\n          createLContext(lView, nodeIndex, native);\n\n      // only when the component has been discovered then update the monkey-patch\n      if (component && context.component === undefined) {\n        context.component = component;\n        attachPatchData(context.component, context);\n      }\n\n      // only when the directives have been discovered then update the monkey-patch\n      if (directives && context.directives === undefined) {\n        context.directives = directives;\n        for (let i = 0; i < directives.length; i++) {\n          attachPatchData(directives[i], context);\n        }\n      }\n\n      attachPatchData(context.native, context);\n      mpValue = context;\n    }\n  } else {\n    const rElement = target as RElement;\n    ngDevMode && assertDomNode(rElement);\n\n    // if the context is not found then we need to traverse upwards up the DOM\n    // to find the nearest element that has already been monkey patched with data\n    let parent = rElement as any;\n    while (parent = parent.parentNode) {\n      const parentContext = readPatchedData(parent);\n      if (parentContext) {\n        let lView: LView|null;\n        if (Array.isArray(parentContext)) {\n          lView = parentContext as LView;\n        } else {\n          lView = parentContext.lView;\n        }\n\n        // the edge of the app was also reached here through another means\n        // (maybe because the DOM was changed manually).\n        if (!lView) {\n          return null;\n        }\n\n        const index = findViaNativeElement(lView, rElement);\n        if (index >= 0) {\n          const native = unwrapRNode(lView[index]);\n          const context = createLContext(lView, index, native);\n          attachPatchData(native, context);\n          mpValue = context;\n          break;\n        }\n      }\n    }\n  }\n  return (mpValue as LContext) || null;\n}\n\n/**\n * Creates an empty instance of a `LContext` context\n */\nfunction createLContext(lView: LView, nodeIndex: number, native: RNode): LContext {\n  return {\n    lView,\n    nodeIndex,\n    native,\n    component: undefined,\n    directives: undefined,\n    localRefs: undefined,\n  };\n}\n\n/**\n * Takes a component instance and returns the view for that component.\n *\n * @param componentInstance\n * @returns The component's view\n */\nexport function getComponentViewByInstance(componentInstance: {}): LView {\n  let lView = readPatchedData(componentInstance);\n  let view: LView;\n\n  if (Array.isArray(lView)) {\n    const nodeIndex = findViaComponent(lView, componentInstance);\n    view = getComponentViewByIndex(nodeIndex, lView);\n    const context = createLContext(lView, nodeIndex, view[HOST] as RElement);\n    context.component = componentInstance;\n    attachPatchData(componentInstance, context);\n    attachPatchData(context.native, context);\n  } else {\n    const context = lView as any as LContext;\n    view = getComponentViewByIndex(context.nodeIndex, context.lView);\n  }\n  return view;\n}\n\n/**\n * Assigns the given data to the given target (which could be a component,\n * directive or DOM node instance) using monkey-patching.\n */\nexport function attachPatchData(target: any, data: LView | LContext) {\n  target[MONKEY_PATCH_KEY_NAME] = data;\n}\n\nexport function isComponentInstance(instance: any): boolean {\n  return instance && instance.constructor && instance.constructor.ngComponentDef;\n}\n\nexport function isDirectiveInstance(instance: any): boolean {\n  return instance && instance.constructor && instance.constructor.ngDirectiveDef;\n}\n\n/**\n * Locates the element within the given LView and returns the matching index\n */\nfunction findViaNativeElement(lView: LView, target: RElement): number {\n  let tNode = lView[TVIEW].firstChild;\n  while (tNode) {\n    const native = getNativeByTNode(tNode, lView) !;\n    if (native === target) {\n      return tNode.index;\n    }\n    tNode = traverseNextElement(tNode);\n  }\n\n  return -1;\n}\n\n/**\n * Locates the next tNode (child, sibling or parent).\n */\nfunction traverseNextElement(tNode: TNode): TNode|null {\n  if (tNode.child) {\n    return tNode.child;\n  } else if (tNode.next) {\n    return tNode.next;\n  } else {\n    // Let's take the following template: <div><span>text</span></div><component/>\n    // After checking the text node, we need to find the next parent that has a \"next\" TNode,\n    // in this case the parent `div`, so that we can find the component.\n    while (tNode.parent && !tNode.parent.next) {\n      tNode = tNode.parent;\n    }\n    return tNode.parent && tNode.parent.next;\n  }\n}\n\n/**\n * Locates the component within the given LView and returns the matching index\n */\nfunction findViaComponent(lView: LView, componentInstance: {}): number {\n  const componentIndices = lView[TVIEW].components;\n  if (componentIndices) {\n    for (let i = 0; i < componentIndices.length; i++) {\n      const elementComponentIndex = componentIndices[i];\n      const componentView = getComponentViewByIndex(elementComponentIndex, lView);\n      if (componentView[CONTEXT] === componentInstance) {\n        return elementComponentIndex;\n      }\n    }\n  } else {\n    const rootComponentView = getComponentViewByIndex(HEADER_OFFSET, lView);\n    const rootComponent = rootComponentView[CONTEXT];\n    if (rootComponent === componentInstance) {\n      // we are dealing with the root element here therefore we know that the\n      // element is the very first element after the HEADER data in the lView\n      return HEADER_OFFSET;\n    }\n  }\n  return -1;\n}\n\n/**\n * Locates the directive within the given LView and returns the matching index\n */\nfunction findViaDirective(lView: LView, directiveInstance: {}): number {\n  // if a directive is monkey patched then it will (by default)\n  // have a reference to the LView of the current view. The\n  // element bound to the directive being search lives somewhere\n  // in the view data. We loop through the nodes and check their\n  // list of directives for the instance.\n  let tNode = lView[TVIEW].firstChild;\n  while (tNode) {\n    const directiveIndexStart = tNode.directiveStart;\n    const directiveIndexEnd = tNode.directiveEnd;\n    for (let i = directiveIndexStart; i < directiveIndexEnd; i++) {\n      if (lView[i] === directiveInstance) {\n        return tNode.index;\n      }\n    }\n    tNode = traverseNextElement(tNode);\n  }\n  return -1;\n}\n\n/**\n * Returns a list of directives extracted from the given view based on the\n * provided list of directive index values.\n *\n * @param nodeIndex The node index\n * @param lView The target view data\n * @param includeComponents Whether or not to include components in returned directives\n */\nexport function getDirectivesAtNodeIndex(\n    nodeIndex: number, lView: LView, includeComponents: boolean): any[]|null {\n  const tNode = lView[TVIEW].data[nodeIndex] as TNode;\n  let directiveStartIndex = tNode.directiveStart;\n  if (directiveStartIndex == 0) return EMPTY_ARRAY;\n  const directiveEndIndex = tNode.directiveEnd;\n  if (!includeComponents && tNode.flags & TNodeFlags.isComponent) directiveStartIndex++;\n  return lView.slice(directiveStartIndex, directiveEndIndex);\n}\n\nexport function getComponentAtNodeIndex(nodeIndex: number, lView: LView): {}|null {\n  const tNode = lView[TVIEW].data[nodeIndex] as TNode;\n  let directiveStartIndex = tNode.directiveStart;\n  return tNode.flags & TNodeFlags.isComponent ? lView[directiveStartIndex] : null;\n}\n\n/**\n * Returns a map of local references (local reference name => element or directive instance) that\n * exist on a given element.\n */\nexport function discoverLocalRefs(lView: LView, nodeIndex: number): {[key: string]: any}|null {\n  const tNode = lView[TVIEW].data[nodeIndex] as TNode;\n  if (tNode && tNode.localNames) {\n    const result: {[key: string]: any} = {};\n    let localIndex = tNode.index + 1;\n    for (let i = 0; i < tNode.localNames.length; i += 2) {\n      result[tNode.localNames[i]] = lView[localIndex];\n      localIndex++;\n    }\n    return result;\n  }\n\n  return null;\n}\n"]}