ngx-scrollbar-v8
Version:
Custom overlay-scrollbars with native scrolling mechanism.
427 lines • 36.3 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Component, Inject, Input, ViewChild, ContentChild, ElementRef, ChangeDetectorRef, ChangeDetectionStrategy, PLATFORM_ID } from '@angular/core';
import { isPlatformBrowser } from '@angular/common';
import { CdkScrollable } from '@angular/cdk/scrolling';
import { BreakpointObserver, Breakpoints } from '@angular/cdk/layout';
import { fromEvent, Subject } from 'rxjs';
import { takeUntil, tap, throttleTime } from 'rxjs/operators';
import { SmoothScroll } from '../smooth-scroll/smooth-scroll';
import { NgScrollbarView } from './ng-scrollbar-view';
export class NgScrollbar {
/**
* @param {?} _changeDetectorRef
* @param {?} _breakpointObserver
* @param {?} _platform
*/
constructor(_changeDetectorRef, _breakpointObserver, _platform) {
this._changeDetectorRef = _changeDetectorRef;
this._breakpointObserver = _breakpointObserver;
this._platform = _platform;
/**
* Horizontal custom scrollbar
*/
this.trackX = false;
/**
* Vertical custom Scrollbar
*/
this.trackY = true;
/**
* Scrollbar visibility
*/
this.shown = 'native';
/**
* Auto update scrollbars on content changes (Mutation Observer)
*/
this.autoUpdate = true;
/**
* The smooth scroll duration when a scrollbar is clicked
*/
this.scrollToDuration = 300;
/**
* Disable custom scrollbars on specific breakpoints
*/
this.disableOnBreakpoints = [
Breakpoints.HandsetLandscape,
Breakpoints.HandsetPortrait
];
this._disabled = false;
/**
* Unsubscribe component observables on destroy
*/
this._unsubscribe$ = new Subject();
/**
* Steam that emits when scrollbar thumbnail needs to update (for internal uses)
*/
this._updateObserver = new Subject();
this.updateObserver = this._updateObserver.asObservable();
}
/**
* Disable custom scrollbars and switch back to native scrollbars
* @return {?}
*/
get disabled() {
return this._disabled;
}
/**
* @param {?} disable
* @return {?}
*/
set disabled(disable) {
disable ? this.disable() : this.enable();
}
/**
* Viewport Element
* @return {?}
*/
get view() {
return this.customViewPort
? this.customViewPort.virtualScrollViewport.getElementRef().nativeElement
: this.scrollViewport.getElementRef().nativeElement;
}
/**
* @return {?}
*/
get scrollable() {
return this.customViewPort
? this.customViewPort.virtualScrollViewport
: this.scrollViewport;
}
/**
* @return {?}
*/
get smoothScroll() {
return this.customViewPort
? this.customViewPort.smoothScroll
: this.viewSmoothScroll;
}
/**
* @return {?}
*/
showScrollbarY() {
return this.shown === 'always' || this.view.scrollHeight > this.view.clientHeight;
}
/**
* @return {?}
*/
showScrollbarX() {
return this.shown === 'always' || this.view.scrollWidth > this.view.clientWidth;
}
/**
* @return {?}
*/
ngAfterViewInit() {
// Avoid 'expression has changed after it was checked' error when 'disableOnBreakpoints' is set to false
Promise.resolve().then((/**
* @return {?}
*/
() => {
if (!this.disabled) {
if (this.disableOnBreakpoints) {
// Enable/Disable custom scrollbar on breakpoints (Used to disable scrollbars on mobile phones)
this._breakpointObserver.observe(this.disableOnBreakpoints).pipe(tap((/**
* @param {?} result
* @return {?}
*/
(result) => result.matches ? this.disable() : this.enable())), takeUntil(this._unsubscribe$)).subscribe();
}
else {
this.enable();
}
}
// Update state on content changes
this.updateObserver.pipe(throttleTime(200), tap((/**
* @return {?}
*/
() => this._changeDetectorRef.markForCheck())), takeUntil(this._unsubscribe$)).subscribe();
if (isPlatformBrowser(this._platform)) {
// Update on window resize
fromEvent(window, 'resize').pipe(throttleTime(200), tap((/**
* @return {?}
*/
() => this.update())), takeUntil(this._unsubscribe$)).subscribe();
}
}));
}
/**
* @return {?}
*/
ngOnDestroy() {
this._unsubscribe$.next();
this._unsubscribe$.complete();
if (this._observer) {
this._observer.disconnect();
}
}
/**
* Update scrollbar thumbnail position
* @return {?}
*/
update() {
if (!this.disabled) {
this._updateObserver.next();
}
}
/**
* Enable custom scrollbar
* @return {?}
*/
enable() {
if (this.view) {
this._disabled = false;
// Update view
this._changeDetectorRef.markForCheck();
if (!this.customViewPort && this.autoUpdate && isPlatformBrowser(this._platform)) {
// Observe content changes
this._observer = new MutationObserver((/**
* @return {?}
*/
() => this.update()));
this._observer.observe(this.view, { subtree: true, childList: true, characterData: true });
}
}
}
/**
* Disable custom scrollbar
* @return {?}
*/
disable() {
this._disabled = true;
if (this._observer) {
this._observer.disconnect();
}
}
/**
* @param {?} options
* @return {?}
*/
scrollTo(options) {
return this.smoothScroll.scrollTo(options);
}
/**
* @param {?} selector
* @param {?=} offset
* @param {?=} duration
* @param {?=} easeFunc
* @return {?}
*/
scrollToElement(selector, offset = 0, duration, easeFunc) {
return this.smoothScroll.scrollToElement(selector, offset, duration, easeFunc);
}
/**
* @param {?} to
* @param {?=} duration
* @param {?=} easeFunc
* @return {?}
*/
scrollXTo(to, duration, easeFunc) {
return this.smoothScroll.scrollXTo(to, duration, easeFunc);
}
/**
* @param {?} to
* @param {?=} duration
* @param {?=} easeFunc
* @return {?}
*/
scrollYTo(to, duration, easeFunc) {
return this.smoothScroll.scrollYTo(to, duration, easeFunc);
}
/**
* @param {?=} duration
* @param {?=} easeFunc
* @return {?}
*/
scrollToTop(duration, easeFunc) {
return this.smoothScroll.scrollToTop(duration, easeFunc);
}
/**
* @param {?=} duration
* @param {?=} easeFunc
* @return {?}
*/
scrollToBottom(duration, easeFunc) {
return this.smoothScroll.scrollToBottom(duration, easeFunc);
}
/**
* @param {?=} duration
* @param {?=} easeFunc
* @return {?}
*/
scrollToRight(duration, easeFunc) {
return this.smoothScroll.scrollToRight(duration, easeFunc);
}
/**
* @param {?=} duration
* @param {?=} easeFunc
* @return {?}
*/
scrollToLeft(duration, easeFunc) {
return this.smoothScroll.scrollToLeft(duration, easeFunc);
}
}
NgScrollbar.decorators = [
{ type: Component, args: [{
selector: 'ng-scrollbar',
template: "<div class=\"ng-scrollbar-layout ng-scrollbar-x-layout\"\n [class.ng-scrollbar-invert]=\"invertX\">\n\n <div class=\"ng-scrollbar-layout ng-scrollbar-y-layout\"\n [class.ng-scrollbar-invert]=\"invertY\">\n\n <div class=\"ng-scroll-view-container\">\n <div #view\n cdkScrollable\n smoothScroll\n class=\"ng-scroll-view {{viewClass}}\">\n <ng-content></ng-content>\n </div>\n </div>\n\n <ng-scrollbar-y #y\n *ngIf=\"!disabled && trackY\"\n [class.ng-scrollbar-visible]=\"showScrollbarY()\"\n [barClass]=\"barClass\"\n [thumbClass]=\"thumbClass\"\n [scrollToDuration]=\"scrollToDuration\">\n </ng-scrollbar-y>\n </div>\n\n <ng-scrollbar-x #x\n *ngIf=\"!disabled && trackX\"\n [class.ng-scrollbar-visible]=\"showScrollbarX()\"\n [barClass]=\"barClass\"\n [thumbClass]=\"thumbClass\"\n [scrollToDuration]=\"scrollToDuration\">\n </ng-scrollbar-x>\n\n</div>\n",
changeDetection: ChangeDetectionStrategy.OnPush,
host: {
'[attr.customView]': '!!customViewPort',
'[attr.trackX]': 'trackX',
'[attr.trackY]': 'trackY',
'[attr.compact]': 'compact',
'[attr.autoHide]': 'shown === "hover"',
'[attr.disabled]': 'disabled'
},
styles: [":host{display:block;overflow:hidden;--scrollbar-color:transparent;--scrollbar-container-color:transparent;--scrollbar-thumb-color:rgba(0, 0, 0, 0.2);--scrollbar-thumb-hover-color:rgba(0, 0, 0, 0.3);--scrollbar-border-radius:4px;--scrollbar-size:6px;--scrollbar-padding:8px;--scroll-view-margin:0;--scroll-view-color:transparent}:host[trackY=true]>.ng-scrollbar-layout>.ng-scrollbar-layout>.ng-scroll-view-container>.ng-scroll-view{overflow-y:scroll}:host[trackX=true]>.ng-scrollbar-layout>.ng-scrollbar-layout>.ng-scroll-view-container>.ng-scroll-view{overflow-x:scroll}:host>.ng-scrollbar-x-layout{flex-direction:column}:host>.ng-scrollbar-x-layout.ng-scrollbar-invert{flex-direction:column-reverse}:host>.ng-scrollbar-x-layout>.ng-scrollbar-y-layout{flex-direction:row}:host>.ng-scrollbar-x-layout>.ng-scrollbar-y-layout.ng-scrollbar-invert{flex-direction:row-reverse}:host[compact=true]>.ng-scrollbar-x-layout>ng-scrollbar-x{position:absolute;bottom:0}:host[compact=true]>.ng-scrollbar-x-layout.ng-scrollbar-invert>ng-scrollbar-x{top:0;bottom:unset}:host[compact=true]>.ng-scrollbar-x-layout>.ng-scrollbar-y-layout>ng-scrollbar-y{position:absolute;right:0;left:unset}:host[compact=true]>.ng-scrollbar-x-layout>.ng-scrollbar-y-layout.ng-scrollbar-invert>ng-scrollbar-y{right:unset;left:0}:host[autoHide=true]>.ng-scrollbar-layout>.ng-scrollbar-layout>ng-scrollbar-y,:host[autoHide=true]>.ng-scrollbar-layout>ng-scrollbar-x{opacity:0;transition:opacity 120ms ease-out}:host[autoHide=true]:active>.ng-scrollbar-layout>.ng-scrollbar-layout>ng-scrollbar-y,:host[autoHide=true]:active>.ng-scrollbar-layout>ng-scrollbar-x,:host[autoHide=true]:focus>.ng-scrollbar-layout>.ng-scrollbar-layout>ng-scrollbar-y,:host[autoHide=true]:focus>.ng-scrollbar-layout>ng-scrollbar-x,:host[autoHide=true]:hover>.ng-scrollbar-layout>.ng-scrollbar-layout>ng-scrollbar-y,:host[autoHide=true]:hover>.ng-scrollbar-layout>ng-scrollbar-x{opacity:1;transition:opacity 340ms ease-out}:host[customView=true] .ng-scroll-view{overflow:hidden!important}.ng-scroll-view,.ng-scrollbar-layout,:host{position:relative;height:100%;width:100%}.ng-scrollbar-layout{display:flex;min-height:0}.ng-scroll-view-container{flex:1;position:relative;overflow:hidden;margin:var(--scroll-view-margin)}.ng-scroll-view{box-sizing:content-box;-webkit-transform:translateZ(0);transform:translateZ(0);background:var(--scroll-view-color);-webkit-overflow-scrolling:touch}ng-scrollbar-x,ng-scrollbar-y{display:none;box-sizing:border-box;padding:var(--scrollbar-padding);background:var(--scrollbar-container-color)}ng-scrollbar-x.ng-scrollbar-visible,ng-scrollbar-y.ng-scrollbar-visible{display:block}ng-scrollbar-y{top:0;bottom:0}ng-scrollbar-x{left:0;right:0}::ng-deep ng-scrollbar-y .ng-scrollbar{width:var(--scrollbar-size)}::ng-deep ng-scrollbar-y .ng-scrollbar-thumb{width:100%}::ng-deep ng-scrollbar-x .ng-scrollbar{height:var(--scrollbar-size)}::ng-deep ng-scrollbar-x .ng-scrollbar-thumb{height:100%}::ng-deep .ng-scrollbar{height:100%;width:100%;z-index:1;border-radius:var(--scrollbar-border-radius);background-color:var(--scrollbar-color)}::ng-deep .ng-scrollbar-thumb{box-sizing:border-box;position:relative;width:0;height:0;border-radius:inherit;background-color:var(--scrollbar-thumb-color);-webkit-transform:translate3d(0,0,0);transform:translate3d(0,0,0);transition:height 150ms ease-out}::ng-deep .ng-scrollbar-thumb:active,::ng-deep .ng-scrollbar-thumb:hover{background-color:var(--scrollbar-thumb-hover-color)}::ng-deep .ng-custom-scroll-view{height:100%}.show-native-scrollbars,:host[disabled=true] .ng-scroll-view,:host[disabled=true] ::ng-deep .ng-scroll-view>.ng-custom-scroll-view{margin:0!important;padding:0!important}.hide-native-scrollbars,:host[disabled=false] .ng-scroll-view,:host[disabled=false] ::ng-deep .ng-scroll-view>.ng-custom-scroll-view{margin-right:-30px!important;padding-right:30px!important;margin-bottom:-30px!important;padding-bottom:30px!important}"]
}] }
];
/** @nocollapse */
NgScrollbar.ctorParameters = () => [
{ type: ChangeDetectorRef },
{ type: BreakpointObserver },
{ type: Object, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
];
NgScrollbar.propDecorators = {
trackX: [{ type: Input }],
trackY: [{ type: Input }],
shown: [{ type: Input }],
autoUpdate: [{ type: Input }],
viewClass: [{ type: Input }],
barClass: [{ type: Input }],
thumbClass: [{ type: Input }],
scrollToDuration: [{ type: Input }],
compact: [{ type: Input }],
invertY: [{ type: Input }],
invertX: [{ type: Input }],
disableOnBreakpoints: [{ type: Input }],
disabled: [{ type: Input, args: ['disabled',] }],
verticalScrollbar: [{ type: ViewChild, args: ['y', { read: ElementRef, static: false },] }],
horizontalScrollbar: [{ type: ViewChild, args: ['x', { read: ElementRef, static: false },] }],
scrollViewport: [{ type: ViewChild, args: [CdkScrollable, { static: true },] }],
viewSmoothScroll: [{ type: ViewChild, args: [SmoothScroll, { static: true },] }],
customViewPort: [{ type: ContentChild, args: [NgScrollbarView, { static: true },] }]
};
if (false) {
/**
* Horizontal custom scrollbar
* @type {?}
*/
NgScrollbar.prototype.trackX;
/**
* Vertical custom Scrollbar
* @type {?}
*/
NgScrollbar.prototype.trackY;
/**
* Scrollbar visibility
* @type {?}
*/
NgScrollbar.prototype.shown;
/**
* Auto update scrollbars on content changes (Mutation Observer)
* @type {?}
*/
NgScrollbar.prototype.autoUpdate;
/**
* Viewport class
* @type {?}
*/
NgScrollbar.prototype.viewClass;
/**
* Scrollbars class
* @type {?}
*/
NgScrollbar.prototype.barClass;
/**
* Scrollbars thumbnails class
* @type {?}
*/
NgScrollbar.prototype.thumbClass;
/**
* The smooth scroll duration when a scrollbar is clicked
* @type {?}
*/
NgScrollbar.prototype.scrollToDuration;
/**
* Compact mode
* @type {?}
*/
NgScrollbar.prototype.compact;
/**
* Invert vertical scrollbar position, if set the scrollbar will be on the right
* @type {?}
*/
NgScrollbar.prototype.invertY;
/**
* Invert horizontal scrollbar position, if set the scrollbar will go the top
* @type {?}
*/
NgScrollbar.prototype.invertX;
/**
* Disable custom scrollbars on specific breakpoints
* @type {?}
*/
NgScrollbar.prototype.disableOnBreakpoints;
/**
* @type {?}
* @private
*/
NgScrollbar.prototype._disabled;
/**
* Scrollbars ElementRef
* @type {?}
*/
NgScrollbar.prototype.verticalScrollbar;
/** @type {?} */
NgScrollbar.prototype.horizontalScrollbar;
/**
* Default viewport and smoothScroll references
* @type {?}
*/
NgScrollbar.prototype.scrollViewport;
/** @type {?} */
NgScrollbar.prototype.viewSmoothScroll;
/**
* Virtual viewport and smoothScroll references
* @type {?}
*/
NgScrollbar.prototype.customViewPort;
/**
* Unsubscribe component observables on destroy
* @type {?}
* @private
*/
NgScrollbar.prototype._unsubscribe$;
/**
* Observe content changes
* @type {?}
* @private
*/
NgScrollbar.prototype._observer;
/**
* Steam that emits when scrollbar thumbnail needs to update (for internal uses)
* @type {?}
* @private
*/
NgScrollbar.prototype._updateObserver;
/** @type {?} */
NgScrollbar.prototype.updateObserver;
/**
* @type {?}
* @private
*/
NgScrollbar.prototype._changeDetectorRef;
/**
* @type {?}
* @private
*/
NgScrollbar.prototype._breakpointObserver;
/**
* @type {?}
* @private
*/
NgScrollbar.prototype._platform;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-scrollbar.js","sourceRoot":"ng://ngx-scrollbar/","sources":["scrollbar/ng-scrollbar.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  Inject,\n  Input,\n  ViewChild,\n  ContentChild,\n  AfterViewInit,\n  OnDestroy,\n  ElementRef,\n  ChangeDetectorRef,\n  ChangeDetectionStrategy,\n  PLATFORM_ID\n} from '@angular/core';\nimport {isPlatformBrowser} from '@angular/common';\nimport {CdkScrollable, CdkVirtualScrollViewport} from '@angular/cdk/scrolling';\nimport {BreakpointObserver, Breakpoints, BreakpointState} from '@angular/cdk/layout';\nimport {fromEvent, Observable, Subject} from 'rxjs';\nimport {takeUntil, tap, throttleTime} from 'rxjs/operators';\nimport {ScrollToOptions, SmoothScroll, SmoothScrollEaseFunc} from '../smooth-scroll/smooth-scroll';\nimport {NgScrollbarView} from './ng-scrollbar-view';\n\n@Component({\n  selector: 'ng-scrollbar',\n  templateUrl: 'ng-scrollbar.html',\n  styleUrls: ['ng-scrollbar.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  host: {\n    '[attr.customView]': '!!customViewPort',\n    '[attr.trackX]': 'trackX',\n    '[attr.trackY]': 'trackY',\n    '[attr.compact]': 'compact',\n    '[attr.autoHide]': 'shown === \"hover\"',\n    '[attr.disabled]': 'disabled'\n  }\n})\nexport class NgScrollbar implements AfterViewInit, OnDestroy {\n\n  /** Horizontal custom scrollbar */\n  @Input() trackX = false;\n  /** Vertical custom Scrollbar */\n  @Input() trackY = true;\n  /** Scrollbar visibility */\n  @Input() shown: 'hover' | 'always' | 'native' = 'native';\n  /** Auto update scrollbars on content changes (Mutation Observer) */\n  @Input() autoUpdate = true;\n  /** Viewport class */\n  @Input() viewClass: string;\n  /** Scrollbars class */\n  @Input() barClass: string;\n  /** Scrollbars thumbnails class */\n  @Input() thumbClass: string;\n  /** The smooth scroll duration when a scrollbar is clicked */\n  @Input() scrollToDuration = 300;\n  /** Compact mode */\n  @Input() compact: boolean;\n  /** Invert vertical scrollbar position, if set the scrollbar will be on the right */\n  @Input() invertY: boolean;\n  /** Invert horizontal scrollbar position, if set the scrollbar will go the top */\n  @Input() invertX: boolean;\n  /** Disable custom scrollbars on specific breakpoints */\n  @Input() disableOnBreakpoints = [\n    Breakpoints.HandsetLandscape,\n    Breakpoints.HandsetPortrait\n  ];\n\n  /** Disable custom scrollbars and switch back to native scrollbars */\n  @Input('disabled')\n  get disabled() {\n    return this._disabled;\n  }\n\n  set disabled(disable: boolean) {\n    disable ? this.disable() : this.enable();\n  }\n\n  private _disabled = false;\n\n  /** Scrollbars ElementRef */\n  @ViewChild('y', { read: ElementRef, static: false }) verticalScrollbar: ElementRef;\n  @ViewChild('x', { read: ElementRef, static: false }) horizontalScrollbar: ElementRef;\n\n  /** Default viewport and smoothScroll references */\n  @ViewChild(CdkScrollable, { static: true }) scrollViewport: CdkScrollable;\n  @ViewChild(SmoothScroll, { static: true }) viewSmoothScroll: SmoothScroll;\n\n  /** Virtual viewport and smoothScroll references */\n  @ContentChild(NgScrollbarView, { static: true }) customViewPort: NgScrollbarView;\n\n  /** Viewport Element */\n  get view(): HTMLElement {\n    return this.customViewPort\n      ? this.customViewPort.virtualScrollViewport.getElementRef().nativeElement\n      : this.scrollViewport.getElementRef().nativeElement;\n  }\n\n  get scrollable(): CdkScrollable | CdkVirtualScrollViewport {\n    return this.customViewPort\n      ? this.customViewPort.virtualScrollViewport\n      : this.scrollViewport;\n  }\n\n  get smoothScroll(): SmoothScroll {\n    return this.customViewPort\n      ? this.customViewPort.smoothScroll\n      : this.viewSmoothScroll;\n  }\n\n  /** Unsubscribe component observables on destroy */\n  private _unsubscribe$ = new Subject();\n  /** Observe content changes */\n  private _observer: MutationObserver;\n\n  /** Steam that emits when scrollbar thumbnail needs to update (for internal uses) */\n  private _updateObserver = new Subject();\n  updateObserver = this._updateObserver.asObservable();\n\n  constructor(private _changeDetectorRef: ChangeDetectorRef,\n              private _breakpointObserver: BreakpointObserver,\n              @Inject(PLATFORM_ID) private _platform: Object) {\n  }\n\n  showScrollbarY() {\n    return this.shown === 'always' || this.view.scrollHeight > this.view.clientHeight;\n  }\n\n  showScrollbarX() {\n    return this.shown === 'always' || this.view.scrollWidth > this.view.clientWidth;\n  }\n\n  ngAfterViewInit() {\n    // Avoid 'expression has changed after it was checked' error when 'disableOnBreakpoints' is set to false\n    Promise.resolve().then(() => {\n      if (!this.disabled) {\n        if (this.disableOnBreakpoints) {\n          // Enable/Disable custom scrollbar on breakpoints (Used to disable scrollbars on mobile phones)\n          this._breakpointObserver.observe(this.disableOnBreakpoints).pipe(\n            tap((result: BreakpointState) => result.matches ? this.disable() : this.enable()),\n            takeUntil(this._unsubscribe$)\n          ).subscribe();\n        } else {\n          this.enable();\n        }\n      }\n\n      // Update state on content changes\n      this.updateObserver.pipe(\n        throttleTime(200),\n        tap(() => this._changeDetectorRef.markForCheck()),\n        takeUntil(this._unsubscribe$)\n      ).subscribe();\n\n\n      if (isPlatformBrowser(this._platform)) {\n        // Update on window resize\n        fromEvent(window, 'resize').pipe(\n          throttleTime(200),\n          tap(() => this.update()),\n          takeUntil(this._unsubscribe$)\n        ).subscribe();\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    this._unsubscribe$.next();\n    this._unsubscribe$.complete();\n    if (this._observer) {\n      this._observer.disconnect();\n    }\n  }\n\n  /**\n   * Update scrollbar thumbnail position\n   */\n  update() {\n    if (!this.disabled) {\n      this._updateObserver.next();\n    }\n  }\n\n  /**\n   * Enable custom scrollbar\n   */\n  enable() {\n    if (this.view) {\n      this._disabled = false;\n      // Update view\n      this._changeDetectorRef.markForCheck();\n\n      if (!this.customViewPort && this.autoUpdate && isPlatformBrowser(this._platform)) {\n        // Observe content changes\n        this._observer = new MutationObserver(() => this.update());\n        this._observer.observe(this.view, {subtree: true, childList: true, characterData: true});\n      }\n    }\n  }\n\n  /**\n   * Disable custom scrollbar\n   */\n  disable() {\n    this._disabled = true;\n    if (this._observer) {\n      this._observer.disconnect();\n    }\n  }\n\n  scrollTo(options: ScrollToOptions): Observable<void> {\n    return this.smoothScroll.scrollTo(options);\n  }\n\n  scrollToElement(selector: string, offset = 0, duration?: number, easeFunc?: SmoothScrollEaseFunc): Observable<void> {\n    return this.smoothScroll.scrollToElement(selector, offset, duration, easeFunc);\n  }\n\n  scrollXTo(to: number, duration?: number, easeFunc?: SmoothScrollEaseFunc): Observable<void> {\n    return this.smoothScroll.scrollXTo(to, duration, easeFunc);\n  }\n\n  scrollYTo(to: number, duration?: number, easeFunc?: SmoothScrollEaseFunc): Observable<void> {\n    return this.smoothScroll.scrollYTo(to, duration, easeFunc);\n  }\n\n  scrollToTop(duration?: number, easeFunc?: SmoothScrollEaseFunc): Observable<void> {\n    return this.smoothScroll.scrollToTop(duration, easeFunc);\n  }\n\n  scrollToBottom(duration?: number, easeFunc?: SmoothScrollEaseFunc): Observable<void> {\n    return this.smoothScroll.scrollToBottom(duration, easeFunc);\n  }\n\n  scrollToRight(duration?: number, easeFunc?: SmoothScrollEaseFunc): Observable<void> {\n    return this.smoothScroll.scrollToRight(duration, easeFunc);\n  }\n\n  scrollToLeft(duration?: number, easeFunc?: SmoothScrollEaseFunc): Observable<void> {\n    return this.smoothScroll.scrollToLeft(duration, easeFunc);\n  }\n}\n"]}