@resolveio/client-lib-core 0.0.1

package/esm2020/lib/core.module.mjs

@@ -0,0 +1,179 @@
+import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
+import { NgModule } from '@angular/core';
+import { CoreComponent } from './core.component';
+import { AccountManagerService } from './account-manager.service';
+import { SocketManagerService } from './socket-manager.service';
+import { DeviceDetectorService } from 'ngx-device-detector';
+import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
+import { NavbarMainComponent } from './widgets/navbar-main/navbar-main.component';
+import { NavbarModuleComponent } from './widgets/navbar-module/navbar-module.component';
+import { LoggerComponent } from './logger/logger.component';
+import { HomeModule } from './home/home.module';
+import { CoreService } from './core.service';
+import { AuthService } from './auth/auth.service';
+import { AuthGuard } from './auth/auth-guard.service';
+import { CanDeactivateGuard } from './auth/can-deactivate-guard.service';
+import { ValidationService } from './util/validation.service';
+import { AuthPermissionService } from './auth/auth-permissions.service';
+import { WindowRefService } from './util/window.service';
+import { ToastrModule } from 'ngx-toastr';
+import { AlertService } from './widgets/alert/alert.service';
+import { AwsService } from './util/aws.service';
+import { DialogService } from './widgets/dialog/dialog.service';
+import { SocketService } from './socket.service';
+import { TokenManagerService } from './token-manager.service';
+import { NgxLocalStorageModule } from 'ngx-localstorage';
+import { SharedModule } from './shared/shared.module';
+import { OfflineManagerService } from './offline-manager.service';
+import { FocusDirective } from './directive/focus';
+import { ForgotPasswordComponent } from './auth/forgot-password.component';
+import { EnrollComponent } from './auth/enroll.component';
+import { DialogConfirmContent } from './widgets/dialog/dialog.confirm.content';
+import { DialogErrorContent } from './widgets/dialog/dialog.error.content';
+import { DialogInputContent } from './widgets/dialog/dialog.input.content';
+import { DialogNotifyContent } from './widgets/dialog/dialog.notify.content';
+import { DialogSelectDateTimeContent } from './widgets/dialog/dialog.select-datetime.content';
+import { DialogSelectDataLabelsContent } from './widgets/dialog/dialog.select-data-labels.content';
+import { DialogLoginContent } from './widgets/dialog/dialog.login.content';
+import { HttpClientModule } from '@angular/common/http';
+import { ScrollDirective } from './directive/scroll';
+// import { TourNgBootstrapModule } from './widgets/ngx-tour-ng-bootstrap/ng-bootstrap.module';
+import { StandardPagesModule } from './standard-pages/standard-pages.module';
+import { DialogRegisterContent } from './widgets/dialog/dialog.register.content';
+import { Auth365Component } from './auth/auth365.component';
+import { UserSettingsModule } from './user-settings/user-settings.module';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-toastr";
+import * as i2 from "ngx-localstorage";
+export class CoreModule {
+}
+CoreModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CoreModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CoreModule, declarations: [CoreComponent,
+        LoggerComponent,
+        NavbarMainComponent,
+        NavbarModuleComponent,
+        ForgotPasswordComponent,
+        EnrollComponent,
+        Auth365Component,
+        FocusDirective,
+        ScrollDirective,
+        DialogConfirmContent,
+        DialogErrorContent,
+        DialogInputContent,
+        DialogNotifyContent,
+        DialogSelectDateTimeContent,
+        DialogSelectDataLabelsContent,
+        DialogLoginContent,
+        DialogRegisterContent], imports: [SharedModule,
+        HttpClientModule,
+        NgbModule, i1.ToastrModule, HomeModule,
+        StandardPagesModule, i2.NgxLocalStorageModule, UserSettingsModule,
+        // TourNgBootstrapModule.forRoot(),
+        BrowserAnimationsModule], exports: [CoreComponent,
+        LoggerComponent,
+        NavbarMainComponent,
+        NavbarModuleComponent,
+        ForgotPasswordComponent,
+        EnrollComponent,
+        Auth365Component,
+        FocusDirective,
+        ScrollDirective] });
+CoreModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CoreModule, providers: [
+        CoreService,
+        AuthService,
+        AuthGuard,
+        CanDeactivateGuard,
+        DialogService,
+        ValidationService,
+        AwsService,
+        AuthPermissionService,
+        WindowRefService,
+        AlertService,
+        SocketService,
+        SocketManagerService,
+        TokenManagerService,
+        AccountManagerService,
+        OfflineManagerService,
+        DeviceDetectorService
+    ], imports: [[
+            SharedModule,
+            HttpClientModule,
+            NgbModule,
+            ToastrModule.forRoot(),
+            HomeModule,
+            StandardPagesModule,
+            NgxLocalStorageModule.forRoot({
+                prefix: 'ResolveIO'
+            }),
+            UserSettingsModule,
+            // TourNgBootstrapModule.forRoot(),
+            BrowserAnimationsModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        SharedModule,
+                        HttpClientModule,
+                        NgbModule,
+                        ToastrModule.forRoot(),
+                        HomeModule,
+                        StandardPagesModule,
+                        NgxLocalStorageModule.forRoot({
+                            prefix: 'ResolveIO'
+                        }),
+                        UserSettingsModule,
+                        // TourNgBootstrapModule.forRoot(),
+                        BrowserAnimationsModule
+                    ],
+                    declarations: [
+                        CoreComponent,
+                        LoggerComponent,
+                        NavbarMainComponent,
+                        NavbarModuleComponent,
+                        ForgotPasswordComponent,
+                        EnrollComponent,
+                        Auth365Component,
+                        FocusDirective,
+                        ScrollDirective,
+                        DialogConfirmContent,
+                        DialogErrorContent,
+                        DialogInputContent,
+                        DialogNotifyContent,
+                        DialogSelectDateTimeContent,
+                        DialogSelectDataLabelsContent,
+                        DialogLoginContent,
+                        DialogRegisterContent
+                    ],
+                    providers: [
+                        CoreService,
+                        AuthService,
+                        AuthGuard,
+                        CanDeactivateGuard,
+                        DialogService,
+                        ValidationService,
+                        AwsService,
+                        AuthPermissionService,
+                        WindowRefService,
+                        AlertService,
+                        SocketService,
+                        SocketManagerService,
+                        TokenManagerService,
+                        AccountManagerService,
+                        OfflineManagerService,
+                        DeviceDetectorService
+                    ],
+                    exports: [
+                        CoreComponent,
+                        LoggerComponent,
+                        NavbarMainComponent,
+                        NavbarModuleComponent,
+                        ForgotPasswordComponent,
+                        EnrollComponent,
+                        Auth365Component,
+                        FocusDirective,
+                        ScrollDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.module.js","sourceRoot":"","sources":["../../../../projects/core/src/lib/core.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { BrowserAnimationsModule } from '@angular/platform-browser/animations';\nimport { NgModule } from '@angular/core';\nimport { CoreComponent } from './core.component';\n\nimport { AccountManagerService } from './account-manager.service';\nimport { SocketManagerService } from './socket-manager.service';\nimport { BrowserModule } from '@angular/platform-browser';\n\nimport { DeviceDetectorService } from 'ngx-device-detector';\nimport { NgbModule } from '@ng-bootstrap/ng-bootstrap';\n\nimport { NavbarMainComponent } from './widgets/navbar-main/navbar-main.component';\nimport { NavbarModuleComponent } from './widgets/navbar-module/navbar-module.component';\nimport { LoggerComponent } from './logger/logger.component';\n\nimport { HomeModule } from './home/home.module';\n\nimport { CoreService } from './core.service';\nimport { AuthService } from './auth/auth.service';\nimport { AuthGuard } from './auth/auth-guard.service';\nimport { CanDeactivateGuard } from './auth/can-deactivate-guard.service';\nimport { ValidationService } from './util/validation.service';\nimport { AuthPermissionService } from './auth/auth-permissions.service';\nimport { WindowRefService } from './util/window.service';\nimport { ToastrModule } from 'ngx-toastr';\nimport { AlertService } from './widgets/alert/alert.service';\nimport { AwsService } from './util/aws.service';\nimport { DialogService } from './widgets/dialog/dialog.service';\nimport { SocketService } from './socket.service';\nimport { TokenManagerService } from './token-manager.service';\nimport { NgxLocalStorageModule } from 'ngx-localstorage';\n\nimport { SharedModule } from './shared/shared.module';\n\nimport { OfflineManagerService } from './offline-manager.service';\nimport { FocusDirective } from './directive/focus';\nimport { ForgotPasswordComponent } from './auth/forgot-password.component';\nimport { EnrollComponent } from './auth/enroll.component';\nimport { DialogConfirmContent } from './widgets/dialog/dialog.confirm.content';\nimport { DialogErrorContent } from './widgets/dialog/dialog.error.content';\nimport { DialogInputContent } from './widgets/dialog/dialog.input.content';\nimport { DialogNotifyContent } from './widgets/dialog/dialog.notify.content';\nimport { DialogSelectDateTimeContent } from './widgets/dialog/dialog.select-datetime.content';\nimport { DialogSelectDataLabelsContent } from './widgets/dialog/dialog.select-data-labels.content';\nimport { DialogLoginContent } from './widgets/dialog/dialog.login.content';\nimport { HttpClientModule } from '@angular/common/http';\nimport { ScrollDirective } from './directive/scroll';\n// import { TourNgBootstrapModule } from './widgets/ngx-tour-ng-bootstrap/ng-bootstrap.module';\nimport { StandardPagesModule } from './standard-pages/standard-pages.module';\nimport { DialogRegisterContent } from './widgets/dialog/dialog.register.content';\nimport { Auth365Component } from './auth/auth365.component';\nimport { UserSettingsModule } from './user-settings/user-settings.module';\n\n@NgModule({\n    imports: [\n        SharedModule,\n        HttpClientModule,\n        NgbModule,\n        ToastrModule.forRoot(),\n        HomeModule,\n        StandardPagesModule,\n        NgxLocalStorageModule.forRoot({\n            prefix: 'ResolveIO'\n        }),\n        UserSettingsModule,\n        // TourNgBootstrapModule.forRoot(),\n        BrowserAnimationsModule\n    ],\n    declarations: [\n        CoreComponent,\n        LoggerComponent,\n        NavbarMainComponent,\n        NavbarModuleComponent,\n        ForgotPasswordComponent,\n        EnrollComponent,\n        Auth365Component,\n        FocusDirective,\n        ScrollDirective,\n        DialogConfirmContent,\n        DialogErrorContent,\n        DialogInputContent,\n        DialogNotifyContent,\n        DialogSelectDateTimeContent,\n        DialogSelectDataLabelsContent,\n        DialogLoginContent,\n        DialogRegisterContent\n    ],\n    providers: [\n        CoreService,\n        AuthService,\n        AuthGuard,\n        CanDeactivateGuard,\n        DialogService,\n        ValidationService,\n        AwsService,\n        AuthPermissionService,\n        WindowRefService,\n        AlertService,\n        SocketService,\n        SocketManagerService,\n        TokenManagerService,\n        AccountManagerService,\n        OfflineManagerService,\n        DeviceDetectorService\n    ],\n    exports: [\n        CoreComponent,\n        LoggerComponent,\n        NavbarMainComponent,\n        NavbarModuleComponent,\n        ForgotPasswordComponent,\n        EnrollComponent,\n        Auth365Component,\n        FocusDirective,\n        ScrollDirective\n    ]\n})\nexport class CoreModule { }\n"]}

package/esm2020/lib/core.service.mjs

@@ -0,0 +1,96 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class CoreService {
+    // customHomePage = new BehaviorSubject(false);
+    // logo = new BehaviorSubject('');
+    constructor() {
+        this.showResolveIOHomepage = new BehaviorSubject(false);
+        this.isDevice = new BehaviorSubject(false);
+        this.fullScreen = new BehaviorSubject(false);
+        this.fsActivated = new BehaviorSubject(false);
+        this.hasConnected = new BehaviorSubject(false);
+        this.navbarModuleData = new BehaviorSubject({
+            title: '',
+            module: '',
+            description: '',
+            description_name: '',
+            tabs: []
+        });
+        this.hasStatusMessage = new BehaviorSubject(false);
+        this.alertData = new BehaviorSubject({
+            type: '',
+            message: '',
+            timer: 0,
+            showing: false
+        });
+        this.isInvalidVersion = new BehaviorSubject(false);
+        this.isInvalidSW = new BehaviorSubject(false);
+        this.environment = new BehaviorSubject(null);
+        this.client = new BehaviorSubject('');
+        this.standardProgram = new BehaviorSubject(false);
+        this.navTabs = new BehaviorSubject([]);
+        this.tourStops = new BehaviorSubject([]);
+        this.tourStarted = new BehaviorSubject(false);
+        this.isDemo = new BehaviorSubject(false);
+        this.isLoggingOut = new BehaviorSubject(false);
+    }
+    setResolveIOHomepage(showResolveIOHomepage) {
+        this.showResolveIOHomepage.next(showResolveIOHomepage);
+    }
+    setFullScreen(fullScreen) {
+        this.fullScreen.next(fullScreen);
+    }
+    setFsActivated(activated) {
+        this.fsActivated.next(activated);
+    }
+    setHasConnected(connected) {
+        this.hasConnected.next(connected);
+    }
+    setNavbarModuleData(data) {
+        data.tabs = data.tabs.filter(a => a.params === null).sort((a, b) => a.label.localeCompare(b.label)).concat(data.tabs.filter(a => a.params !== null).sort((a, b) => a.label.localeCompare(b.label)));
+        this.navbarModuleData.next(data);
+    }
+    setHasStatusMessage(data) {
+        this.hasStatusMessage.next(data);
+    }
+    setIsDevice(data) {
+        this.isDevice.next(data);
+    }
+    setIsInvalidVersion(data) {
+        this.isInvalidVersion.next(data);
+    }
+    setIsInvalidSW(data) {
+        this.isInvalidSW.next(data);
+    }
+    setEnvironment(env) {
+        this.environment.next(env);
+    }
+    setClient(client) {
+        this.client.next(client);
+    }
+    setStandardProgram(standardProgram) {
+        this.standardProgram.next(standardProgram);
+    }
+    setNavTabs(navTabs) {
+        this.navTabs.next(navTabs);
+    }
+    setTourStops(tourStops) {
+        this.tourStops.next(tourStops);
+    }
+    setTourStarted(tourStarted) {
+        this.tourStarted.next(tourStarted);
+    }
+    setDemo(isDemo) {
+        this.isDemo.next(isDemo);
+    }
+}
+CoreService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CoreService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CoreService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CoreService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: CoreService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.service.js","sourceRoot":"","sources":["../../../../projects/core/src/lib/core.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\nimport { NavbarModel } from './widgets/navbar-module/navbar-module.model';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class CoreService {\n\tshowResolveIOHomepage = new BehaviorSubject(false);\n  \tisDevice = new BehaviorSubject(false);\n\tfullScreen = new BehaviorSubject(false);\n\tfsActivated = new BehaviorSubject(false);\n\thasConnected = new BehaviorSubject(false);\n\tnavbarModuleData = new BehaviorSubject({\n\t\ttitle: '',\n\t\tmodule: '',\n\t\tdescription: '',\n\t\tdescription_name: '',\n\t\ttabs: []\n\t});\n\thasStatusMessage = new BehaviorSubject(false);\n\talertData = new BehaviorSubject({\n\t\ttype: '',\n\t\tmessage: '',\n\t\ttimer: 0,\n\t\tshowing: false\n\t});\n\tisInvalidVersion = new BehaviorSubject(false);\n\tisInvalidSW = new BehaviorSubject(false);\n\tenvironment = new BehaviorSubject(null);\n\tclient = new BehaviorSubject('');\n\tstandardProgram = new BehaviorSubject(false);\n\tnavTabs = new BehaviorSubject([]);\n\ttourStops = new BehaviorSubject([]);\n\ttourStarted = new BehaviorSubject(false);\n\tisDemo = new BehaviorSubject(false);\n\tisLoggingOut = new BehaviorSubject(false);\n\t// customHomePage = new BehaviorSubject(false);\n\t// logo = new BehaviorSubject('');\n\n\tconstructor() {}\n\n\tsetResolveIOHomepage(showResolveIOHomepage: boolean) {\n\t\tthis.showResolveIOHomepage.next(showResolveIOHomepage);\n\t}\n\n\tsetFullScreen(fullScreen: boolean) {\n\t\tthis.fullScreen.next(fullScreen);\n\t}\n\n\tsetFsActivated(activated: boolean) {\n\t\tthis.fsActivated.next(activated);\n\t}\n\n\tsetHasConnected(connected: boolean) {\n\t\tthis.hasConnected.next(connected);\n\t}\n\n\tsetNavbarModuleData(data: NavbarModel) {\n\t\tdata.tabs = data.tabs.filter(a => a.params === null).sort((a, b) => a.label.localeCompare(b.label)).concat(data.tabs.filter(a => a.params !== null).sort((a, b) => a.label.localeCompare(b.label)));\n\t\tthis.navbarModuleData.next(data);\n\t}\n\n\tsetHasStatusMessage(data: boolean) {\n\t\tthis.hasStatusMessage.next(data);\n\t}\n\n\tsetIsDevice(data: boolean) {\n\t\tthis.isDevice.next(data);\n\t}\n\n\tsetIsInvalidVersion(data: boolean) {\n\t\tthis.isInvalidVersion.next(data);\n\t}\n\n\tsetIsInvalidSW(data: boolean) {\n\t\tthis.isInvalidSW.next(data);\n\t}\n\n\tsetEnvironment(env) {\n\t\tthis.environment.next(env);\n\t}\n\n\tsetClient(client) {\n\t\tthis.client.next(client);\n\t}\n\n\tsetStandardProgram(standardProgram) {\n\t\tthis.standardProgram.next(standardProgram);\n\t}\n\n\tsetNavTabs(navTabs) {\n\t\tthis.navTabs.next(navTabs);\n\t}\n\n\tsetTourStops(tourStops) {\n\t\tthis.tourStops.next(tourStops);\n\t}\n\n\tsetTourStarted(tourStarted) {\n\t\tthis.tourStarted.next(tourStarted);\n\t}\n\n\tsetDemo(isDemo: boolean) {\n\t\tthis.isDemo.next(isDemo);\n\t}\n\n\t// setCustomHomePage(data: boolean) {\n\t// \tthis.customHomePage.next(data);\n\t// }\n\n\t// setLogo(logo) {\n\t// \tthis.logo.next(logo);\n\t// }\n}\n"]}

package/esm2020/lib/directive/focus.mjs

@@ -0,0 +1,22 @@
+import { Directive, Input, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FocusDirective {
+    constructor(element) {
+        this.element = element;
+    }
+    ngOnChanges() {
+        if (this.focus)
+            this.element.nativeElement.focus();
+    }
+}
+FocusDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FocusDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+FocusDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: FocusDirective, selector: "[focus]", inputs: { focus: "focus" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: FocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[focus]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { focus: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlL3NyYy9saWIvZGlyZWN0aXZlL2ZvY3VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFLN0QsTUFBTSxPQUFPLGNBQWM7SUFJMUIsWUFBb0IsT0FBb0I7UUFBcEIsWUFBTyxHQUFQLE9BQU8sQ0FBYTtJQUN4QyxDQUFDO0lBRVMsV0FBVztRQUNwQixJQUFJLElBQUksQ0FBQyxLQUFLO1lBQ2IsSUFBSSxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDckMsQ0FBQzs7MkdBVlcsY0FBYzsrRkFBZCxjQUFjOzJGQUFkLGNBQWM7a0JBSDFCLFNBQVM7bUJBQUM7b0JBQ1YsUUFBUSxFQUFHLFNBQVM7aUJBQ3BCO2lHQUdBLEtBQUs7c0JBREosS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQsIEVsZW1lbnRSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG5cdHNlbGVjdG9yIDogJ1tmb2N1c10nXG59KVxuZXhwb3J0IGNsYXNzIEZvY3VzRGlyZWN0aXZlIHtcblx0QElucHV0KClcblx0Zm9jdXMgOiBib29sZWFuO1xuXG5cdGNvbnN0cnVjdG9yKHByaXZhdGUgZWxlbWVudCA6IEVsZW1lbnRSZWYpIHtcblx0fVxuXG5cdHByb3RlY3RlZCBuZ09uQ2hhbmdlcygpIHtcblx0XHRpZiAodGhpcy5mb2N1cylcblx0XHRcdHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LmZvY3VzKCk7XG5cdH1cbn0iXX0=

package/esm2020/lib/directive/scroll.mjs

@@ -0,0 +1,55 @@
+import { Directive, HostListener, Output, EventEmitter, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ScrollDirective {
+    constructor() {
+        this.onScroll = new EventEmitter();
+        this.bottomOffset = 100;
+        this.topOffset = 100;
+    }
+    // handle host scroll
+    scrolled($event) {
+        this.elementScrollEvent($event);
+    }
+    // handle window scroll
+    windowScrolled($event) {
+        this.windowScrollEvent($event);
+    }
+    windowScrollEvent($event) {
+        const target = $event.target;
+        const scrollTop = window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+        const isReachingTop = scrollTop < this.topOffset;
+        const isReachingBottom = (target.body.offsetHeight - (window.innerHeight + scrollTop)) < this.bottomOffset;
+        const emitValue = { isReachingBottom, isReachingTop, originalEvent: $event, isWindowEvent: true };
+        this.onScroll.emit(emitValue);
+    }
+    elementScrollEvent($event) {
+        const target = $event.target;
+        const scrollPosition = target.scrollHeight - target.scrollTop;
+        const offsetHeight = target.offsetHeight;
+        const isReachingTop = target.scrollTop < this.topOffset;
+        const isReachingBottom = (scrollPosition - offsetHeight) < this.bottomOffset;
+        const emitValue = { isReachingBottom, isReachingTop, originalEvent: $event, isWindowEvent: false };
+        this.onScroll.emit(emitValue);
+    }
+}
+ScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+ScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.1.1", type: ScrollDirective, selector: "[detect-scroll]", inputs: { bottomOffset: "bottomOffset", topOffset: "topOffset" }, outputs: { onScroll: "onScroll" }, host: { listeners: { "scroll": "scrolled($event)", "window:scroll": "windowScrolled($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.1", ngImport: i0, type: ScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[detect-scroll]'
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { onScroll: [{
+                type: Output
+            }], bottomOffset: [{
+                type: Input
+            }], topOffset: [{
+                type: Input
+            }], scrolled: [{
+                type: HostListener,
+                args: ['scroll', ['$event']]
+            }], windowScrolled: [{
+                type: HostListener,
+                args: ['window:scroll', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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