@angular/core 17.0.0-next.7 → 17.0.0-rc.0

package/esm2022/src/defer/discovery.mjs

@@ -0,0 +1,47 @@
+/**
+ * @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 { CONTAINER_HEADER_OFFSET } from '../render3/interfaces/container';
+import { isLContainer, isLView } from '../render3/interfaces/type_checks';
+import { HEADER_OFFSET, TVIEW } from '../render3/interfaces/view';
+import { getTDeferBlockDetails, isTDeferBlockDetails } from './utils';
+/**
+ * Retrieves all defer blocks in a given LView.
+ *
+ * @param lView lView with defer blocks
+ * @param deferBlocks defer block aggregator array
+ */
+export function getDeferBlocks(lView, deferBlocks) {
+    const tView = lView[TVIEW];
+    for (let i = HEADER_OFFSET; i < tView.bindingStartIndex; i++) {
+        if (isLContainer(lView[i])) {
+            const lContainer = lView[i];
+            // An LContainer may represent an instance of a defer block, in which case
+            // we store it as a result. Otherwise, keep iterating over LContainer views and
+            // look for defer blocks.
+            const isLast = i === tView.bindingStartIndex - 1;
+            if (!isLast) {
+                const tNode = tView.data[i];
+                const tDetails = getTDeferBlockDetails(tView, tNode);
+                if (isTDeferBlockDetails(tDetails)) {
+                    deferBlocks.push({ lContainer, lView, tNode, tDetails });
+                    // This LContainer represents a defer block, so we exit
+                    // this iteration and don't inspect views in this LContainer.
+                    continue;
+                }
+            }
+            for (let i = CONTAINER_HEADER_OFFSET; i < lContainer.length; i++) {
+                getDeferBlocks(lContainer[i], deferBlocks);
+            }
+        }
+        else if (isLView(lView[i])) {
+            // This is a component, enter the `getDeferBlocks` recursively.
+            getDeferBlocks(lView[i], deferBlocks);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzY292ZXJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvY29yZS9zcmMvZGVmZXIvZGlzY292ZXJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyx1QkFBdUIsRUFBYSxNQUFNLGlDQUFpQyxDQUFDO0FBRXBGLE9BQU8sRUFBQyxZQUFZLEVBQUUsT0FBTyxFQUFDLE1BQU0sbUNBQW1DLENBQUM7QUFDeEUsT0FBTyxFQUFDLGFBQWEsRUFBUyxLQUFLLEVBQUMsTUFBTSw0QkFBNEIsQ0FBQztBQUd2RSxPQUFPLEVBQUMscUJBQXFCLEVBQUUsb0JBQW9CLEVBQUMsTUFBTSxTQUFTLENBQUM7QUFZcEU7Ozs7O0dBS0c7QUFDSCxNQUFNLFVBQVUsY0FBYyxDQUFDLEtBQVksRUFBRSxXQUFnQztJQUMzRSxNQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDM0IsS0FBSyxJQUFJLENBQUMsR0FBRyxhQUFhLEVBQUUsQ0FBQyxHQUFHLEtBQUssQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLEVBQUUsRUFBRTtRQUM1RCxJQUFJLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRTtZQUMxQixNQUFNLFVBQVUsR0FBRyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDNUIsMEVBQTBFO1lBQzFFLCtFQUErRTtZQUMvRSx5QkFBeUI7WUFDekIsTUFBTSxNQUFNLEdBQUcsQ0FBQyxLQUFLLEtBQUssQ0FBQyxpQkFBaUIsR0FBRyxDQUFDLENBQUM7WUFDakQsSUFBSSxDQUFDLE1BQU0sRUFBRTtnQkFDWCxNQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBVSxDQUFDO2dCQUNyQyxNQUFNLFFBQVEsR0FBRyxxQkFBcUIsQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUM7Z0JBQ3JELElBQUksb0JBQW9CLENBQUMsUUFBUSxDQUFDLEVBQUU7b0JBQ2xDLFdBQVcsQ0FBQyxJQUFJLENBQUMsRUFBQyxVQUFVLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUMsQ0FBQyxDQUFDO29CQUN2RCx1REFBdUQ7b0JBQ3ZELDZEQUE2RDtvQkFDN0QsU0FBUztpQkFDVjthQUNGO1lBQ0QsS0FBSyxJQUFJLENBQUMsR0FBRyx1QkFBdUIsRUFBRSxDQUFDLEdBQUcsVUFBVSxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRTtnQkFDaEUsY0FBYyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQVUsRUFBRSxXQUFXLENBQUMsQ0FBQzthQUNyRDtTQUNGO2FBQU0sSUFBSSxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUU7WUFDNUIsK0RBQStEO1lBQy9ELGNBQWMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsV0FBVyxDQUFDLENBQUM7U0FDdkM7S0FDRjtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHtDT05UQUlORVJfSEVBREVSX09GRlNFVCwgTENvbnRhaW5lcn0gZnJvbSAnLi4vcmVuZGVyMy9pbnRlcmZhY2VzL2NvbnRhaW5lcic7XG5pbXBvcnQge1ROb2RlfSBmcm9tICcuLi9yZW5kZXIzL2ludGVyZmFjZXMvbm9kZSc7XG5pbXBvcnQge2lzTENvbnRhaW5lciwgaXNMVmlld30gZnJvbSAnLi4vcmVuZGVyMy9pbnRlcmZhY2VzL3R5cGVfY2hlY2tzJztcbmltcG9ydCB7SEVBREVSX09GRlNFVCwgTFZpZXcsIFRWSUVXfSBmcm9tICcuLi9yZW5kZXIzL2ludGVyZmFjZXMvdmlldyc7XG5cbmltcG9ydCB7VERlZmVyQmxvY2tEZXRhaWxzfSBmcm9tICcuL2ludGVyZmFjZXMnO1xuaW1wb3J0IHtnZXRURGVmZXJCbG9ja0RldGFpbHMsIGlzVERlZmVyQmxvY2tEZXRhaWxzfSBmcm9tICcuL3V0aWxzJztcblxuLyoqXG4gKiBEZWZlciBibG9jayBpbnN0YW5jZSBmb3IgdGVzdGluZy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBEZWZlckJsb2NrRGV0YWlscyB7XG4gIGxDb250YWluZXI6IExDb250YWluZXI7XG4gIGxWaWV3OiBMVmlldztcbiAgdE5vZGU6IFROb2RlO1xuICB0RGV0YWlsczogVERlZmVyQmxvY2tEZXRhaWxzO1xufVxuXG4vKipcbiAqIFJldHJpZXZlcyBhbGwgZGVmZXIgYmxvY2tzIGluIGEgZ2l2ZW4gTFZpZXcuXG4gKlxuICogQHBhcmFtIGxWaWV3IGxWaWV3IHdpdGggZGVmZXIgYmxvY2tzXG4gKiBAcGFyYW0gZGVmZXJCbG9ja3MgZGVmZXIgYmxvY2sgYWdncmVnYXRvciBhcnJheVxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0RGVmZXJCbG9ja3MobFZpZXc6IExWaWV3LCBkZWZlckJsb2NrczogRGVmZXJCbG9ja0RldGFpbHNbXSkge1xuICBjb25zdCB0VmlldyA9IGxWaWV3W1RWSUVXXTtcbiAgZm9yIChsZXQgaSA9IEhFQURFUl9PRkZTRVQ7IGkgPCB0Vmlldy5iaW5kaW5nU3RhcnRJbmRleDsgaSsrKSB7XG4gICAgaWYgKGlzTENvbnRhaW5lcihsVmlld1tpXSkpIHtcbiAgICAgIGNvbnN0IGxDb250YWluZXIgPSBsVmlld1tpXTtcbiAgICAgIC8vIEFuIExDb250YWluZXIgbWF5IHJlcHJlc2VudCBhbiBpbnN0YW5jZSBvZiBhIGRlZmVyIGJsb2NrLCBpbiB3aGljaCBjYXNlXG4gICAgICAvLyB3ZSBzdG9yZSBpdCBhcyBhIHJlc3VsdC4gT3RoZXJ3aXNlLCBrZWVwIGl0ZXJhdGluZyBvdmVyIExDb250YWluZXIgdmlld3MgYW5kXG4gICAgICAvLyBsb29rIGZvciBkZWZlciBibG9ja3MuXG4gICAgICBjb25zdCBpc0xhc3QgPSBpID09PSB0Vmlldy5iaW5kaW5nU3RhcnRJbmRleCAtIDE7XG4gICAgICBpZiAoIWlzTGFzdCkge1xuICAgICAgICBjb25zdCB0Tm9kZSA9IHRWaWV3LmRhdGFbaV0gYXMgVE5vZGU7XG4gICAgICAgIGNvbnN0IHREZXRhaWxzID0gZ2V0VERlZmVyQmxvY2tEZXRhaWxzKHRWaWV3LCB0Tm9kZSk7XG4gICAgICAgIGlmIChpc1REZWZlckJsb2NrRGV0YWlscyh0RGV0YWlscykpIHtcbiAgICAgICAgICBkZWZlckJsb2Nrcy5wdXNoKHtsQ29udGFpbmVyLCBsVmlldywgdE5vZGUsIHREZXRhaWxzfSk7XG4gICAgICAgICAgLy8gVGhpcyBMQ29udGFpbmVyIHJlcHJlc2VudHMgYSBkZWZlciBibG9jaywgc28gd2UgZXhpdFxuICAgICAgICAgIC8vIHRoaXMgaXRlcmF0aW9uIGFuZCBkb24ndCBpbnNwZWN0IHZpZXdzIGluIHRoaXMgTENvbnRhaW5lci5cbiAgICAgICAgICBjb250aW51ZTtcbiAgICAgICAgfVxuICAgICAgfVxuICAgICAgZm9yIChsZXQgaSA9IENPTlRBSU5FUl9IRUFERVJfT0ZGU0VUOyBpIDwgbENvbnRhaW5lci5sZW5ndGg7IGkrKykge1xuICAgICAgICBnZXREZWZlckJsb2NrcyhsQ29udGFpbmVyW2ldIGFzIExWaWV3LCBkZWZlckJsb2Nrcyk7XG4gICAgICB9XG4gICAgfSBlbHNlIGlmIChpc0xWaWV3KGxWaWV3W2ldKSkge1xuICAgICAgLy8gVGhpcyBpcyBhIGNvbXBvbmVudCwgZW50ZXIgdGhlIGBnZXREZWZlckJsb2Nrc2AgcmVjdXJzaXZlbHkuXG4gICAgICBnZXREZWZlckJsb2NrcyhsVmlld1tpXSwgZGVmZXJCbG9ja3MpO1xuICAgIH1cbiAgfVxufVxuIl19

package/esm2022/src/defer/dom_triggers.mjs

@@ -0,0 +1,256 @@
+/*!
+ * @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 { 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.
+ * @param injector Injector that can be used by the trigger to resolve DI tokens.
+ */
+export function onInteraction(trigger, callback, injector) {
+    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);
+        // Ensure that the handler runs in the NgZone
+        ngDevMode && NgZone.assertInAngularZone();
+        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.
+ * @param injector Injector that can be used by the trigger to resolve DI tokens.
+ */
+export function onHover(trigger, callback, injector) {
+    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);
+        // Ensure that the handler runs in the NgZone
+        ngDevMode && NgZone.assertInAngularZone();
+        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.
+ */
+export function registerDomTrigger(initialLView, tNode, triggerIndex, walkUpTimes, registerFn, callback) {
+    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;
+        }
+        // TODO: add integration with `DeferBlockCleanupManager`.
+        const element = getTriggerElement(triggerLView, triggerIndex);
+        const cleanup = registerFn(element, () => {
+            callback();
+            removeLViewOnDestroy(triggerLView, cleanup);
+            if (initialLView !== triggerLView) {
+                removeLViewOnDestroy(initialLView, cleanup);
+            }
+            cleanup();
+        }, injector);
+        storeLViewOnDestroy(triggerLView, cleanup);
+        // Since the trigger and deferred block might be in different
+        // views, we have to register the callback in both locations.
+        if (initialLView !== triggerLView) {
+            storeLViewOnDestroy(initialLView, 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 {getNativeByIndex, removeLViewOnDestroy, storeLViewOnDestroy, walkUpViews} from '../render3/util/view_utils';\nimport {assertElement, assertEqual} from '../util/assert';\nimport {NgZone} from '../zone';\n\nimport {DEFER_BLOCK_STATE, DeferBlockInternalState, DeferBlockState} 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 * @param injector Injector that can be used by the trigger to resolve DI tokens.\n */\nexport function onInteraction(\n    trigger: Element, callback: VoidFunction, injector: Injector): 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    // Ensure that the handler runs in the NgZone\n    ngDevMode && NgZone.assertInAngularZone();\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 * @param injector Injector that can be used by the trigger to resolve DI tokens.\n */\nexport function onHover(\n    trigger: Element, callback: VoidFunction, injector: Injector): 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    // Ensure that the handler runs in the NgZone\n    ngDevMode && NgZone.assertInAngularZone();\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, callback: VoidFunction, injector: Injector): VoidFunction {\n  const ngZone = injector.get(NgZone);\n  let entry = viewportTriggers.get(trigger);\n\n  intersectionObserver = intersectionObserver || 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, deferredTNode: TNode, walkUpTimes: number|undefined): 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, DeferBlockState.Placeholder,\n        'Expected a placeholder to be rendered in this defer block.');\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 */\nexport function registerDomTrigger(\n    initialLView: LView, tNode: TNode, triggerIndex: number, walkUpTimes: number|undefined,\n    registerFn: (element: Element, callback: VoidFunction, injector: Injector) => VoidFunction,\n    callback: VoidFunction) {\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 (renderedState !== DeferBlockInternalState.Initial &&\n        renderedState !== DeferBlockState.Placeholder) {\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    // TODO: add integration with `DeferBlockCleanupManager`.\n    const element = getTriggerElement(triggerLView, triggerIndex);\n    const cleanup = registerFn(element, () => {\n      callback();\n      removeLViewOnDestroy(triggerLView, cleanup);\n      if (initialLView !== triggerLView) {\n        removeLViewOnDestroy(initialLView, cleanup);\n      }\n      cleanup();\n    }, injector);\n\n    storeLViewOnDestroy(triggerLView, cleanup);\n\n    // Since the trigger and deferred block might be in different\n    // views, we have to register the callback in both locations.\n    if (initialLView !== triggerLView) {\n      storeLViewOnDestroy(initialLView, cleanup);\n    }\n  }\n\n  // Begin polling for the trigger.\n  internalAfterNextRender(pollDomTrigger, {injector});\n}\n"]}

package/esm2022/src/defer/idle_scheduler.mjs

@@ -0,0 +1,109 @@
+/**
+ * @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 { inject, ɵɵdefineInjectable } from '../di';
+import { INJECTOR } from '../render3/interfaces/view';
+import { NgZone } from '../zone';
+import { wrapWithLViewCleanup } from './utils';
+/**
+ * Helper function to schedule a callback to be invoked when a browser becomes idle.
+ *
+ * @param callback A function to be invoked when a browser becomes idle.
+ * @param lView LView that hosts an instance of a defer block.
+ * @param withLViewCleanup A flag that indicates whether a scheduled callback
+ *           should be cancelled in case an LView is destroyed before a callback
+ *           was invoked.
+ */
+export function onIdle(callback, lView, withLViewCleanup) {
+    const injector = lView[INJECTOR];
+    const scheduler = injector.get(IdleScheduler);
+    const cleanupFn = () => scheduler.remove(callback);
+    const wrappedCallback = withLViewCleanup ? wrapWithLViewCleanup(callback, lView, cleanupFn) : callback;
+    scheduler.add(wrappedCallback);
+    return cleanupFn;
+}
+/**
+ * Use shims for the `requestIdleCallback` and `cancelIdleCallback` functions for
+ * environments where those functions are not available (e.g. Node.js and Safari).
+ *
+ * Note: we wrap the `requestIdleCallback` call into a function, so that it can be
+ * overridden/mocked in test environment and picked up by the runtime code.
+ */
+const _requestIdleCallback = () => typeof requestIdleCallback !== 'undefined' ? requestIdleCallback : setTimeout;
+const _cancelIdleCallback = () => typeof requestIdleCallback !== 'undefined' ? cancelIdleCallback : clearTimeout;
+/**
+ * Helper service to schedule `requestIdleCallback`s for batches of defer blocks,
+ * to avoid calling `requestIdleCallback` for each defer block (e.g. if
+ * defer blocks are defined inside a for loop).
+ */
+export class IdleScheduler {
+    constructor() {
+        // Indicates whether current callbacks are being invoked.
+        this.executingCallbacks = false;
+        // Currently scheduled idle callback id.
+        this.idleId = null;
+        // Set of callbacks to be invoked next.
+        this.current = new Set();
+        // Set of callbacks collected while invoking current set of callbacks.
+        // Those callbacks are scheduled for the next idle period.
+        this.deferred = new Set();
+        this.ngZone = inject(NgZone);
+        this.requestIdleCallback = _requestIdleCallback().bind(globalThis);
+        this.cancelIdleCallback = _cancelIdleCallback().bind(globalThis);
+    }
+    add(callback) {
+        const target = this.executingCallbacks ? this.deferred : this.current;
+        target.add(callback);
+        if (this.idleId === null) {
+            this.scheduleIdleCallback();
+        }
+    }
+    remove(callback) {
+        this.current.delete(callback);
+        this.deferred.delete(callback);
+    }
+    scheduleIdleCallback() {
+        const callback = () => {
+            this.cancelIdleCallback(this.idleId);
+            this.idleId = null;
+            this.executingCallbacks = true;
+            for (const callback of this.current) {
+                callback();
+            }
+            this.current.clear();
+            this.executingCallbacks = false;
+            // If there are any callbacks added during an invocation
+            // of the current ones - make them "current" and schedule
+            // a new idle callback.
+            if (this.deferred.size > 0) {
+                for (const callback of this.deferred) {
+                    this.current.add(callback);
+                }
+                this.deferred.clear();
+                this.scheduleIdleCallback();
+            }
+        };
+        // Ensure that the callback runs in the NgZone since
+        // the `requestIdleCallback` is not currently patched by Zone.js.
+        this.idleId = this.requestIdleCallback(() => this.ngZone.run(callback));
+    }
+    ngOnDestroy() {
+        if (this.idleId !== null) {
+            this.cancelIdleCallback(this.idleId);
+            this.idleId = null;
+        }
+        this.current.clear();
+        this.deferred.clear();
+    }
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: IdleScheduler,
+        providedIn: 'root',
+        factory: () => new IdleScheduler(),
+    }); }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"idle_scheduler.js","sourceRoot":"","sources":["../../../../../../../packages/core/src/defer/idle_scheduler.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 {inject, ɵɵdefineInjectable} from '../di';\nimport {INJECTOR, LView} from '../render3/interfaces/view';\nimport {NgZone} from '../zone';\n\nimport {wrapWithLViewCleanup} from './utils';\n\n/**\n * Helper function to schedule a callback to be invoked when a browser becomes idle.\n *\n * @param callback A function to be invoked when a browser becomes idle.\n * @param lView LView that hosts an instance of a defer block.\n * @param withLViewCleanup A flag that indicates whether a scheduled callback\n *           should be cancelled in case an LView is destroyed before a callback\n *           was invoked.\n */\nexport function onIdle(callback: VoidFunction, lView: LView, withLViewCleanup: boolean) {\n  const injector = lView[INJECTOR]!;\n  const scheduler = injector.get(IdleScheduler);\n  const cleanupFn = () => scheduler.remove(callback);\n  const wrappedCallback =\n      withLViewCleanup ? wrapWithLViewCleanup(callback, lView, cleanupFn) : callback;\n  scheduler.add(wrappedCallback);\n  return cleanupFn;\n}\n\n/**\n * Use shims for the `requestIdleCallback` and `cancelIdleCallback` functions for\n * environments where those functions are not available (e.g. Node.js and Safari).\n *\n * Note: we wrap the `requestIdleCallback` call into a function, so that it can be\n * overridden/mocked in test environment and picked up by the runtime code.\n */\nconst _requestIdleCallback = () =>\n    typeof requestIdleCallback !== 'undefined' ? requestIdleCallback : setTimeout;\nconst _cancelIdleCallback = () =>\n    typeof requestIdleCallback !== 'undefined' ? cancelIdleCallback : clearTimeout;\n\n/**\n * Helper service to schedule `requestIdleCallback`s for batches of defer blocks,\n * to avoid calling `requestIdleCallback` for each defer block (e.g. if\n * defer blocks are defined inside a for loop).\n */\nexport class IdleScheduler {\n  // Indicates whether current callbacks are being invoked.\n  executingCallbacks = false;\n\n  // Currently scheduled idle callback id.\n  idleId: number|null = null;\n\n  // Set of callbacks to be invoked next.\n  current = new Set<VoidFunction>();\n\n  // Set of callbacks collected while invoking current set of callbacks.\n  // Those callbacks are scheduled for the next idle period.\n  deferred = new Set<VoidFunction>();\n\n  ngZone = inject(NgZone);\n\n  requestIdleCallback = _requestIdleCallback().bind(globalThis);\n  cancelIdleCallback = _cancelIdleCallback().bind(globalThis);\n\n  add(callback: VoidFunction) {\n    const target = this.executingCallbacks ? this.deferred : this.current;\n    target.add(callback);\n    if (this.idleId === null) {\n      this.scheduleIdleCallback();\n    }\n  }\n\n  remove(callback: VoidFunction) {\n    this.current.delete(callback);\n    this.deferred.delete(callback);\n  }\n\n  private scheduleIdleCallback() {\n    const callback = () => {\n      this.cancelIdleCallback(this.idleId!);\n      this.idleId = null;\n\n      this.executingCallbacks = true;\n\n      for (const callback of this.current) {\n        callback();\n      }\n      this.current.clear();\n\n      this.executingCallbacks = false;\n\n      // If there are any callbacks added during an invocation\n      // of the current ones - make them \"current\" and schedule\n      // a new idle callback.\n      if (this.deferred.size > 0) {\n        for (const callback of this.deferred) {\n          this.current.add(callback);\n        }\n        this.deferred.clear();\n        this.scheduleIdleCallback();\n      }\n    };\n    // Ensure that the callback runs in the NgZone since\n    // the `requestIdleCallback` is not currently patched by Zone.js.\n    this.idleId = this.requestIdleCallback(() => this.ngZone.run(callback)) as number;\n  }\n\n  ngOnDestroy() {\n    if (this.idleId !== null) {\n      this.cancelIdleCallback(this.idleId);\n      this.idleId = null;\n    }\n    this.current.clear();\n    this.deferred.clear();\n  }\n\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: IdleScheduler,\n    providedIn: 'root',\n    factory: () => new IdleScheduler(),\n  });\n}\n"]}