lzy-load
Version:
LzyLoad is an Angular Lib for loading content on demand
265 lines • 37.1 kB
JavaScript
/*
* Important note: Is required that the items marked as lazy-load-items using the "LazyLoadItemDirective"
* are present in the template at the moment of the initialization of the component because the
* ContentChildren query is evaluated just before the AfterContentInit life circle,
* if the items are being added dynamically later to the template then is possible that the parent of this component needs to run manualy
* change detection to notify this component that the template has changed. Example of this case is in the cases-table in
* gallery-management
*/
import { Component, ContentChildren, ElementRef, HostListener, Input, Renderer2 } from '@angular/core';
import { Subject, Subscription } from 'rxjs';
import { debounceTime } from 'rxjs/internal/operators';
import { LzyLoadItemDirective, LL_PRO_NAME } from '../../directives/lzy-load-item.directive';
import { LoadStrategy, UnloadStrategy } from '../../models/settings';
export class LzyLoadContComponent {
constructor(renderer, hostElement) {
this.renderer = renderer;
this.hostElement = hostElement;
// Component fields
this.init = false;
this.loadingRangeAmount = 0;
this.preloadAmo = 0;
this.scrollEvent = new Subject();
this.onResizeEvent = new Subject();
// new properties
this.numOfVisiElem = 0;
this.loadedRange = [];
this.settings = {
loadStrategy: LoadStrategy.PctOfVisibleElem,
unloadStrategy: UnloadStrategy.KeepLoaded,
percent: 2
};
// Subscription that is gonna handle the unsubscribe to all the other subscriptions
this.subscription = new Subscription();
}
ngOnInit() {
this.registerIO();
this.initScroll();
this.initScreenResizing();
}
registerIO() {
// Initializing the IO options
this.IOOptions = {
root: null,
rootMargin: '0px',
threshold: [0.1]
};
// If the container was passed then use it as a root for the IO
if (this.container) {
this.IOOptions.root = this.container;
}
else {
// If the container input was not provided then use the self component as a container
this.container = this.hostElement.nativeElement;
this.IOOptions.root = this.container;
}
}
initScroll() {
// Listening for scroll event in the container
this.renderer.listen(this.container, 'scroll', () => {
this.scrollEvent.next();
});
// subscribing to scroll events to preload the items that need to be
// preload in both directions up and down of the current position
// including 100 mil of debounce time
this.subscription.add(this.scrollEvent.pipe(debounceTime(100)).subscribe(() => {
this.updateLoadedElements();
}));
}
initScreenResizing() {
// Subscribing to the resize event and giving it a 300 miliseconds delay to prevent trigger this code too offten
this.subscription.add(this.onResizeEvent.pipe(debounceTime(300)).subscribe(() => {
// Updating the settings after changing the viewport
this.calSettings();
// resetting the component after the change in the layout
this.updateLoadedElements();
}));
}
// Used for initialize the component settings
initialize() {
this.initializeIntersectionObs();
}
resetAndRecalculateSettings() {
// Resetting the isReady variable to false that will trigger the initial calculations for the first
// execution of the IO callback
this.init = false;
// Disconnecting from the observer and its targets
if (this.observer) {
this.observer.disconnect();
}
// Initializing again the observer with the current elements
this.initializeIntersectionObs();
}
ngAfterContentInit() {
// Listening for changes in the elements
this.subscription.add(this.itemsIO.changes.subscribe(() => {
this.resetAndRecalculateSettings();
}));
// Initializing if are items to observe for
if (this.itemsIO.length > 0) {
this.initialize();
}
}
// Calculate preload amounts
calSettings() {
switch (this.settings.loadStrategy) {
case LoadStrategy.AheadOfVisElem: {
this.loadingRangeAmount = Math.ceil(this.settings.number + this.numOfVisiElem);
// Calculating the amount of items to be load in both directions
this.preloadAmo = this.settings.number;
break;
}
case LoadStrategy.PctOfVisibleElem: {
// Calculating the amount of preload elements depending of the amount of visible items in the view
this.loadingRangeAmount = Math.ceil(this.settings.factor * this.numOfVisiElem);
// Calculating the amount of items to be load in both directions
this.preloadAmo = Math.ceil((this.loadingRangeAmount - this.numOfVisiElem) / 2);
break;
}
case LoadStrategy.OnVisible: {
this.loadingRangeAmount = this.numOfVisiElem;
this.preloadAmo = 0;
break;
}
case LoadStrategy.PctOfTotElem: {
// Calculating the amount of preload elements depending of the amount of visible items in the view
this.loadingRangeAmount = Math.ceil(this.settings.percent * this.itemsIO.length);
// Calculating the amount of items to be load in both directions
this.preloadAmo = Math.ceil((this.loadingRangeAmount - this.numOfVisiElem) / 2);
break;
}
}
}
// loading the content
inLoadingRange(element) {
element.loadContent = true;
}
// unloading the content
outOfLoadingRange(element) {
if (this.settings.unloadStrategy === UnloadStrategy.LeavLoadedRange) {
element.loadContent = false;
}
}
// Calculate the amount of visible elements that are in the exact moment and update the property in the component
getVisibleItems() {
this.numOfVisiElem = this.itemsIO.filter((item) => {
return item.isVisible;
}).length;
return this.numOfVisiElem;
}
// Initialize the IO and the targets to observe
initializeIntersectionObs() {
// callback provided to the IO
const ioCallBack = (entries) => {
const updEntriesVisibility = () => {
entries.forEach((entry) => {
// when an element is intersecting the view
const itemElement = this.itemsIO.toArray()[entry.target[LL_PRO_NAME]];
if (itemElement) {
itemElement.isVisible = entry.isIntersecting;
}
});
};
// differentiating between the first call to the function and the rest. The first is always gonna be
// the initialization of all the targets
if (!this.init) {
// Updating the visibility of each element
updEntriesVisibility();
// Calculating the amount of visible items and updating the property "visibleItemsAmo" for first time
this.getVisibleItems();
// calculating amount of visible items depending if the selected model for the component needs it
this.calSettings();
// Preloading the items
this.updateLoadedElements();
this.init = true;
}
else {
// This code will be executed always after the first time
// Updating the visibility of each element
updEntriesVisibility();
}
};
// Creating the observer
this.observer = new IntersectionObserver(ioCallBack, this.IOOptions);
// Registering the items with the observer
this.itemsIO.forEach((item) => {
this.observer.observe(item.hostElement.nativeElement);
});
}
// calculate the new range of elements in the list that should be preload
calLoadedRange(visibleItems) {
const newRange = [0, 0];
// getting the range of current visible items
const firstVisibleItem = visibleItems[0];
const lastVisibleItem = visibleItems[visibleItems.length - 1];
// Last item position in the array of items
const lastItemPosInArray = (this.itemsIO.length - 1);
// Setting the new start position to the current position menus the preload amount divided by two
// in order to preload forward and in backward
newRange[0] = Math.max(0, (firstVisibleItem.pos - this.preloadAmo));
if (newRange[0] === 0) {
// prefetching the elements ahead of the last visible item
newRange[1] = Math.min(this.loadingRangeAmount, lastItemPosInArray);
}
else if ((lastVisibleItem.pos + this.preloadAmo) >= lastItemPosInArray) {
// pre-fetching the elements ahead and backward of the range of visible items
newRange[1] = lastItemPosInArray;
newRange[0] = Math.max(0, lastItemPosInArray - this.loadingRangeAmount);
}
else {
newRange[1] = (lastVisibleItem.pos + this.preloadAmo);
}
return newRange;
}
// Function that calculate the current visible items and the ones that need to be preload
updateLoadedElements() {
// Getting the current visible elements in the container
const visibleItems = this.itemsIO.filter((item) => {
return item.isVisible;
});
// if are not visible items, then do nothing
if (visibleItems.length > 0) {
// Calculating the elements should be preload
this.loadedRange = this.calLoadedRange(visibleItems);
this.itemsIO.forEach((item, index) => {
if (index >= this.loadedRange[0] && index <= this.loadedRange[1]) {
// element within the loading range
this.inLoadingRange(item);
}
else {
// element out the loading range
this.outOfLoadingRange(item);
}
});
}
}
// Listening to the resize event so we can recalculate the amount of visible items in the list and other
// important properties that are use for the component
onResize() {
this.onResizeEvent.next();
}
ngOnDestroy() {
if (this.observer) {
this.observer.disconnect();
}
this.subscription.unsubscribe();
}
}
LzyLoadContComponent.decorators = [
{ type: Component, args: [{
selector: 'lzy-load-cont',
template: "<ng-content></ng-content>",
styles: [":host{background:transparent;border:inherit;color:inherit;display:flex;margin:0;padding:0}"]
},] }
];
LzyLoadContComponent.ctorParameters = () => [
{ type: Renderer2 },
{ type: ElementRef }
];
LzyLoadContComponent.propDecorators = {
settings: [{ type: Input }],
container: [{ type: Input }],
itemsIO: [{ type: ContentChildren, args: [LzyLoadItemDirective, { descendants: true },] }],
onResize: [{ type: HostListener, args: ['window:resize', [],] }]
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lzy-load-content.component.js","sourceRoot":"","sources":["../../../../../../projects/lzy-load/src/lib/components/lzy-load-content/lzy-load-content.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n  * Important note: Is required that the items marked as lazy-load-items using the \"LazyLoadItemDirective\"\r\n  * are present in the template at the moment of the initialization of the component because the\r\n  * ContentChildren query is evaluated just before the AfterContentInit life circle,\r\n  * if the items are being added dynamically later to the template then is possible that the parent of this component needs to run manualy\r\n  * change detection to notify this component that the template has changed. Example of this case is in the cases-table in\r\n  * gallery-management\r\n  */\r\n import { AfterContentInit, Component, ContentChildren,\r\n  ElementRef, HostListener, Input, OnDestroy, OnInit, QueryList, Renderer2 } from '@angular/core';\r\n import { Subject, Subscription } from 'rxjs';\r\n import { debounceTime } from 'rxjs/internal/operators';\r\n import { LzyLoadItemDirective, LL_PRO_NAME } from '../../directives/lzy-load-item.directive';\r\n import { Settings, LoadStrategy, UnloadStrategy } from '../../models/settings';\r\n\r\n @Component({\r\n  selector: 'lzy-load-cont',\r\n  templateUrl: './lzy-load-content.component.html',\r\n  styleUrls: ['./lzy-load-content.component.css']\r\n})\r\nexport class LzyLoadContComponent implements OnInit, AfterContentInit, OnDestroy {\r\n  // IntersectionObserver settings\r\n  private observer: IntersectionObserver;\r\n  private IOOptions: { root: any, rootMargin: '0px', threshold: [0.1]};\r\n\r\n  // Component fields\r\n  private init = false;\r\n  private loadingRangeAmount = 0;\r\n  private preloadAmo = 0;\r\n  private scrollEvent = new Subject<void>();\r\n  private onResizeEvent = new Subject<void>();\r\n\r\n  // new properties\r\n  private numOfVisiElem = 0;\r\n  private loadedRange = [];\r\n\r\n  @Input() settings: Settings = {\r\n    loadStrategy: LoadStrategy.PctOfVisibleElem,\r\n    unloadStrategy: UnloadStrategy.KeepLoaded,\r\n    percent: 2\r\n  };\r\n\r\n  @Input() container: HTMLElement;\r\n  // Subscription that is gonna handle the unsubscribe to all the other subscriptions\r\n  subscription = new Subscription();\r\n\r\n  @ContentChildren(LzyLoadItemDirective, {descendants: true}) itemsIO: QueryList<LzyLoadItemDirective>;\r\n\r\n  constructor(private renderer: Renderer2, private hostElement: ElementRef) {}\r\n\r\n\r\n  ngOnInit() {\r\n\r\n    this.registerIO();\r\n\r\n    this.initScroll();\r\n\r\n    this.initScreenResizing();\r\n  }\r\n\r\n  private registerIO() {\r\n    //  Initializing the IO options\r\n    this.IOOptions = {\r\n      root: null,\r\n      rootMargin: '0px',\r\n      threshold: [0.1]\r\n    };\r\n    // If the container was passed then use it as a root for the IO\r\n    if (this.container) {\r\n      this.IOOptions.root = this.container;\r\n    } else {\r\n      // If the container input was not provided then use the self component as a container\r\n      this.container = this.hostElement.nativeElement;\r\n      this.IOOptions.root = this.container;\r\n    }\r\n  }\r\n\r\n  private initScroll() {\r\n    // Listening for scroll event in the container\r\n    this.renderer.listen(this.container, 'scroll', () => {\r\n      this.scrollEvent.next();\r\n    });\r\n\r\n    // subscribing to scroll events to preload the items that need to be\r\n    // preload in both directions up and down of the current position\r\n    // including 100 mil of debounce time\r\n    this.subscription.add(this.scrollEvent.pipe(debounceTime(100)).subscribe(() => {\r\n    this.updateLoadedElements();\r\n    }));\r\n  }\r\n\r\n  private initScreenResizing() {\r\n    // Subscribing to the resize event and giving it a 300 miliseconds delay to prevent trigger this code too offten\r\n    this.subscription.add(this.onResizeEvent.pipe(debounceTime(300)).subscribe(() => {\r\n      // Updating the settings after changing the viewport\r\n      this.calSettings();\r\n      // resetting the component after the change in the layout\r\n      this.updateLoadedElements();\r\n    }));\r\n  }\r\n\r\n  // Used for initialize the component settings\r\n  initialize(): void {\r\n    this.initializeIntersectionObs();\r\n  }\r\n\r\n  resetAndRecalculateSettings(): void {\r\n    // Resetting the isReady variable to false that will trigger the initial calculations for the first\r\n    // execution of the IO callback\r\n    this.init =  false;\r\n    // Disconnecting from the observer and its targets\r\n    if (this.observer) {\r\n      this.observer.disconnect();\r\n    }\r\n    // Initializing again the observer with the current elements\r\n    this.initializeIntersectionObs();\r\n  }\r\n\r\n  ngAfterContentInit(): void {\r\n    // Listening for changes in the elements\r\n    this.subscription.add(this.itemsIO.changes.subscribe(() => {\r\n        this.resetAndRecalculateSettings();\r\n    }));\r\n    // Initializing if are items to observe for\r\n    if (this.itemsIO.length > 0) {\r\n     this.initialize();\r\n    }\r\n  }\r\n\r\n  // Calculate preload amounts\r\n  private calSettings() {\r\n    switch (this.settings.loadStrategy) {\r\n        case LoadStrategy.AheadOfVisElem: {\r\n          this.loadingRangeAmount = Math.ceil(this.settings.number + this.numOfVisiElem);\r\n          // Calculating the amount of items to be load in both directions\r\n          this.preloadAmo = this.settings.number;\r\n          break;\r\n        }\r\n        case LoadStrategy.PctOfVisibleElem: {\r\n          // Calculating the amount of preload elements depending of the amount of visible items in the view\r\n          this.loadingRangeAmount = Math.ceil(this.settings.factor * this.numOfVisiElem);\r\n          // Calculating the amount of items to be load in both directions\r\n          this.preloadAmo = Math.ceil((this.loadingRangeAmount - this.numOfVisiElem) / 2);\r\n          break;\r\n        }\r\n        case LoadStrategy.OnVisible: {\r\n          this.loadingRangeAmount = this.numOfVisiElem;\r\n          this.preloadAmo = 0;\r\n          break;\r\n        }\r\n        case LoadStrategy.PctOfTotElem: {\r\n          // Calculating the amount of preload elements depending of the amount of visible items in the view\r\n          this.loadingRangeAmount = Math.ceil(this.settings.percent * this.itemsIO.length);\r\n          // Calculating the amount of items to be load in both directions\r\n          this.preloadAmo = Math.ceil((this.loadingRangeAmount - this.numOfVisiElem) / 2);\r\n          break;\r\n        }\r\n      }\r\n  }\r\n\r\n  // loading the content\r\n  private inLoadingRange(element: LzyLoadItemDirective) {\r\n      element.loadContent = true;\r\n  }\r\n\r\n  // unloading the content\r\n  private outOfLoadingRange(element: LzyLoadItemDirective) {\r\n    if (this.settings.unloadStrategy === UnloadStrategy.LeavLoadedRange) {\r\n        element.loadContent = false;\r\n    }\r\n  }\r\n\r\n  // Calculate the amount of visible elements  that are in the exact moment and update the property in the component\r\n  private getVisibleItems() {\r\n    this.numOfVisiElem = this.itemsIO.filter((item: LzyLoadItemDirective) => {\r\n      return item.isVisible;\r\n    }).length;\r\n    return this.numOfVisiElem;\r\n  }\r\n\r\n  // Initialize the IO and the targets to observe\r\n  private initializeIntersectionObs() {\r\n\r\n    // callback provided to the IO\r\n    const ioCallBack = (entries: IntersectionObserverEntry[]) => {\r\n      const updEntriesVisibility = () => {\r\n        entries.forEach((entry: IntersectionObserverEntry) => {\r\n          // when an element is intersecting the view\r\n          const itemElement = this.itemsIO.toArray()[entry.target[LL_PRO_NAME]];\r\n          if (itemElement) {\r\n            itemElement.isVisible = entry.isIntersecting;\r\n          }\r\n        });\r\n      };\r\n      // differentiating between the first call to the function and the rest. The first is always gonna be\r\n      // the initialization of all the targets\r\n      if (!this.init) {\r\n        // Updating the visibility of each element\r\n        updEntriesVisibility();\r\n        // Calculating the amount of visible items and updating the property \"visibleItemsAmo\" for first time\r\n        this.getVisibleItems();\r\n        // calculating amount of visible items depending if the selected model for the component needs it\r\n        this.calSettings();\r\n        // Preloading the items\r\n        this.updateLoadedElements();\r\n        this.init = true;\r\n      } else {\r\n        // This code will be executed always after the first time\r\n        // Updating the visibility of each element\r\n        updEntriesVisibility();\r\n      }\r\n    };\r\n    // Creating the observer\r\n    this.observer = new IntersectionObserver(ioCallBack, this.IOOptions);\r\n    // Registering the items with the observer\r\n    this.itemsIO.forEach((item: LzyLoadItemDirective) => {\r\n      this.observer.observe(item.hostElement.nativeElement);\r\n    });\r\n  }\r\n\r\n  // calculate the new range of elements in the list that should be preload\r\n  calLoadedRange(visibleItems: LzyLoadItemDirective[]): number[] {\r\n    const newRange = [0, 0];\r\n    // getting the range of current visible items\r\n    const firstVisibleItem = visibleItems[0];\r\n    const lastVisibleItem = visibleItems[visibleItems.length - 1];\r\n    // Last item position in the array of items\r\n    const lastItemPosInArray = (this.itemsIO.length - 1);\r\n    // Setting the new start position to the current position menus the preload amount divided by two\r\n    // in order to preload forward and in backward\r\n    newRange[0] = Math.max(0, (firstVisibleItem.pos - this.preloadAmo));\r\n    if (newRange[0] === 0) {\r\n      // prefetching the elements ahead of the last visible item\r\n      newRange[1] = Math.min(this.loadingRangeAmount, lastItemPosInArray);\r\n    } else if ((lastVisibleItem.pos + this.preloadAmo) >= lastItemPosInArray) {\r\n      // pre-fetching the elements ahead and backward of the range of visible items\r\n      newRange[1] = lastItemPosInArray;\r\n      newRange[0] =  Math.max(0, lastItemPosInArray - this.loadingRangeAmount);\r\n    } else {\r\n      newRange[1] =  (lastVisibleItem.pos + this.preloadAmo);\r\n    }\r\n    return newRange;\r\n  }\r\n\r\n  // Function that calculate the current visible items and the ones that need to be preload\r\n  updateLoadedElements() {\r\n     //  Getting the current visible elements in the container\r\n     const visibleItems = this.itemsIO.filter((item: LzyLoadItemDirective) => {\r\n      return item.isVisible;\r\n    });\r\n\r\n    // if are not visible items, then do nothing\r\n     if (visibleItems.length > 0) {\r\n      // Calculating the elements should be preload\r\n      this.loadedRange = this.calLoadedRange(visibleItems);\r\n      this.itemsIO.forEach((item: LzyLoadItemDirective, index) => {\r\n        if (index >= this.loadedRange[0] && index <= this.loadedRange[1]) {\r\n          // element within the loading range\r\n          this.inLoadingRange(item);\r\n        } else {\r\n          // element out the loading range\r\n          this.outOfLoadingRange(item);\r\n        }\r\n      });\r\n    }\r\n  }\r\n\r\n  // Listening to the resize event so we can recalculate the amount of visible items in the list and other\r\n  // important properties that are use for the component\r\n  @HostListener('window:resize', []) onResize() {\r\n    this.onResizeEvent.next();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    if (this.observer) {\r\n      this.observer.disconnect();\r\n    }\r\n    this.subscription.unsubscribe();\r\n  }\r\n}\r\n"]}