@angular/core 18.0.0-next.5 → 18.0.0-next.6

package/esm2022/src/hydration/event_replay.mjs

@@ -0,0 +1,181 @@
+/**
+ * @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 { Dispatcher, registerDispatcher } from '@angular/core/primitives/event-dispatch';
+import { APP_BOOTSTRAP_LISTENER, ApplicationRef, whenStable } from '../application/application_ref';
+import { APP_ID } from '../application/application_tokens';
+import { Injector } from '../di';
+import { inject } from '../di/injector_compatibility';
+import { attachLViewId, readLView } from '../render3/context_discovery';
+import { CLEANUP, TVIEW } from '../render3/interfaces/view';
+import { isPlatformBrowser } from '../render3/util/misc_utils';
+import { unwrapRNode } from '../render3/util/view_utils';
+import { IS_EVENT_REPLAY_ENABLED } from './tokens';
+export const EVENT_REPLAY_ENABLED_DEFAULT = false;
+export const CONTRACT_PROPERTY = 'ngContracts';
+/**
+ * Returns a set of providers required to setup support for event replay.
+ * Requires hydration to be enabled separately.
+ */
+export function withEventReplay() {
+    return [
+        {
+            provide: IS_EVENT_REPLAY_ENABLED,
+            useValue: true,
+        },
+        {
+            provide: APP_BOOTSTRAP_LISTENER,
+            useFactory: () => {
+                if (isPlatformBrowser()) {
+                    const injector = inject(Injector);
+                    const appRef = inject(ApplicationRef);
+                    return () => {
+                        // Kick off event replay logic once hydration for the initial part
+                        // of the application is completed. This timing is similar to the unclaimed
+                        // dehydrated views cleanup timing.
+                        whenStable(appRef).then(() => {
+                            const appId = injector.get(APP_ID);
+                            // This is set in packages/platform-server/src/utils.ts
+                            // Note: globalThis[CONTRACT_PROPERTY] may be undefined in case Event Replay feature
+                            // is enabled, but there are no events configured in an application.
+                            const eventContract = globalThis[CONTRACT_PROPERTY]?.[appId];
+                            if (eventContract) {
+                                const dispatcher = new Dispatcher();
+                                setEventReplayer(dispatcher);
+                                // Event replay is kicked off as a side-effect of executing this function.
+                                registerDispatcher(eventContract, dispatcher);
+                            }
+                        });
+                    };
+                }
+                return () => { }; // noop for the server code
+            },
+            multi: true,
+        }
+    ];
+}
+/**
+ * Extracts information about all DOM events (added in a template) registered on elements in a give
+ * LView. Maps collected events to a corresponding DOM element (an element is used as a key).
+ */
+export function collectDomEventsInfo(tView, lView, eventTypesToReplay) {
+    const events = new Map();
+    const lCleanup = lView[CLEANUP];
+    const tCleanup = tView.cleanup;
+    if (!tCleanup || !lCleanup) {
+        return events;
+    }
+    for (let i = 0; i < tCleanup.length;) {
+        const firstParam = tCleanup[i++];
+        const secondParam = tCleanup[i++];
+        if (typeof firstParam !== 'string') {
+            continue;
+        }
+        const name = firstParam;
+        eventTypesToReplay.add(name);
+        const listenerElement = unwrapRNode(lView[secondParam]);
+        i++; // move the cursor to the next position (location of the listener idx)
+        const useCaptureOrIndx = tCleanup[i++];
+        // if useCaptureOrIndx is boolean then report it as is.
+        // if useCaptureOrIndx is positive number then it in unsubscribe method
+        // if useCaptureOrIndx is negative number then it is a Subscription
+        const isDomEvent = typeof useCaptureOrIndx === 'boolean' || useCaptureOrIndx >= 0;
+        if (!isDomEvent) {
+            continue;
+        }
+        if (!events.has(listenerElement)) {
+            events.set(listenerElement, [name]);
+        }
+        else {
+            events.get(listenerElement).push(name);
+        }
+    }
+    return events;
+}
+export function setJSActionAttribute(tNode, rNode, nativeElementToEvents) {
+    if (tNode.type & 2 /* TNodeType.Element */) {
+        const nativeElement = unwrapRNode(rNode);
+        const events = nativeElementToEvents.get(nativeElement) ?? [];
+        const parts = events.map(event => `${event}:`);
+        if (parts.length > 0) {
+            nativeElement.setAttribute('jsaction', parts.join(';'));
+        }
+    }
+}
+/**
+ * Registers a function that should be invoked to replay events.
+ */
+function setEventReplayer(dispatcher) {
+    dispatcher.setEventReplayer(queue => {
+        for (const event of queue) {
+            handleEvent(event);
+        }
+    });
+}
+/**
+ * Finds an LView that a given DOM element belongs to.
+ */
+function getLViewByElement(target) {
+    let lView = readLView(target);
+    if (lView) {
+        return lView;
+    }
+    else {
+        // If this node doesn't have LView info attached, then we need to
+        // traverse upwards up the DOM to find the nearest element that
+        // has already been monkey patched with data.
+        let parent = target;
+        while (parent = parent.parentNode) {
+            lView = readLView(parent);
+            if (lView) {
+                // To prevent additional lookups, monkey-patch LView id onto this DOM node.
+                // TODO: consider patching all parent nodes that didn't have LView id, so that
+                // we can avoid lookups for more nodes.
+                attachLViewId(target, lView);
+                return lView;
+            }
+        }
+    }
+    return null;
+}
+function handleEvent(event) {
+    const nativeElement = event.getAction().element;
+    // Dispatch event via Angular's logic
+    if (nativeElement) {
+        const lView = getLViewByElement(nativeElement);
+        if (lView !== null) {
+            const tView = lView[TVIEW];
+            const eventName = event.getEventType();
+            const origEvent = event.getEvent();
+            const listeners = getEventListeners(tView, lView, nativeElement, eventName);
+            for (const listener of listeners) {
+                listener(origEvent);
+            }
+        }
+    }
+}
+function getEventListeners(tView, lView, nativeElement, eventName) {
+    const listeners = [];
+    const lCleanup = lView[CLEANUP];
+    const tCleanup = tView.cleanup;
+    if (tCleanup && lCleanup) {
+        for (let i = 0; i < tCleanup.length;) {
+            const storedEventName = tCleanup[i++];
+            const nativeElementIndex = tCleanup[i++];
+            if (typeof storedEventName === 'string') {
+                const listenerElement = unwrapRNode(lView[nativeElementIndex]);
+                const listener = lCleanup[tCleanup[i++]];
+                i++; // increment to the next position;
+                if (listenerElement === nativeElement && eventName === storedEventName) {
+                    listeners.push(listener);
+                }
+            }
+        }
+    }
+    return listeners;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event_replay.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/hydration/event_replay.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC 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 {Dispatcher, EventContract, EventInfoWrapper, registerDispatcher} from '@angular/core/primitives/event-dispatch';\n\nimport {APP_BOOTSTRAP_LISTENER, ApplicationRef, whenStable} from '../application/application_ref';\nimport {APP_ID} from '../application/application_tokens';\nimport {Injector} from '../di';\nimport {inject} from '../di/injector_compatibility';\nimport {Provider} from '../di/interface/provider';\nimport {attachLViewId, readLView} from '../render3/context_discovery';\nimport {TNode, TNodeType} from '../render3/interfaces/node';\nimport {RNode} from '../render3/interfaces/renderer_dom';\nimport {CLEANUP, LView, TVIEW, TView} from '../render3/interfaces/view';\nimport {isPlatformBrowser} from '../render3/util/misc_utils';\nimport {unwrapRNode} from '../render3/util/view_utils';\n\nimport {IS_EVENT_REPLAY_ENABLED} from './tokens';\n\nexport const EVENT_REPLAY_ENABLED_DEFAULT = false;\nexport const CONTRACT_PROPERTY = 'ngContracts';\n\ndeclare global {\n  var ngContracts: {[key: string]: EventContract};\n}\n\n/**\n * Returns a set of providers required to setup support for event replay.\n * Requires hydration to be enabled separately.\n */\nexport function withEventReplay(): Provider[] {\n  return [\n    {\n      provide: IS_EVENT_REPLAY_ENABLED,\n      useValue: true,\n    },\n    {\n      provide: APP_BOOTSTRAP_LISTENER,\n      useFactory: () => {\n        if (isPlatformBrowser()) {\n          const injector = inject(Injector);\n          const appRef = inject(ApplicationRef);\n          return () => {\n            // Kick off event replay logic once hydration for the initial part\n            // of the application is completed. This timing is similar to the unclaimed\n            // dehydrated views cleanup timing.\n            whenStable(appRef).then(() => {\n              const appId = injector.get(APP_ID);\n              // This is set in packages/platform-server/src/utils.ts\n              // Note: globalThis[CONTRACT_PROPERTY] may be undefined in case Event Replay feature\n              // is enabled, but there are no events configured in an application.\n              const eventContract = globalThis[CONTRACT_PROPERTY]?.[appId] as EventContract;\n              if (eventContract) {\n                const dispatcher = new Dispatcher();\n                setEventReplayer(dispatcher);\n                // Event replay is kicked off as a side-effect of executing this function.\n                registerDispatcher(eventContract, dispatcher);\n              }\n            });\n          };\n        }\n        return () => {};  // noop for the server code\n      },\n      multi: true,\n    }\n  ];\n}\n\n/**\n * Extracts information about all DOM events (added in a template) registered on elements in a give\n * LView. Maps collected events to a corresponding DOM element (an element is used as a key).\n */\nexport function collectDomEventsInfo(\n    tView: TView, lView: LView, eventTypesToReplay: Set<string>): Map<Element, string[]> {\n  const events = new Map<Element, string[]>();\n  const lCleanup = lView[CLEANUP];\n  const tCleanup = tView.cleanup;\n  if (!tCleanup || !lCleanup) {\n    return events;\n  }\n  for (let i = 0; i < tCleanup.length;) {\n    const firstParam = tCleanup[i++];\n    const secondParam = tCleanup[i++];\n    if (typeof firstParam !== 'string') {\n      continue;\n    }\n    const name: string = firstParam;\n    eventTypesToReplay.add(name);\n    const listenerElement = unwrapRNode(lView[secondParam]) as any as Element;\n    i++;  // move the cursor to the next position (location of the listener idx)\n    const useCaptureOrIndx = tCleanup[i++];\n    // if useCaptureOrIndx is boolean then report it as is.\n    // if useCaptureOrIndx is positive number then it in unsubscribe method\n    // if useCaptureOrIndx is negative number then it is a Subscription\n    const isDomEvent = typeof useCaptureOrIndx === 'boolean' || useCaptureOrIndx >= 0;\n    if (!isDomEvent) {\n      continue;\n    }\n    if (!events.has(listenerElement)) {\n      events.set(listenerElement, [name]);\n    } else {\n      events.get(listenerElement)!.push(name);\n    }\n  }\n  return events;\n}\n\nexport function setJSActionAttribute(\n    tNode: TNode, rNode: RNode, nativeElementToEvents: Map<Element, string[]>) {\n  if (tNode.type & TNodeType.Element) {\n    const nativeElement = unwrapRNode(rNode) as Element;\n    const events = nativeElementToEvents.get(nativeElement) ?? [];\n    const parts = events.map(event => `${event}:`);\n    if (parts.length > 0) {\n      nativeElement.setAttribute('jsaction', parts.join(';'));\n    }\n  }\n}\n\n/**\n * Registers a function that should be invoked to replay events.\n */\nfunction setEventReplayer(dispatcher: Dispatcher) {\n  dispatcher.setEventReplayer(queue => {\n    for (const event of queue) {\n      handleEvent(event);\n    }\n  });\n}\n\n/**\n * Finds an LView that a given DOM element belongs to.\n */\nfunction getLViewByElement(target: HTMLElement): LView|null {\n  let lView = readLView(target);\n  if (lView) {\n    return lView;\n  } else {\n    // If this node doesn't have LView info attached, then we need to\n    // traverse upwards up the DOM to find the nearest element that\n    // has already been monkey patched with data.\n    let parent = target as HTMLElement;\n    while (parent = parent.parentNode as HTMLElement) {\n      lView = readLView(parent);\n      if (lView) {\n        // To prevent additional lookups, monkey-patch LView id onto this DOM node.\n        // TODO: consider patching all parent nodes that didn't have LView id, so that\n        // we can avoid lookups for more nodes.\n        attachLViewId(target, lView);\n        return lView;\n      }\n    }\n  }\n  return null;\n}\n\nfunction handleEvent(event: EventInfoWrapper) {\n  const nativeElement = event.getAction()!.element;\n  // Dispatch event via Angular's logic\n  if (nativeElement) {\n    const lView = getLViewByElement(nativeElement as HTMLElement);\n    if (lView !== null) {\n      const tView = lView[TVIEW];\n      const eventName = event.getEventType();\n      const origEvent = event.getEvent();\n      const listeners = getEventListeners(tView, lView, nativeElement, eventName);\n      for (const listener of listeners) {\n        listener(origEvent);\n      }\n    }\n  }\n}\n\ntype Listener = ((value: Event) => unknown)|(() => unknown);\n\nfunction getEventListeners(\n    tView: TView, lView: LView, nativeElement: Element, eventName: string): Listener[] {\n  const listeners: Listener[] = [];\n  const lCleanup = lView[CLEANUP];\n  const tCleanup = tView.cleanup;\n  if (tCleanup && lCleanup) {\n    for (let i = 0; i < tCleanup.length;) {\n      const storedEventName = tCleanup[i++];\n      const nativeElementIndex = tCleanup[i++];\n      if (typeof storedEventName === 'string') {\n        const listenerElement = unwrapRNode(lView[nativeElementIndex]) as any as Element;\n        const listener: Listener = lCleanup[tCleanup[i++]];\n        i++;  // increment to the next position;\n        if (listenerElement === nativeElement && eventName === storedEventName) {\n          listeners.push(listener);\n        }\n      }\n    }\n  }\n  return listeners;\n}\n"]}

package/esm2022/src/hydration/tokens.mjs

@@ -27,4 +27,9 @@ export const PRESERVE_HOST_CONTENT = new InjectionToken((typeof ngDevMode === 'u
  * is enabled.
  */
 export const IS_I18N_HYDRATION_ENABLED = new InjectionToken((typeof ngDevMode === 'undefined' || !!ngDevMode ? 'IS_I18N_HYDRATION_ENABLED' : ''));
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Internal token that indicates whether event replay support for SSR
+ * is enabled.
+ */
+export const IS_EVENT_REPLAY_ENABLED = new InjectionToken((typeof ngDevMode === 'undefined' || !!ngDevMode ? 'IS_EVENT_REPLAY_ENABLED' : ''));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/pending_tasks.mjs

@@ -6,17 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { BehaviorSubject } from 'rxjs';
-import { Injectable } from './di';
+import { inject } from './di';
+import { Injectable } from './di/injectable';
 import * as i0 from "./r3_symbols";
 /**
- * *Internal* service that keeps track of pending tasks happening in the system.
- *
- * This information is needed to make sure that the serialization on the server
- * is delayed until all tasks in the queue (such as an initial navigation or a
- * pending HTTP request) are completed.
- *
- * Pending tasks continue to contribute to the stableness of `ApplicationRef`
- * throughout the lifetime of the application.
+ * Internal implementation of the pending tasks service.
  */
 export class PendingTasks {
     constructor() {
@@ -52,6 +46,55 @@ export class PendingTasks {
 }
 (() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.setClassMetadata(PendingTasks, [{
         type: Injectable,
-        args: [{ providedIn: 'root' }]
+        args: [{
+                providedIn: 'root',
+            }]
+    }], null, null); })();
+/**
+ * Experimental service that keeps track of pending tasks contributing to the stableness of Angular
+ * application. While several existing Angular services (ex.: `HttpClient`) will internally manage
+ * tasks influencing stability, this API gives control over stability to library and application
+ * developers for specific cases not covered by Angular internals.
+ *
+ * The concept of stability comes into play in several important scenarios:
+ * - SSR process needs to wait for the application stability before serializing and sending rendered
+ * HTML;
+ * - tests might want to delay assertions until the application becomes stable;
+ *
+ * @usageNotes
+ * ```typescript
+ * const pendingTasks = inject(ExperimentalPendingTasks);
+ * const taskCleanup = pendingTasks.add();
+ * // do work that should block application's stability and then:
+ * taskCleanup();
+ * ```
+ *
+ * This API is experimental. Neither the shape, nor the underlying behavior is stable and can change
+ * in patch versions. We will iterate on the exact API based on the feedback and our understanding
+ * of the problem and solution space.
+ *
+ * @publicApi
+ * @experimental
+ */
+export class ExperimentalPendingTasks {
+    constructor() {
+        this.internalPendingTasks = inject(PendingTasks);
+    }
+    /**
+     * Adds a new task that should block application's stability.
+     * @returns A cleanup function that removes a task when called.
+     */
+    add() {
+        const taskId = this.internalPendingTasks.add();
+        return () => this.internalPendingTasks.remove(taskId);
+    }
+    static { this.ɵfac = function ExperimentalPendingTasks_Factory(t) { return new (t || ExperimentalPendingTasks)(); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ExperimentalPendingTasks, factory: ExperimentalPendingTasks.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.setClassMetadata(ExperimentalPendingTasks, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/render3/component_ref.mjs

@@ -397,7 +397,7 @@ function createRootComponent(componentView, rootComponentDef, rootDirectives, ho
 function setRootNodeAttributes(hostRenderer, componentDef, hostRNode, rootSelectorOrNode) {
     if (rootSelectorOrNode) {
         // The placeholder will be replaced with the actual version at build time.
-        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '18.0.0-next.5']);
+        setUpAttributes(hostRenderer, hostRNode, ['ng-version', '18.0.0-next.6']);
     }
     else {
         // If host element is created as a part of this function call (i.e. `rootSelectorOrNode`

package/esm2022/src/render3/context_discovery.mjs

@@ -153,6 +153,20 @@ export function getComponentViewByInstance(componentInstance) {
  * This property will be monkey-patched on elements, components and directives.
  */
 const MONKEY_PATCH_KEY_NAME = '__ngContext__';
+export function attachLViewId(target, data) {
+    target[MONKEY_PATCH_KEY_NAME] = data[ID];
+}
+/**
+ * Returns the monkey-patch value data present on the target (which could be
+ * a component, directive or a DOM node).
+ */
+export function readLView(target) {
+    const data = readPatchedData(target);
+    if (isLView(data)) {
+        return data;
+    }
+    return data ? data.lView : null;
+}
 /**
  * Assigns the given data to the given target (which could be a component,
  * directive or DOM node instance) using monkey-patching.
@@ -314,4 +328,4 @@ export function discoverLocalRefs(lView, nodeIndex) {
     }
     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 LLC 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 {assertDefined, assertDomNode} from '../util/assert';\nimport {EMPTY_ARRAY} from '../util/empty';\n\nimport {assertLView} from './assert';\nimport {LContext} from './interfaces/context';\nimport {getLViewById, registerLView} from './interfaces/lview_tracking';\nimport {TNode} from './interfaces/node';\nimport {RElement, RNode} from './interfaces/renderer_dom';\nimport {isLView} from './interfaces/type_checks';\nimport {CONTEXT, HEADER_OFFSET, HOST, ID, LView, TVIEW} from './interfaces/view';\nimport {getComponentLViewByIndex, unwrapRNode} from './util/view_utils';\n\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 (isLView(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);\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        const lView = Array.isArray(parentContext) ? parentContext as LView : parentContext.lView;\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 new LContext(lView[ID], nodeIndex, native);\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 patchedData = readPatchedData(componentInstance);\n  let lView: LView;\n\n  if (isLView(patchedData)) {\n    const contextLView: LView = patchedData;\n    const nodeIndex = findViaComponent(contextLView, componentInstance);\n    lView = getComponentLViewByIndex(nodeIndex, contextLView);\n    const context = createLContext(contextLView, nodeIndex, lView[HOST] as RElement);\n    context.component = componentInstance;\n    attachPatchData(componentInstance, context);\n    attachPatchData(context.native, context);\n  } else {\n    const context = patchedData as unknown as LContext;\n    const contextLView = context.lView!;\n    ngDevMode && assertLView(contextLView);\n    lView = getComponentLViewByIndex(context.nodeIndex, contextLView);\n  }\n  return lView;\n}\n\n/**\n * This property will be monkey-patched on elements, components and directives.\n */\nconst MONKEY_PATCH_KEY_NAME = '__ngContext__';\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  ngDevMode && assertDefined(target, 'Target expected');\n  // Only attach the ID of the view in order to avoid memory leaks (see #41047). We only do this\n  // for `LView`, because we have control over when an `LView` is created and destroyed, whereas\n  // we can't know when to remove an `LContext`.\n  if (isLView(data)) {\n    target[MONKEY_PATCH_KEY_NAME] = data[ID];\n    registerLView(data);\n  } else {\n    target[MONKEY_PATCH_KEY_NAME] = data;\n  }\n}\n\n/**\n * Returns the monkey-patch value data present on the target (which could be\n * a component, directive or a DOM node).\n */\nexport function readPatchedData(target: any): LView|LContext|null {\n  ngDevMode && assertDefined(target, 'Target expected');\n  const data = target[MONKEY_PATCH_KEY_NAME];\n  return (typeof data === 'number') ? getLViewById(data) : data || null;\n}\n\nexport function readPatchedLView<T>(target: any): LView<T>|null {\n  const value = readPatchedData(target);\n  if (value) {\n    return (isLView(value) ? value : value.lView) as LView<T>;\n  }\n  return null;\n}\n\nexport function isComponentInstance(instance: any): boolean {\n  return instance && instance.constructor && instance.constructor.ɵcmp;\n}\n\nexport function isDirectiveInstance(instance: any): boolean {\n  return instance && instance.constructor && instance.constructor.ɵdir;\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  const tView = lView[TVIEW];\n  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {\n    if (unwrapRNode(lView[i]) === target) {\n      return i;\n    }\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 = getComponentLViewByIndex(elementComponentIndex, lView);\n      if (componentView[CONTEXT] === componentInstance) {\n        return elementComponentIndex;\n      }\n    }\n  } else {\n    const rootComponentView = getComponentLViewByIndex(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 applied to a node at a specific index. The list includes\n * directives matched by selector and any host directives, but it excludes components.\n * Use `getComponentAtNodeIndex` to find the component applied to a node.\n *\n * @param nodeIndex The node index\n * @param lView The target view data\n */\nexport function getDirectivesAtNodeIndex(nodeIndex: number, lView: LView): any[]|null {\n  const tNode = lView[TVIEW].data[nodeIndex] as TNode;\n  if (tNode.directiveStart === 0) return EMPTY_ARRAY;\n  const results: any[] = [];\n  for (let i = tNode.directiveStart; i < tNode.directiveEnd; i++) {\n    const directiveInstance = lView[i];\n    if (!isComponentInstance(directiveInstance)) {\n      results.push(directiveInstance);\n    }\n  }\n  return results;\n}\n\nexport function getComponentAtNodeIndex(nodeIndex: number, lView: LView): {}|null {\n  const tNode = lView[TVIEW].data[nodeIndex] as TNode;\n  const {directiveStart, componentOffset} = tNode;\n  return componentOffset > -1 ? lView[directiveStart + componentOffset] : 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"]}
+//# 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 LLC 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 {assertDefined, assertDomNode} from '../util/assert';\nimport {EMPTY_ARRAY} from '../util/empty';\n\nimport {assertLView} from './assert';\nimport {LContext} from './interfaces/context';\nimport {getLViewById, registerLView} from './interfaces/lview_tracking';\nimport {TNode} from './interfaces/node';\nimport {RElement, RNode} from './interfaces/renderer_dom';\nimport {isLView} from './interfaces/type_checks';\nimport {CONTEXT, HEADER_OFFSET, HOST, ID, LView, TVIEW} from './interfaces/view';\nimport {getComponentLViewByIndex, unwrapRNode} from './util/view_utils';\n\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 (isLView(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);\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        const lView = Array.isArray(parentContext) ? parentContext as LView : parentContext.lView;\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 new LContext(lView[ID], nodeIndex, native);\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 patchedData = readPatchedData(componentInstance);\n  let lView: LView;\n\n  if (isLView(patchedData)) {\n    const contextLView: LView = patchedData;\n    const nodeIndex = findViaComponent(contextLView, componentInstance);\n    lView = getComponentLViewByIndex(nodeIndex, contextLView);\n    const context = createLContext(contextLView, nodeIndex, lView[HOST] as RElement);\n    context.component = componentInstance;\n    attachPatchData(componentInstance, context);\n    attachPatchData(context.native, context);\n  } else {\n    const context = patchedData as unknown as LContext;\n    const contextLView = context.lView!;\n    ngDevMode && assertLView(contextLView);\n    lView = getComponentLViewByIndex(context.nodeIndex, contextLView);\n  }\n  return lView;\n}\n\n/**\n * This property will be monkey-patched on elements, components and directives.\n */\nconst MONKEY_PATCH_KEY_NAME = '__ngContext__';\n\nexport function attachLViewId(target: any, data: LView) {\n  target[MONKEY_PATCH_KEY_NAME] = data[ID];\n}\n\n/**\n * Returns the monkey-patch value data present on the target (which could be\n * a component, directive or a DOM node).\n */\nexport function readLView(target: any): LView|null {\n  const data = readPatchedData(target);\n  if (isLView(data)) {\n    return data;\n  }\n  return data ? data.lView : null;\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  ngDevMode && assertDefined(target, 'Target expected');\n  // Only attach the ID of the view in order to avoid memory leaks (see #41047). We only do this\n  // for `LView`, because we have control over when an `LView` is created and destroyed, whereas\n  // we can't know when to remove an `LContext`.\n  if (isLView(data)) {\n    target[MONKEY_PATCH_KEY_NAME] = data[ID];\n    registerLView(data);\n  } else {\n    target[MONKEY_PATCH_KEY_NAME] = data;\n  }\n}\n\n/**\n * Returns the monkey-patch value data present on the target (which could be\n * a component, directive or a DOM node).\n */\nexport function readPatchedData(target: any): LView|LContext|null {\n  ngDevMode && assertDefined(target, 'Target expected');\n  const data = target[MONKEY_PATCH_KEY_NAME];\n  return (typeof data === 'number') ? getLViewById(data) : data || null;\n}\n\nexport function readPatchedLView<T>(target: any): LView<T>|null {\n  const value = readPatchedData(target);\n  if (value) {\n    return (isLView(value) ? value : value.lView) as LView<T>;\n  }\n  return null;\n}\n\nexport function isComponentInstance(instance: any): boolean {\n  return instance && instance.constructor && instance.constructor.ɵcmp;\n}\n\nexport function isDirectiveInstance(instance: any): boolean {\n  return instance && instance.constructor && instance.constructor.ɵdir;\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  const tView = lView[TVIEW];\n  for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {\n    if (unwrapRNode(lView[i]) === target) {\n      return i;\n    }\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 = getComponentLViewByIndex(elementComponentIndex, lView);\n      if (componentView[CONTEXT] === componentInstance) {\n        return elementComponentIndex;\n      }\n    }\n  } else {\n    const rootComponentView = getComponentLViewByIndex(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 applied to a node at a specific index. The list includes\n * directives matched by selector and any host directives, but it excludes components.\n * Use `getComponentAtNodeIndex` to find the component applied to a node.\n *\n * @param nodeIndex The node index\n * @param lView The target view data\n */\nexport function getDirectivesAtNodeIndex(nodeIndex: number, lView: LView): any[]|null {\n  const tNode = lView[TVIEW].data[nodeIndex] as TNode;\n  if (tNode.directiveStart === 0) return EMPTY_ARRAY;\n  const results: any[] = [];\n  for (let i = tNode.directiveStart; i < tNode.directiveEnd; i++) {\n    const directiveInstance = lView[i];\n    if (!isComponentInstance(directiveInstance)) {\n      results.push(directiveInstance);\n    }\n  }\n  return results;\n}\n\nexport function getComponentAtNodeIndex(nodeIndex: number, lView: LView): {}|null {\n  const tNode = lView[TVIEW].data[nodeIndex] as TNode;\n  const {directiveStart, componentOffset} = tNode;\n  return componentOffset > -1 ? lView[directiveStart + componentOffset] : 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"]}