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

package/esm2022/src/render3/instructions/defer_events.mjs

@@ -0,0 +1,154 @@
+/*!
+ * @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 { NgZone } from '../../zone';
+/** 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();
+/** Names of the events considered as interaction events. */
+const interactionEventNames = ['click', 'keydown'];
+/** 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 using 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();
+        trigger.addEventListener('mouseenter', entry.listener, eventListenerOptions);
+        hoverTriggers.set(trigger, entry);
+    }
+    entry.callbacks.add(callback);
+    return () => {
+        const { callbacks, listener } = entry;
+        callbacks.delete(callback);
+        if (callbacks.size === 0) {
+            trigger.removeEventListener('mouseenter', 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) {
+    return injector.get(DeferIntersectionManager).register(trigger, callback);
+}
+/** Keeps track of the registered `viewport` triggers. */
+class DeferIntersectionManager {
+    /** @nocollapse */
+    static { this.ɵprov = ɵɵdefineInjectable({
+        token: DeferIntersectionManager,
+        providedIn: 'root',
+        factory: () => new DeferIntersectionManager(inject(NgZone)),
+    }); }
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+        /** `IntersectionObserver` used to observe `viewport` triggers. */
+        this.intersectionObserver = null;
+        /** Number of elements currently observed with `viewport` triggers. */
+        this.observedViewportElements = 0;
+        /** Currently-registered `viewport` triggers. */
+        this.viewportTriggers = new WeakMap();
+        this.intersectionCallback = entries => {
+            for (const current of entries) {
+                // Only invoke the callbacks if the specific element is intersecting.
+                if (current.isIntersecting && this.viewportTriggers.has(current.target)) {
+                    this.ngZone.run(this.viewportTriggers.get(current.target).listener);
+                }
+            }
+        };
+    }
+    register(trigger, callback) {
+        let entry = this.viewportTriggers.get(trigger);
+        if (!this.intersectionObserver) {
+            this.intersectionObserver =
+                this.ngZone.runOutsideAngular(() => new IntersectionObserver(this.intersectionCallback));
+        }
+        if (!entry) {
+            entry = new DeferEventEntry();
+            this.ngZone.runOutsideAngular(() => this.intersectionObserver.observe(trigger));
+            this.viewportTriggers.set(trigger, entry);
+            this.observedViewportElements++;
+        }
+        entry.callbacks.add(callback);
+        return () => {
+            entry.callbacks.delete(callback);
+            if (entry.callbacks.size === 0) {
+                this.intersectionObserver?.unobserve(trigger);
+                this.viewportTriggers.delete(trigger);
+                this.observedViewportElements--;
+            }
+            if (this.observedViewportElements === 0) {
+                this.intersectionObserver?.disconnect();
+                this.intersectionObserver = null;
+            }
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"defer_events.js","sourceRoot":"","sources":["../../../../../../../../packages/core/src/render3/instructions/defer_events.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, Injector, ɵɵdefineInjectable} from '../../di';\nimport {NgZone} from '../../zone';\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/** Names of the events considered as interaction events. */\nconst interactionEventNames = ['click', 'keydown'] as const;\n\n/** Object keeping track of registered callbacks for a deferred block trigger. */\nclass DeferEventEntry {\n  callbacks = new Set<() => void>();\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) {\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 using 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    trigger.addEventListener('mouseenter', entry.listener, eventListenerOptions);\n    hoverTriggers.set(trigger, entry);\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      trigger.removeEventListener('mouseenter', listener, eventListenerOptions);\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  return injector.get(DeferIntersectionManager).register(trigger, callback);\n}\n\n/** Keeps track of the registered `viewport` triggers. */\nclass DeferIntersectionManager {\n  /** @nocollapse */\n  static ɵprov = /** @pureOrBreakMyCode */ ɵɵdefineInjectable({\n    token: DeferIntersectionManager,\n    providedIn: 'root',\n    factory: () => new DeferIntersectionManager(inject(NgZone)),\n  });\n\n  /** `IntersectionObserver` used to observe `viewport` triggers. */\n  private intersectionObserver: IntersectionObserver|null = null;\n\n  /** Number of elements currently observed with `viewport` triggers. */\n  private observedViewportElements = 0;\n\n  /** Currently-registered `viewport` triggers. */\n  private viewportTriggers = new WeakMap<Element, DeferEventEntry>();\n\n  constructor(private ngZone: NgZone) {}\n\n  register(trigger: Element, callback: VoidFunction): VoidFunction {\n    let entry = this.viewportTriggers.get(trigger);\n\n    if (!this.intersectionObserver) {\n      this.intersectionObserver =\n          this.ngZone.runOutsideAngular(() => new IntersectionObserver(this.intersectionCallback));\n    }\n\n    if (!entry) {\n      entry = new DeferEventEntry();\n      this.ngZone.runOutsideAngular(() => this.intersectionObserver!.observe(trigger));\n      this.viewportTriggers.set(trigger, entry);\n      this.observedViewportElements++;\n    }\n\n    entry.callbacks.add(callback);\n\n    return () => {\n      entry!.callbacks.delete(callback);\n\n      if (entry!.callbacks.size === 0) {\n        this.intersectionObserver?.unobserve(trigger);\n        this.viewportTriggers.delete(trigger);\n        this.observedViewportElements--;\n      }\n\n      if (this.observedViewportElements === 0) {\n        this.intersectionObserver?.disconnect();\n        this.intersectionObserver = null;\n      }\n    };\n  }\n\n  private intersectionCallback: IntersectionObserverCallback = entries => {\n    for (const current of entries) {\n      // Only invoke the callbacks if the specific element is intersecting.\n      if (current.isIntersecting && this.viewportTriggers.has(current.target)) {\n        this.ngZone.run(this.viewportTriggers.get(current.target)!.listener);\n      }\n    }\n  }\n}\n"]}