@angular/core
Version:
Angular - the core framework
254 lines • 36.5 kB
JavaScript
/*!
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { internalAfterNextRender } from '../render3/after_render_hooks';
import { assertLContainer, assertLView } from '../render3/assert';
import { CONTAINER_HEADER_OFFSET } from '../render3/interfaces/container';
import { isDestroyed } from '../render3/interfaces/type_checks';
import { HEADER_OFFSET, INJECTOR } from '../render3/interfaces/view';
import { getNativeByIndex, removeLViewOnDestroy, storeLViewOnDestroy, walkUpViews, } from '../render3/util/view_utils';
import { assertElement, assertEqual } from '../util/assert';
import { NgZone } from '../zone';
import { storeTriggerCleanupFn } from './cleanup';
import { DEFER_BLOCK_STATE, DeferBlockInternalState, DeferBlockState, } from './interfaces';
import { getLDeferBlockDetails } from './utils';
/** Configuration object used to register passive and capturing events. */
const eventListenerOptions = {
passive: true,
capture: true,
};
/** Keeps track of the currently-registered `on hover` triggers. */
const hoverTriggers = new WeakMap();
/** Keeps track of the currently-registered `on interaction` triggers. */
const interactionTriggers = new WeakMap();
/** Currently-registered `viewport` triggers. */
const viewportTriggers = new WeakMap();
/** Names of the events considered as interaction events. */
const interactionEventNames = ['click', 'keydown'];
/** Names of the events considered as hover events. */
const hoverEventNames = ['mouseenter', 'focusin'];
/** `IntersectionObserver` used to observe `viewport` triggers. */
let intersectionObserver = null;
/** Number of elements currently observed with `viewport` triggers. */
let observedViewportElements = 0;
/** Object keeping track of registered callbacks for a deferred block trigger. */
class DeferEventEntry {
constructor() {
this.callbacks = new Set();
this.listener = () => {
for (const callback of this.callbacks) {
callback();
}
};
}
}
/**
* Registers an interaction trigger.
* @param trigger Element that is the trigger.
* @param callback Callback to be invoked when the trigger is interacted with.
*/
export function onInteraction(trigger, callback) {
let entry = interactionTriggers.get(trigger);
// If this is the first entry for this element, add the listeners.
if (!entry) {
// Note that managing events centrally like this lends itself well to using global
// event delegation. It currently does delegation at the element level, rather than the
// document level, because:
// 1. Global delegation is the most effective when there are a lot of events being registered
// at the same time. Deferred blocks are unlikely to be used in such a way.
// 2. Matching events to their target isn't free. For each `click` and `keydown` event we
// would have look through all the triggers and check if the target either is the element
// itself or it's contained within the element. Given that `click` and `keydown` are some
// of the most common events, this may end up introducing a lot of runtime overhead.
// 3. We're still registering only two events per element, no matter how many deferred blocks
// are referencing it.
entry = new DeferEventEntry();
interactionTriggers.set(trigger, entry);
for (const name of interactionEventNames) {
trigger.addEventListener(name, entry.listener, eventListenerOptions);
}
}
entry.callbacks.add(callback);
return () => {
const { callbacks, listener } = entry;
callbacks.delete(callback);
if (callbacks.size === 0) {
interactionTriggers.delete(trigger);
for (const name of interactionEventNames) {
trigger.removeEventListener(name, listener, eventListenerOptions);
}
}
};
}
/**
* Registers a hover trigger.
* @param trigger Element that is the trigger.
* @param callback Callback to be invoked when the trigger is hovered over.
*/
export function onHover(trigger, callback) {
let entry = hoverTriggers.get(trigger);
// If this is the first entry for this element, add the listener.
if (!entry) {
entry = new DeferEventEntry();
hoverTriggers.set(trigger, entry);
for (const name of hoverEventNames) {
trigger.addEventListener(name, entry.listener, eventListenerOptions);
}
}
entry.callbacks.add(callback);
return () => {
const { callbacks, listener } = entry;
callbacks.delete(callback);
if (callbacks.size === 0) {
for (const name of hoverEventNames) {
trigger.removeEventListener(name, listener, eventListenerOptions);
}
hoverTriggers.delete(trigger);
}
};
}
/**
* Registers a viewport trigger.
* @param trigger Element that is the trigger.
* @param callback Callback to be invoked when the trigger comes into the viewport.
* @param injector Injector that can be used by the trigger to resolve DI tokens.
*/
export function onViewport(trigger, callback, injector) {
const ngZone = injector.get(NgZone);
let entry = viewportTriggers.get(trigger);
intersectionObserver =
intersectionObserver ||
ngZone.runOutsideAngular(() => {
return new IntersectionObserver((entries) => {
for (const current of entries) {
// Only invoke the callbacks if the specific element is intersecting.
if (current.isIntersecting && viewportTriggers.has(current.target)) {
ngZone.run(viewportTriggers.get(current.target).listener);
}
}
});
});
if (!entry) {
entry = new DeferEventEntry();
ngZone.runOutsideAngular(() => intersectionObserver.observe(trigger));
viewportTriggers.set(trigger, entry);
observedViewportElements++;
}
entry.callbacks.add(callback);
return () => {
// It's possible that a different cleanup callback fully removed this element already.
if (!viewportTriggers.has(trigger)) {
return;
}
entry.callbacks.delete(callback);
if (entry.callbacks.size === 0) {
intersectionObserver?.unobserve(trigger);
viewportTriggers.delete(trigger);
observedViewportElements--;
}
if (observedViewportElements === 0) {
intersectionObserver?.disconnect();
intersectionObserver = null;
}
};
}
/**
* Helper function to get the LView in which a deferred block's trigger is rendered.
* @param deferredHostLView LView in which the deferred block is defined.
* @param deferredTNode TNode defining the deferred block.
* @param walkUpTimes Number of times to go up in the view hierarchy to find the trigger's view.
* A negative value means that the trigger is inside the block's placeholder, while an undefined
* value means that the trigger is in the same LView as the deferred block.
*/
export function getTriggerLView(deferredHostLView, deferredTNode, walkUpTimes) {
// The trigger is in the same view, we don't need to traverse.
if (walkUpTimes == null) {
return deferredHostLView;
}
// A positive value or zero means that the trigger is in a parent view.
if (walkUpTimes >= 0) {
return walkUpViews(walkUpTimes, deferredHostLView);
}
// If the value is negative, it means that the trigger is inside the placeholder.
const deferredContainer = deferredHostLView[deferredTNode.index];
ngDevMode && assertLContainer(deferredContainer);
const triggerLView = deferredContainer[CONTAINER_HEADER_OFFSET] ?? null;
// We need to null check, because the placeholder might not have been rendered yet.
if (ngDevMode && triggerLView !== null) {
const lDetails = getLDeferBlockDetails(deferredHostLView, deferredTNode);
const renderedState = lDetails[DEFER_BLOCK_STATE];
assertEqual(renderedState, DeferBlockState.Placeholder, 'Expected a placeholder to be rendered in this defer block.');
assertLView(triggerLView);
}
return triggerLView;
}
/**
* Gets the element that a deferred block's trigger is pointing to.
* @param triggerLView LView in which the trigger is defined.
* @param triggerIndex Index at which the trigger element should've been rendered.
*/
export function getTriggerElement(triggerLView, triggerIndex) {
const element = getNativeByIndex(HEADER_OFFSET + triggerIndex, triggerLView);
ngDevMode && assertElement(element);
return element;
}
/**
* Registers a DOM-node based trigger.
* @param initialLView LView in which the defer block is rendered.
* @param tNode TNode representing the defer block.
* @param triggerIndex Index at which to find the trigger element.
* @param walkUpTimes Number of times to go up/down in the view hierarchy to find the trigger.
* @param registerFn Function that will register the DOM events.
* @param callback Callback to be invoked when the trigger receives the event that should render
* the deferred block.
* @param type Trigger type to distinguish between regular and prefetch triggers.
*/
export function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, registerFn, callback, type) {
const injector = initialLView[INJECTOR];
function pollDomTrigger() {
// If the initial view was destroyed, we don't need to do anything.
if (isDestroyed(initialLView)) {
return;
}
const lDetails = getLDeferBlockDetails(initialLView, tNode);
const renderedState = lDetails[DEFER_BLOCK_STATE];
// If the block was loaded before the trigger was resolved, we don't need to do anything.
if (renderedState !== DeferBlockInternalState.Initial &&
renderedState !== DeferBlockState.Placeholder) {
return;
}
const triggerLView = getTriggerLView(initialLView, tNode, walkUpTimes);
// Keep polling until we resolve the trigger's LView.
if (!triggerLView) {
internalAfterNextRender(pollDomTrigger, { injector });
return;
}
// It's possible that the trigger's view was destroyed before we resolved the trigger element.
if (isDestroyed(triggerLView)) {
return;
}
const element = getTriggerElement(triggerLView, triggerIndex);
const cleanup = registerFn(element, () => {
if (initialLView !== triggerLView) {
removeLViewOnDestroy(triggerLView, cleanup);
}
callback();
}, injector);
// The trigger and deferred block might be in different LViews.
// For the main LView the cleanup would happen as a part of
// `storeTriggerCleanupFn` logic. For trigger LView we register
// a cleanup function there to remove event handlers in case an
// LView gets destroyed before a trigger is invoked.
if (initialLView !== triggerLView) {
storeLViewOnDestroy(triggerLView, cleanup);
}
storeTriggerCleanupFn(type, lDetails, cleanup);
}
// Begin polling for the trigger.
internalAfterNextRender(pollDomTrigger, { injector });
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dom_triggers.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/defer/dom_triggers.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 type {Injector} from '../di';\nimport {internalAfterNextRender} from '../render3/after_render_hooks';\nimport {assertLContainer, assertLView} from '../render3/assert';\nimport {CONTAINER_HEADER_OFFSET} from '../render3/interfaces/container';\nimport {TNode} from '../render3/interfaces/node';\nimport {isDestroyed} from '../render3/interfaces/type_checks';\nimport {HEADER_OFFSET, INJECTOR, LView} from '../render3/interfaces/view';\nimport {\n  getNativeByIndex,\n  removeLViewOnDestroy,\n  storeLViewOnDestroy,\n  walkUpViews,\n} from '../render3/util/view_utils';\nimport {assertElement, assertEqual} from '../util/assert';\nimport {NgZone} from '../zone';\nimport {storeTriggerCleanupFn} from './cleanup';\n\nimport {\n  DEFER_BLOCK_STATE,\n  DeferBlockInternalState,\n  DeferBlockState,\n  TriggerType,\n} from './interfaces';\nimport {getLDeferBlockDetails} from './utils';\n\n/** Configuration object used to register passive and capturing events. */\nconst eventListenerOptions: AddEventListenerOptions = {\n  passive: true,\n  capture: true,\n};\n\n/** Keeps track of the currently-registered `on hover` triggers. */\nconst hoverTriggers = new WeakMap<Element, DeferEventEntry>();\n\n/** Keeps track of the currently-registered `on interaction` triggers. */\nconst interactionTriggers = new WeakMap<Element, DeferEventEntry>();\n\n/** Currently-registered `viewport` triggers. */\nconst viewportTriggers = new WeakMap<Element, DeferEventEntry>();\n\n/** Names of the events considered as interaction events. */\nconst interactionEventNames = ['click', 'keydown'] as const;\n\n/** Names of the events considered as hover events. */\nconst hoverEventNames = ['mouseenter', 'focusin'] as const;\n\n/** `IntersectionObserver` used to observe `viewport` triggers. */\nlet intersectionObserver: IntersectionObserver | null = null;\n\n/** Number of elements currently observed with `viewport` triggers. */\nlet observedViewportElements = 0;\n\n/** Object keeping track of registered callbacks for a deferred block trigger. */\nclass DeferEventEntry {\n  callbacks = new Set<VoidFunction>();\n\n  listener = () => {\n    for (const callback of this.callbacks) {\n      callback();\n    }\n  };\n}\n\n/**\n * Registers an interaction trigger.\n * @param trigger Element that is the trigger.\n * @param callback Callback to be invoked when the trigger is interacted with.\n */\nexport function onInteraction(trigger: Element, callback: VoidFunction): VoidFunction {\n  let entry = interactionTriggers.get(trigger);\n\n  // If this is the first entry for this element, add the listeners.\n  if (!entry) {\n    // Note that managing events centrally like this lends itself well to using global\n    // event delegation. It currently does delegation at the element level, rather than the\n    // document level, because:\n    // 1. Global delegation is the most effective when there are a lot of events being registered\n    // at the same time. Deferred blocks are unlikely to be used in such a way.\n    // 2. Matching events to their target isn't free. For each `click` and `keydown` event we\n    // would have look through all the triggers and check if the target either is the element\n    // itself or it's contained within the element. Given that `click` and `keydown` are some\n    // of the most common events, this may end up introducing a lot of runtime overhead.\n    // 3. We're still registering only two events per element, no matter how many deferred blocks\n    // are referencing it.\n    entry = new DeferEventEntry();\n    interactionTriggers.set(trigger, entry);\n\n    for (const name of interactionEventNames) {\n      trigger.addEventListener(name, entry!.listener, eventListenerOptions);\n    }\n  }\n\n  entry.callbacks.add(callback);\n\n  return () => {\n    const {callbacks, listener} = entry!;\n    callbacks.delete(callback);\n\n    if (callbacks.size === 0) {\n      interactionTriggers.delete(trigger);\n\n      for (const name of interactionEventNames) {\n        trigger.removeEventListener(name, listener, eventListenerOptions);\n      }\n    }\n  };\n}\n\n/**\n * Registers a hover trigger.\n * @param trigger Element that is the trigger.\n * @param callback Callback to be invoked when the trigger is hovered over.\n */\nexport function onHover(trigger: Element, callback: VoidFunction): VoidFunction {\n  let entry = hoverTriggers.get(trigger);\n\n  // If this is the first entry for this element, add the listener.\n  if (!entry) {\n    entry = new DeferEventEntry();\n    hoverTriggers.set(trigger, entry);\n\n    for (const name of hoverEventNames) {\n      trigger.addEventListener(name, entry!.listener, eventListenerOptions);\n    }\n  }\n\n  entry.callbacks.add(callback);\n\n  return () => {\n    const {callbacks, listener} = entry!;\n    callbacks.delete(callback);\n\n    if (callbacks.size === 0) {\n      for (const name of hoverEventNames) {\n        trigger.removeEventListener(name, listener, eventListenerOptions);\n      }\n      hoverTriggers.delete(trigger);\n    }\n  };\n}\n\n/**\n * Registers a viewport trigger.\n * @param trigger Element that is the trigger.\n * @param callback Callback to be invoked when the trigger comes into the viewport.\n * @param injector Injector that can be used by the trigger to resolve DI tokens.\n */\nexport function onViewport(\n  trigger: Element,\n  callback: VoidFunction,\n  injector: Injector,\n): VoidFunction {\n  const ngZone = injector.get(NgZone);\n  let entry = viewportTriggers.get(trigger);\n\n  intersectionObserver =\n    intersectionObserver ||\n    ngZone.runOutsideAngular(() => {\n      return new IntersectionObserver((entries) => {\n        for (const current of entries) {\n          // Only invoke the callbacks if the specific element is intersecting.\n          if (current.isIntersecting && viewportTriggers.has(current.target)) {\n            ngZone.run(viewportTriggers.get(current.target)!.listener);\n          }\n        }\n      });\n    });\n\n  if (!entry) {\n    entry = new DeferEventEntry();\n    ngZone.runOutsideAngular(() => intersectionObserver!.observe(trigger));\n    viewportTriggers.set(trigger, entry);\n    observedViewportElements++;\n  }\n\n  entry.callbacks.add(callback);\n\n  return () => {\n    // It's possible that a different cleanup callback fully removed this element already.\n    if (!viewportTriggers.has(trigger)) {\n      return;\n    }\n\n    entry!.callbacks.delete(callback);\n\n    if (entry!.callbacks.size === 0) {\n      intersectionObserver?.unobserve(trigger);\n      viewportTriggers.delete(trigger);\n      observedViewportElements--;\n    }\n\n    if (observedViewportElements === 0) {\n      intersectionObserver?.disconnect();\n      intersectionObserver = null;\n    }\n  };\n}\n\n/**\n * Helper function to get the LView in which a deferred block's trigger is rendered.\n * @param deferredHostLView LView in which the deferred block is defined.\n * @param deferredTNode TNode defining the deferred block.\n * @param walkUpTimes Number of times to go up in the view hierarchy to find the trigger's view.\n *   A negative value means that the trigger is inside the block's placeholder, while an undefined\n *   value means that the trigger is in the same LView as the deferred block.\n */\nexport function getTriggerLView(\n  deferredHostLView: LView,\n  deferredTNode: TNode,\n  walkUpTimes: number | undefined,\n): LView | null {\n  // The trigger is in the same view, we don't need to traverse.\n  if (walkUpTimes == null) {\n    return deferredHostLView;\n  }\n\n  // A positive value or zero means that the trigger is in a parent view.\n  if (walkUpTimes >= 0) {\n    return walkUpViews(walkUpTimes, deferredHostLView);\n  }\n\n  // If the value is negative, it means that the trigger is inside the placeholder.\n  const deferredContainer = deferredHostLView[deferredTNode.index];\n  ngDevMode && assertLContainer(deferredContainer);\n  const triggerLView = deferredContainer[CONTAINER_HEADER_OFFSET] ?? null;\n\n  // We need to null check, because the placeholder might not have been rendered yet.\n  if (ngDevMode && triggerLView !== null) {\n    const lDetails = getLDeferBlockDetails(deferredHostLView, deferredTNode);\n    const renderedState = lDetails[DEFER_BLOCK_STATE];\n    assertEqual(\n      renderedState,\n      DeferBlockState.Placeholder,\n      'Expected a placeholder to be rendered in this defer block.',\n    );\n    assertLView(triggerLView);\n  }\n\n  return triggerLView;\n}\n\n/**\n * Gets the element that a deferred block's trigger is pointing to.\n * @param triggerLView LView in which the trigger is defined.\n * @param triggerIndex Index at which the trigger element should've been rendered.\n */\nexport function getTriggerElement(triggerLView: LView, triggerIndex: number): Element {\n  const element = getNativeByIndex(HEADER_OFFSET + triggerIndex, triggerLView);\n  ngDevMode && assertElement(element);\n  return element as Element;\n}\n\n/**\n * Registers a DOM-node based trigger.\n * @param initialLView LView in which the defer block is rendered.\n * @param tNode TNode representing the defer block.\n * @param triggerIndex Index at which to find the trigger element.\n * @param walkUpTimes Number of times to go up/down in the view hierarchy to find the trigger.\n * @param registerFn Function that will register the DOM events.\n * @param callback Callback to be invoked when the trigger receives the event that should render\n *     the deferred block.\n * @param type Trigger type to distinguish between regular and prefetch triggers.\n */\nexport function registerDomTrigger(\n  initialLView: LView,\n  tNode: TNode,\n  triggerIndex: number,\n  walkUpTimes: number | undefined,\n  registerFn: (element: Element, callback: VoidFunction, injector: Injector) => VoidFunction,\n  callback: VoidFunction,\n  type: TriggerType,\n) {\n  const injector = initialLView[INJECTOR]!;\n  function pollDomTrigger() {\n    // If the initial view was destroyed, we don't need to do anything.\n    if (isDestroyed(initialLView)) {\n      return;\n    }\n\n    const lDetails = getLDeferBlockDetails(initialLView, tNode);\n    const renderedState = lDetails[DEFER_BLOCK_STATE];\n\n    // If the block was loaded before the trigger was resolved, we don't need to do anything.\n    if (\n      renderedState !== DeferBlockInternalState.Initial &&\n      renderedState !== DeferBlockState.Placeholder\n    ) {\n      return;\n    }\n\n    const triggerLView = getTriggerLView(initialLView, tNode, walkUpTimes);\n\n    // Keep polling until we resolve the trigger's LView.\n    if (!triggerLView) {\n      internalAfterNextRender(pollDomTrigger, {injector});\n      return;\n    }\n\n    // It's possible that the trigger's view was destroyed before we resolved the trigger element.\n    if (isDestroyed(triggerLView)) {\n      return;\n    }\n\n    const element = getTriggerElement(triggerLView, triggerIndex);\n    const cleanup = registerFn(\n      element,\n      () => {\n        if (initialLView !== triggerLView) {\n          removeLViewOnDestroy(triggerLView, cleanup);\n        }\n        callback();\n      },\n      injector,\n    );\n\n    // The trigger and deferred block might be in different LViews.\n    // For the main LView the cleanup would happen as a part of\n    // `storeTriggerCleanupFn` logic. For trigger LView we register\n    // a cleanup function there to remove event handlers in case an\n    // LView gets destroyed before a trigger is invoked.\n    if (initialLView !== triggerLView) {\n      storeLViewOnDestroy(triggerLView, cleanup);\n    }\n\n    storeTriggerCleanupFn(type, lDetails, cleanup);\n  }\n\n  // Begin polling for the trigger.\n  internalAfterNextRender(pollDomTrigger, {injector});\n}\n"]}