@linid-dm/directory-manager-client-core/esm2022/lib/shared/directives/infinite-scroll.directive.mjs

Core package by providing a set of angular components for the Directory Manager app.

/**
 * Copyright (C) 2020-2024 Linagora
 *
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option) any
 * later version, provided you comply with the Additional Terms applicable for
 * LinID Directory Manager software by LINAGORA pursuant to Section 7 of the GNU
 * Affero General Public License, subsections (b), (c), and (e), pursuant to
 * which these Appropriate Legal Notices must notably (i) retain the display of
 * the "LinID™" trademark/logo at the top of the interface window, the display
 * of the “You are using the Open Source and free version of LinID™, powered by
 * Linagora © 2009–2013. Contribute to LinID R&D by subscribing to an Enterprise
 * offer!” infobox and in the e-mails sent with the Program, notice appended to
 * any type of outbound messages (e.g. e-mail and meeting requests) as well as
 * in the LinID Directory Manager user interface, (ii) retain all hypertext
 * links between LinID Directory Manager and https://linid.org/, as well as
 * between LINAGORA and LINAGORA.com, and (iii) refrain from infringing LINAGORA
 * intellectual property rights over its trademarks and commercial brands. Other
 * Additional Terms apply, see <http://www.linagora.com/licenses/> for more
 * details.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Affero General Public License and
 * its applicable Additional Terms for LinID Directory Manager along with this
 * program. If not, see <http://www.gnu.org/licenses/> for the GNU Affero
 * General Public License version 3 and <http://www.linagora.com/licenses/> for
 * the Additional Terms applicable to the LinID Directory Manager software.
 */
