Datasets:
finnstrom3693
/
opewebtext-subset-00

Dataset card Data Studio Files
xet
Community
2
text
stringlengths
1
80.5k
⌀
public addTarget( target: LazyTarget ) : void {
if ( this.observer ) {
this.targets.set( target.element, target );
this.observer.observe( target.element );
// If we don't actually have an observer (lacking browser support), then we're
// going to punt on the feature for now and just immediately tell the target
// that it is visible on the page.
} else {
target.updateVisibility( true, 1.0 );
}
}
// I setup the IntersectionObserver with the given element as the root.
public setup( element: Element = null, offset: number = 0 ) : void {
// While the IntersectionObserver is supported in the modern browsers, it will
// never be added to Internet Explorer (IE) and is not in my version of Safari
// (at the time of this post). As such, we'll only use it if it's available.
// And, if it's not, we'll fall-back to non-lazy behaviors.
if ( ! global[ "IntersectionObserver" ] ) {
return;
}
this.observer = new IntersectionObserver(
this.handleIntersectionUpdate,
{
root: element,
rootMargin: `${ offset }px`
}
);
}
// I remove the given LazyTarget implementation from the collection of objects being
// tracked by the IntersectionObserver.
public removeTarget( target: LazyTarget ) : void {
// If the IntersectionObserver isn't supported, we never started tracking the
// given target in the first place.
if ( this.observer ) {
this.targets.delete( target.element );
this.observer.unobserve( target.element );
}
}
// I teardown this service instance.
public teardown() : void {
if ( this.observer ) {
this.observer.disconnect();
this.observer = null;
}
this.targets.clear();
this.targets = null;
}
// ---
// PRIVATE METHODS.
// ---
// I handle changes in the visibility for elements being tracked by the intersection
// observer.
// --
// CAUTION: Using fat-arrow binding for method.
private handleIntersectionUpdate = ( entries: IntersectionObserverEntry[] ) : void => {
for ( var entry of entries ) {
var lazyTarget = this.targets.get( entry.target );
( lazyTarget ) && lazyTarget.updateVisibility(
entry.isIntersecting,
entry.intersectionRatio
);
}
}
}
As of this writing, the IntersectionObserver API is only supported in my Chrome and Firefox browsers. My Safari browser, which I think is a version behind, doesn't support it. And, IE will never support it. As such, my LazyViewport service has to be a bit defensive. There is an official IntersectionObserver polyfill, but I haven't tried it. That said, most of the code in this service just adds and removes targets - it doesn't actually handle any of the intersection logic - that's all done by the
IntersectionObserver API.
By default, the injected LazyViewport instance will be associated with the browser's viewport because we don't provide a root element when providing the LazyViewport service in the LazyModule:
// Import the core angular services.
import { NgModule } from "@angular/core";
// Import the application components and services.
import { LazySrcDirective } from "./lazy-src.directive.ts";
import { LazyViewport } from "./lazy-viewport.ts";
import { LazyViewportDirective } from "./lazy-viewport.directive.ts";
// ----------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------- //
@NgModule({
declarations: [
LazySrcDirective,
LazyViewportDirective
],
exports: [
LazySrcDirective,
LazyViewportDirective
],
providers: [
// Setup the default LazyViewport instance without an associated element. This
// will create a IntersectionObserver that uses the browser's viewport as the
// observer root. This way, an instance of LazyViewport is always available for
// injection into other directives and services.
// --
// NOTE: This service will be overridden at lower-levels in the component tree
// whenever a [lazyViewport] directive is applied.
{
provide: LazyViewport,
useFactory: function() {
var viewport = new LazyViewport();
viewport.setup( /* No root. */ );
return( viewport );
}
}