import { Directive, Optional, Input, Output } from '@angular/core';
import { Observable, Subject, Subscription, filter, map, tap, distinctUntilChanged } from 'rxjs';
import * as i0 from "@angular/core";
import * as i1 from "ngx-scrollbar";
import * as i2 from "@angular/cdk/bidi";
class ReachedFunctions {
    static reachedTop(offset, e) {
        return ReachedFunctions.reached(-e.target.scrollTop, 0, offset);
    }
    static reachedBottom(offset, e) {
        return ReachedFunctions.reached(e.target.scrollTop + e.target.clientHeight, e.target.scrollHeight, offset);
    }
    static reachedStart(offset, e, direction, rtlScrollAxisType) {
        if (direction === 'rtl') {
            if (rtlScrollAxisType === 1 /* RtlScrollAxisType.NEGATED */) {
                return ReachedFunctions.reached(e.target.scrollLeft, 0, offset);
            }
            if (rtlScrollAxisType === 2 /* RtlScrollAxisType.INVERTED */) {
                return ReachedFunctions.reached(-e.target.scrollLeft, 0, offset);
            }
            return ReachedFunctions.reached(e.target.scrollLeft + e.target.clientWidth, e.target.scrollWidth, offset);
        }
        return ReachedFunctions.reached(-e.target.scrollLeft, 0, offset);
    }
    static reachedEnd(offset, e, direction, rtlScrollAxisType) {
        if (direction === 'rtl') {
            if (rtlScrollAxisType === 1 /* RtlScrollAxisType.NEGATED */) {
                return ReachedFunctions.reached(-(e.target.scrollLeft - e.target.clientWidth), e.target.scrollWidth, offset);
            }
            if (rtlScrollAxisType === 2 /* RtlScrollAxisType.INVERTED */) {
                return ReachedFunctions.reached(-(e.target.scrollLeft + e.target.clientWidth), e.target.scrollWidth, offset);
            }
            return ReachedFunctions.reached(-e.target.scrollLeft, 0, offset);
        }
        return ReachedFunctions.reached(e.target.scrollLeft + e.target.clientWidth, e.target.scrollWidth, offset);
    }
    static reached(currPosition, targetPosition, offset) {
        return currPosition >= targetPosition - offset;
    }
}
class ScrollReached {
    constructor(scrollbar, zone) {
        this.scrollbar = scrollbar;
        this.zone = zone;
        /** offset: Reached offset value in px */
        this.offset = 0;
        /**
         * Stream that emits scroll event when `NgScrollbar.scrolled` is initialized.
         *
         * **NOTE:** This subject is used to hold the place of `NgScrollbar.scrolled` when it's not initialized yet
         */
        this.scrollEvent = new Subject();
        /** subscription: Scrolled event subscription, used to unsubscribe from the event on destroy */
        this.subscription = Subscription.EMPTY;
        /** A stream used to assign the reached output */
        this.reachedEvent = new Observable((subscriber) => this.scrollReached().subscribe(_ => Promise.resolve().then(() => this.zone.run(() => subscriber.next(_)))));
        if (!scrollbar) {
            console.warn('[NgScrollbarReached Directive]: Host element must be an NgScrollbar component.');
        }
    }
    ngOnDestroy() {
        this.subscription.unsubscribe();
    }
    scrollReached() {
        // current event
        let currEvent;
        return this.scrollEvent.pipe(tap((e) => currEvent = e), 
        // Check if scroll has reached
        map((e) => this.reached(this.offset, e)), 
        // Distinct until reached value has changed
        distinctUntilChanged(), 
        // Emit only if reached is true
        filter((reached) => reached), 
        // Return scroll event
        map(() => currEvent));
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: ScrollReached, deps: [{ token: i1.NgScrollbar, optional: true }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: ScrollReached, inputs: { offset: ["reachedOffset", "offset"] }, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: ScrollReached, decorators: [{
            type: Directive
        }], ctorParameters: function () { return [{ type: i1.NgScrollbar, decorators: [{
                    type: Optional
                }] }, { type: i0.NgZone }]; }, propDecorators: { offset: [{
                type: Input,
                args: ['reachedOffset']
            }] } });
class VerticalScrollReached extends ScrollReached {
    constructor(scrollbar, zone) {
        super(scrollbar, zone);
        this.scrollbar = scrollbar;
        this.zone = zone;
    }
    ngOnInit() {
        this.zone.runOutsideAngular(() => {
            // Fix the viewport size in case the rendered size is not rounded
            const fixedSize = Math.round(this.scrollbar.viewport.nativeElement.getBoundingClientRect().height);
            this.scrollbar.viewport.nativeElement.style.height = `${fixedSize}px`;
            this.subscription = this.scrollbar.verticalScrolled.subscribe(this.scrollEvent);
        });
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: VerticalScrollReached, deps: [{ token: i1.NgScrollbar, optional: true }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: VerticalScrollReached, usesInheritance: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: VerticalScrollReached, decorators: [{
            type: Directive
        }], ctorParameters: function () { return [{ type: i1.NgScrollbar, decorators: [{
                    type: Optional
                }] }, { type: i0.NgZone }]; } });
class HorizontalScrollReached extends ScrollReached {
    constructor(scrollbar, zone) {
        super(scrollbar, zone);
        this.scrollbar = scrollbar;
        this.zone = zone;
    }
    ngOnInit() {
        this.zone.runOutsideAngular(() => {
            // Fix the viewport size in case the rendered size is not rounded
            const fixedSize = Math.round(this.scrollbar.viewport.nativeElement.getBoundingClientRect().width);
            this.scrollbar.viewport.nativeElement.style.width = `${fixedSize}px`;
            this.subscription = this.scrollbar.horizontalScrolled.subscribe(this.scrollEvent);
        });
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: HorizontalScrollReached, deps: [{ token: i1.NgScrollbar, optional: true }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: HorizontalScrollReached, usesInheritance: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: HorizontalScrollReached, decorators: [{
            type: Directive
        }], ctorParameters: function () { return [{ type: i1.NgScrollbar, decorators: [{
                    type: Optional
                }] }, { type: i0.NgZone }]; } });
export class NgScrollbarReachedTop extends VerticalScrollReached {
    constructor(scrollbar, zone) {
        super(scrollbar, zone);
        this.scrollbar = scrollbar;
        this.zone = zone;
        /** Stream that emits when scroll has reached the top */
        this.reachedTop = this.reachedEvent;
    }
    ngOnInit() {
        super.ngOnInit();
    }
    /**
     * Check if scroll has reached the top (vertically)
     * @param offset Scroll offset
     * @param e Scroll event
     */
    reached(offset, e) {
        return ReachedFunctions.reachedTop(offset, e);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: NgScrollbarReachedTop, deps: [{ token: i1.NgScrollbar, optional: true }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: NgScrollbarReachedTop, isStandalone: true, selector: "[reachedTop], [reached-top]", outputs: { reachedTop: "reachedTop" }, usesInheritance: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: NgScrollbarReachedTop, decorators: [{
            type: Directive,
            args: [{
                    selector: '[reachedTop], [reached-top]',
                    standalone: true,
                }]
        }], ctorParameters: function () { return [{ type: i1.NgScrollbar, decorators: [{
                    type: Optional
                }] }, { type: i0.NgZone }]; }, propDecorators: { reachedTop: [{
                type: Output
            }] } });
export class NgScrollbarReachedBottom extends VerticalScrollReached {
    constructor(scrollbar, zone) {
        super(scrollbar, zone);
        this.scrollbar = scrollbar;
        this.zone = zone;
        /** Stream that emits when scroll has reached the bottom */
        this.reachedBottom = this.reachedEvent;
    }
    ngOnInit() {
        super.ngOnInit();
    }
    /**
     * Check if scroll has reached the bottom (vertically)
     * @param offset Scroll offset
     * @param e Scroll event
     */
    reached(offset, e) {
        return ReachedFunctions.reachedBottom(offset, e);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: NgScrollbarReachedBottom, deps: [{ token: i1.NgScrollbar, optional: true }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: NgScrollbarReachedBottom, isStandalone: true, selector: "[reachedBottom], [reached-bottom]", outputs: { reachedBottom: "reachedBottom" }, usesInheritance: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: NgScrollbarReachedBottom, decorators: [{
            type: Directive,
            args: [{
                    selector: '[reachedBottom], [reached-bottom]',
                    standalone: true,
                }]
        }], ctorParameters: function () { return [{ type: i1.NgScrollbar, decorators: [{
                    type: Optional
                }] }, { type: i0.NgZone }]; }, propDecorators: { reachedBottom: [{
                type: Output
            }] } });
export class NgScrollbarReachedStart extends HorizontalScrollReached {
    constructor(scrollbar, zone, dir) {
        super(scrollbar, zone);
        this.scrollbar = scrollbar;
        this.zone = zone;
        this.dir = dir;
        /** Stream that emits when scroll has reached the start */
        this.reachedStart = this.reachedEvent;
    }
    ngOnInit() {
        super.ngOnInit();
    }
    /**
     * Check if scroll has reached the start (horizontally)
     * @param offset Scroll offset
     * @param e Scroll event
     */
    reached(offset, e) {
        return ReachedFunctions.reachedStart(offset, e, this.dir.value, this.scrollbar.manager.rtlScrollAxisType);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: NgScrollbarReachedStart, deps: [{ token: i1.NgScrollbar, optional: true }, { token: i0.NgZone }, { token: i2.Directionality }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: NgScrollbarReachedStart, isStandalone: true, selector: "[reachedStart], [reached-start]", outputs: { reachedStart: "reachedStart" }, usesInheritance: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: NgScrollbarReachedStart, decorators: [{
            type: Directive,
            args: [{
                    selector: '[reachedStart], [reached-start]',
                    standalone: true,
                }]
        }], ctorParameters: function () { return [{ type: i1.NgScrollbar, decorators: [{
                    type: Optional
                }] }, { type: i0.NgZone }, { type: i2.Directionality }]; }, propDecorators: { reachedStart: [{
                type: Output
            }] } });
export class NgScrollbarReachedEnd extends HorizontalScrollReached {
    constructor(scrollbar, zone, dir) {
        super(scrollbar, zone);
        this.scrollbar = scrollbar;
        this.zone = zone;
        this.dir = dir;
        /** Stream that emits when scroll has reached the end */
        this.reachedEnd = this.reachedEvent;
    }
    ngOnInit() {
        super.ngOnInit();
    }
    /**
     * Check if scroll has reached the end (horizontally)
     * @param offset Scroll offset
     * @param e Scroll event
     */
    reached(offset, e) {
        return ReachedFunctions.reachedEnd(offset, e, this.dir.value, this.scrollbar.manager.rtlScrollAxisType);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: NgScrollbarReachedEnd, deps: [{ token: i1.NgScrollbar, optional: true }, { token: i0.NgZone }, { token: i2.Directionality }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.5", type: NgScrollbarReachedEnd, isStandalone: true, selector: "[reachedEnd], [reached-end]", outputs: { reachedEnd: "reachedEnd" }, usesInheritance: true, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.5", ngImport: i0, type: NgScrollbarReachedEnd, decorators: [{
            type: Directive,
            args: [{
                    selector: '[reachedEnd], [reached-end]',
                    standalone: true,
                }]
        }], ctorParameters: function () { return [{ type: i1.NgScrollbar, decorators: [{
                    type: Optional
                }] }, { type: i0.NgZone }, { type: i2.Directionality }]; }, propDecorators: { reachedEnd: [{
                type: Output
            }] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-scrollbar-reached.js","sourceRoot":"","sources":["../../../../projects/ngx-scrollbar/reached-event/src/ng-scrollbar-reached.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Optional, Input, Output, OnInit, OnDestroy, NgZone } from '@angular/core';\r\nimport { Directionality } from '@angular/cdk/bidi';\r\nimport { RtlScrollAxisType } from '@angular/cdk/platform';\r\nimport { NgScrollbar } from 'ngx-scrollbar';\r\nimport { Observable, Subject, Subscription, Subscriber, filter, map, tap, distinctUntilChanged } from 'rxjs';\r\n\r\n// Fix target type on ElementEvent\r\ntype ElementEvent = Event & { target: Element };\r\n\r\nclass ReachedFunctions {\r\n  static reachedTop(offset: number, e: ElementEvent): boolean {\r\n    return ReachedFunctions.reached(-e.target.scrollTop, 0, offset);\r\n  }\r\n\r\n  static reachedBottom(offset: number, e: ElementEvent): boolean {\r\n    return ReachedFunctions.reached(e.target.scrollTop + e.target.clientHeight, e.target.scrollHeight, offset);\r\n  }\r\n\r\n  static reachedStart(offset: number, e: ElementEvent, direction: 'ltr' | 'rtl', rtlScrollAxisType: RtlScrollAxisType): boolean {\r\n    if (direction === 'rtl') {\r\n      if (rtlScrollAxisType === RtlScrollAxisType.NEGATED) {\r\n        return ReachedFunctions.reached(e.target.scrollLeft, 0, offset);\r\n      }\r\n      if (rtlScrollAxisType === RtlScrollAxisType.INVERTED) {\r\n        return ReachedFunctions.reached(-e.target.scrollLeft, 0, offset);\r\n      }\r\n      return ReachedFunctions.reached(e.target.scrollLeft + e.target.clientWidth, e.target.scrollWidth, offset);\r\n    }\r\n    return ReachedFunctions.reached(-e.target.scrollLeft, 0, offset);\r\n  }\r\n\r\n  static reachedEnd(offset: number, e: ElementEvent, direction: 'ltr' | 'rtl', rtlScrollAxisType: RtlScrollAxisType): boolean {\r\n    if (direction === 'rtl') {\r\n      if (rtlScrollAxisType === RtlScrollAxisType.NEGATED) {\r\n        return ReachedFunctions.reached(-(e.target.scrollLeft - e.target.clientWidth), e.target.scrollWidth, offset);\r\n      }\r\n      if (rtlScrollAxisType === RtlScrollAxisType.INVERTED) {\r\n        return ReachedFunctions.reached(-(e.target.scrollLeft + e.target.clientWidth), e.target.scrollWidth, offset);\r\n      }\r\n      return ReachedFunctions.reached(-e.target.scrollLeft, 0, offset);\r\n    }\r\n    return ReachedFunctions.reached(e.target.scrollLeft + e.target.clientWidth, e.target.scrollWidth, offset);\r\n  }\r\n\r\n  static reached(currPosition: number, targetPosition: number, offset: number): boolean {\r\n    return currPosition >= targetPosition - offset;\r\n  }\r\n}\r\n\r\n@Directive()\r\nabstract class ScrollReached implements OnDestroy {\r\n\r\n  /** offset: Reached offset value in px */\r\n  @Input('reachedOffset') offset: number = 0;\r\n\r\n  /**\r\n   * Stream that emits scroll event when `NgScrollbar.scrolled` is initialized.\r\n   *\r\n   * **NOTE:** This subject is used to hold the place of `NgScrollbar.scrolled` when it's not initialized yet\r\n   */\r\n  protected scrollEvent = new Subject<ElementEvent>();\r\n\r\n  /** subscription: Scrolled event subscription, used to unsubscribe from the event on destroy */\r\n  protected subscription = Subscription.EMPTY;\r\n\r\n  /** A stream used to assign the reached output */\r\n  protected reachedEvent = new Observable((subscriber: Subscriber<ElementEvent>) =>\r\n    this.scrollReached().subscribe(_ =>\r\n      Promise.resolve().then(() => this.zone.run(() => subscriber.next(_)))));\r\n\r\n  protected constructor(@Optional() protected scrollbar: NgScrollbar, protected zone: NgZone) {\r\n    if (!scrollbar) {\r\n      console.warn('[NgScrollbarReached Directive]: Host element must be an NgScrollbar component.');\r\n    }\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.subscription.unsubscribe();\r\n  }\r\n\r\n  protected scrollReached(): Observable<ElementEvent> {\r\n    // current event\r\n    let currEvent: ElementEvent;\r\n\r\n    return this.scrollEvent.pipe(\r\n      tap((e: ElementEvent) => currEvent = e),\r\n      // Check if scroll has reached\r\n      map((e: ElementEvent) => this.reached(this.offset, e)),\r\n      // Distinct until reached value has changed\r\n      distinctUntilChanged(),\r\n      // Emit only if reached is true\r\n      filter((reached: boolean) => reached),\r\n      // Return scroll event\r\n      map(() => currEvent)\r\n    );\r\n  }\r\n\r\n  protected abstract reached(offset: number, e?: ElementEvent): boolean;\r\n}\r\n\r\n@Directive()\r\nabstract class VerticalScrollReached extends ScrollReached implements OnInit {\r\n  protected constructor(@Optional() protected scrollbar: NgScrollbar, protected zone: NgZone) {\r\n    super(scrollbar, zone);\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.zone.runOutsideAngular(() => {\r\n      // Fix the viewport size in case the rendered size is not rounded\r\n      const fixedSize: number = Math.round(this.scrollbar.viewport.nativeElement.getBoundingClientRect().height);\r\n      this.scrollbar.viewport.nativeElement.style.height = `${ fixedSize }px`;\r\n\r\n      this.subscription = this.scrollbar.verticalScrolled!.subscribe(this.scrollEvent);\r\n    });\r\n  }\r\n}\r\n\r\n@Directive()\r\nabstract class HorizontalScrollReached extends ScrollReached implements OnInit {\r\n  protected constructor(@Optional() protected scrollbar: NgScrollbar, protected zone: NgZone) {\r\n    super(scrollbar, zone);\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.zone.runOutsideAngular(() => {\r\n      // Fix the viewport size in case the rendered size is not rounded\r\n      const fixedSize: number = Math.round(this.scrollbar.viewport.nativeElement.getBoundingClientRect().width);\r\n      this.scrollbar.viewport.nativeElement.style.width = `${ fixedSize }px`;\r\n\r\n      this.subscription = this.scrollbar.horizontalScrolled!.subscribe(this.scrollEvent);\r\n    });\r\n  }\r\n}\r\n\r\n@Directive({\r\n  selector: '[reachedTop], [reached-top]',\r\n  standalone: true,\r\n})\r\nexport class NgScrollbarReachedTop extends VerticalScrollReached implements OnInit {\r\n\r\n  /** Stream that emits when scroll has reached the top */\r\n  @Output() reachedTop: Observable<ElementEvent> = this.reachedEvent;\r\n\r\n  constructor(@Optional() protected scrollbar: NgScrollbar, protected zone: NgZone) {\r\n    super(scrollbar, zone);\r\n  }\r\n\r\n  ngOnInit() {\r\n    super.ngOnInit();\r\n  }\r\n\r\n  /**\r\n   * Check if scroll has reached the top (vertically)\r\n   * @param offset Scroll offset\r\n   * @param e Scroll event\r\n   */\r\n  protected reached(offset: number, e: ElementEvent): boolean {\r\n    return ReachedFunctions.reachedTop(offset, e);\r\n  }\r\n}\r\n\r\n@Directive({\r\n  selector: '[reachedBottom], [reached-bottom]',\r\n  standalone: true,\r\n})\r\nexport class NgScrollbarReachedBottom extends VerticalScrollReached implements OnInit {\r\n\r\n  /** Stream that emits when scroll has reached the bottom */\r\n  @Output() reachedBottom: Observable<ElementEvent> = this.reachedEvent;\r\n\r\n  constructor(@Optional() protected scrollbar: NgScrollbar, protected zone: NgZone) {\r\n    super(scrollbar, zone);\r\n  }\r\n\r\n  ngOnInit() {\r\n    super.ngOnInit();\r\n  }\r\n\r\n  /**\r\n   * Check if scroll has reached the bottom (vertically)\r\n   * @param offset Scroll offset\r\n   * @param e Scroll event\r\n   */\r\n  protected reached(offset: number, e: ElementEvent): boolean {\r\n    return ReachedFunctions.reachedBottom(offset, e);\r\n  }\r\n}\r\n\r\n@Directive({\r\n  selector: '[reachedStart], [reached-start]',\r\n  standalone: true,\r\n})\r\nexport class NgScrollbarReachedStart extends HorizontalScrollReached implements OnInit {\r\n\r\n  /** Stream that emits when scroll has reached the start */\r\n  @Output() reachedStart: Observable<ElementEvent> = this.reachedEvent;\r\n\r\n  constructor(@Optional() protected scrollbar: NgScrollbar, protected zone: NgZone, private dir: Directionality) {\r\n    super(scrollbar, zone);\r\n  }\r\n\r\n  ngOnInit() {\r\n    super.ngOnInit();\r\n  }\r\n\r\n  /**\r\n   * Check if scroll has reached the start (horizontally)\r\n   * @param offset Scroll offset\r\n   * @param e Scroll event\r\n   */\r\n  protected reached(offset: number, e: ElementEvent): boolean {\r\n    return ReachedFunctions.reachedStart(offset, e, this.dir.value, this.scrollbar.manager.rtlScrollAxisType);\r\n  }\r\n}\r\n\r\n@Directive({\r\n  selector: '[reachedEnd], [reached-end]',\r\n  standalone: true,\r\n})\r\nexport class NgScrollbarReachedEnd extends HorizontalScrollReached implements OnInit {\r\n\r\n  /** Stream that emits when scroll has reached the end */\r\n  @Output() reachedEnd: Observable<ElementEvent> = this.reachedEvent;\r\n\r\n  constructor(@Optional() protected scrollbar: NgScrollbar, protected zone: NgZone, private dir: Directionality) {\r\n    super(scrollbar, zone);\r\n  }\r\n\r\n  ngOnInit() {\r\n    super.ngOnInit();\r\n  }\r\n\r\n  /**\r\n   * Check if scroll has reached the end (horizontally)\r\n   * @param offset Scroll offset\r\n   * @param e Scroll event\r\n   */\r\n  protected reached(offset: number, e: ElementEvent): boolean {\r\n    return ReachedFunctions.reachedEnd(offset, e, this.dir.value, this.scrollbar.manager.rtlScrollAxisType);\r\n  }\r\n}\r\n"]}