import { Directive, EventEmitter, Input, Output, } from '@angular/core';
import { fromEvent, Subject, debounceTime, takeUntil, tap } from 'rxjs';
import * as i0 from "@angular/core";
import * as i1 from "@angular/material/autocomplete";
export class InfiniteScrollDirective {
    constructor(_matAutocomplete, _ngZone, _renderer) {
        this._matAutocomplete = _matAutocomplete;
        this._ngZone = _ngZone;
        this._renderer = _renderer;
        this.threshold = '15%';
        this.debounceTime = 150;
        this.infiniteScroll = new EventEmitter();
        this.thrPx = 0;
        this.thrPc = 0;
        this._onDestroy$ = new Subject();
    }
    ngOnInit() {
        this.evaluateThreshold();
    }
    ngOnChanges(changes) {
        if (changes.isOpened && changes.isOpened.currentValue) {
            setTimeout(() => {
                if (this._matAutocomplete.panel) {
                    this.panel = this._matAutocomplete.panel.nativeElement;
                    this._renderer.setStyle(this.panel, 'min-width', this.inputWidth + 'px');
                    if (this.panel.firstElementChild) {
                        this.singleOptionHeight = parseFloat(getComputedStyle(this.panel.firstElementChild).height);
                    }
                    this.registerScrollListener();
                }
            }, 1);
        }
        else if (changes.inputWidth && !!this.panel) {
            this._renderer.setStyle(this.panel, 'min-width', changes.inputWidth.currentValue + 'px');
        }
    }
    ngOnDestroy() {
        this._onDestroy$.next();
        this._onDestroy$.complete();
    }
    evaluateThreshold() {
        if (this.threshold.lastIndexOf('%') > -1) {
            this.thrPx = 0;
            this.thrPc = parseFloat(this.threshold) / 100;
        }
        else {
            this.thrPx = parseFloat(this.threshold);
            this.thrPc = 0;
        }
    }
    registerScrollListener() {
        fromEvent(this.panel, 'scroll')
            .pipe(takeUntil(this._onDestroy$), debounceTime(this.debounceTime), tap((event) => {
            this.handleScrollEvent(event);
        }))
            .subscribe();
    }
    handleScrollEvent(event) {
        this._ngZone.runOutsideAngular(() => {
            if (!this.complete) {
                const countOfRenderedOptions = this._matAutocomplete.options.length;
                const infiniteScrollDistance = this.singleOptionHeight * countOfRenderedOptions;
                const threshold = this.thrPc !== 0 ? infiniteScrollDistance * this.thrPc : this.thrPx;
                const scrolledDistance = this.panel.clientHeight + event.target.scrollTop;
                if (scrolledDistance + threshold >= infiniteScrollDistance) {
                    this._ngZone.run(() => this.infiniteScroll.emit());
                }
            }
        });
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: InfiniteScrollDirective, deps: [{ token: i1.MatAutocomplete }, { token: i0.NgZone }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.4", type: InfiniteScrollDirective, selector: "[appInfiniteScroll]", inputs: { threshold: "threshold", debounceTime: "debounceTime", complete: "complete", inputWidth: "inputWidth", isOpened: "isOpened" }, outputs: { infiniteScroll: "infiniteScroll" }, usesOnChanges: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: InfiniteScrollDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[appInfiniteScroll]',
                }]
        }], ctorParameters: () => [{ type: i1.MatAutocomplete }, { type: i0.NgZone }, { type: i0.Renderer2 }], propDecorators: { threshold: [{
                type: Input
            }], debounceTime: [{
                type: Input
            }], complete: [{
                type: Input
            }], inputWidth: [{
                type: Input
            }], infiniteScroll: [{
                type: Output
            }], isOpened: [{
                type: Input
            }] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"infinite-scroll.directive.js","sourceRoot":"","sources":["../../../../../../../../packages/libs/client-core/src/lib/shared/directives/infinite-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (C) 2020-2024 Linagora\n *\n * This program is free software: you can redistribute it and/or modify it under\n * the terms of the GNU Affero General Public License as published by the Free\n * Software Foundation, either version 3 of the License, or (at your option) any\n * later version, provided you comply with the Additional Terms applicable for\n * LinID Directory Manager software by LINAGORA pursuant to Section 7 of the GNU\n * Affero General Public License, subsections (b), (c), and (e), pursuant to\n * which these Appropriate Legal Notices must notably (i) retain the display of\n * the \"LinID™\" trademark/logo at the top of the interface window, the display\n * of the “You are using the Open Source and free version of LinID™, powered by\n * Linagora © 2009–2013. Contribute to LinID R&D by subscribing to an Enterprise\n * offer!” infobox and in the e-mails sent with the Program, notice appended to\n * any type of outbound messages (e.g. e-mail and meeting requests) as well as\n * in the LinID Directory Manager user interface, (ii) retain all hypertext\n * links between LinID Directory Manager and https://linid.org/, as well as\n * between LINAGORA and LINAGORA.com, and (iii) refrain from infringing LINAGORA\n * intellectual property rights over its trademarks and commercial brands. Other\n * Additional Terms apply, see <http://www.linagora.com/licenses/> for more\n * details.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more\n * details.\n *\n * You should have received a copy of the GNU Affero General Public License and\n * its applicable Additional Terms for LinID Directory Manager along with this\n * program. If not, see <http://www.gnu.org/licenses/> for the GNU Affero\n * General Public License version 3 and <http://www.linagora.com/licenses/> for\n * the Additional Terms applicable to the LinID Directory Manager software.\n */\n\nimport {\n  Directive,\n  EventEmitter,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n  SimpleChanges,\n} from '@angular/core';\nimport { MatAutocomplete } from '@angular/material/autocomplete';\nimport { fromEvent, Subject, debounceTime, takeUntil, tap } from 'rxjs';\n\n@Directive({\n  selector: '[appInfiniteScroll]',\n})\nexport class InfiniteScrollDirective implements OnInit, OnDestroy, OnChanges {\n  @Input() threshold = '15%';\n  @Input() debounceTime = 150;\n  @Input() complete: boolean;\n  @Input() inputWidth: number;\n  @Output() infiniteScroll = new EventEmitter<void>();\n\n  private panel: Element;\n  private thrPx = 0;\n  private thrPc = 0;\n  private singleOptionHeight: number;\n\n  private _onDestroy$ = new Subject<void>();\n\n  constructor(\n    private _matAutocomplete: MatAutocomplete,\n    private _ngZone: NgZone,\n    private _renderer: Renderer2\n  ) {}\n\n  @Input() isOpened: boolean;\n\n  ngOnInit(): void {\n    this.evaluateThreshold();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.isOpened && changes.isOpened.currentValue) {\n      setTimeout(() => {\n        if (this._matAutocomplete.panel) {\n          this.panel = this._matAutocomplete.panel.nativeElement;\n          this._renderer.setStyle(\n            this.panel,\n            'min-width',\n            this.inputWidth + 'px'\n          );\n          if (this.panel.firstElementChild) {\n            this.singleOptionHeight = parseFloat(\n              getComputedStyle(this.panel.firstElementChild).height\n            );\n          }\n          this.registerScrollListener();\n        }\n      }, 1);\n    } else if (changes.inputWidth && !!this.panel) {\n      this._renderer.setStyle(\n        this.panel,\n        'min-width',\n        changes.inputWidth.currentValue + 'px'\n      );\n    }\n  }\n\n  ngOnDestroy(): void {\n    this._onDestroy$.next();\n    this._onDestroy$.complete();\n  }\n\n  evaluateThreshold(): void {\n    if (this.threshold.lastIndexOf('%') > -1) {\n      this.thrPx = 0;\n      this.thrPc = parseFloat(this.threshold) / 100;\n    } else {\n      this.thrPx = parseFloat(this.threshold);\n      this.thrPc = 0;\n    }\n  }\n\n  registerScrollListener(): void {\n    fromEvent(this.panel, 'scroll')\n      .pipe(\n        takeUntil(this._onDestroy$),\n        debounceTime(this.debounceTime),\n        tap((event) => {\n          this.handleScrollEvent(event);\n        })\n      )\n      .subscribe();\n  }\n\n  handleScrollEvent(event): void {\n    this._ngZone.runOutsideAngular(() => {\n      if (!this.complete) {\n        const countOfRenderedOptions = this._matAutocomplete.options.length;\n        const infiniteScrollDistance =\n          this.singleOptionHeight * countOfRenderedOptions;\n        const threshold =\n          this.thrPc !== 0 ? infiniteScrollDistance * this.thrPc : this.thrPx;\n\n        const scrolledDistance =\n          this.panel.clientHeight + event.target.scrollTop;\n\n        if (scrolledDistance + threshold >= infiniteScrollDistance) {\n          this._ngZone.run(() => this.infiniteScroll.emit());\n        }\n      }\n    });\n  }\n}\n"]}