@smartbit4all/ng-client 1.0.0

package/esm2020/lib/session/smart-session.service.mjs

@@ -0,0 +1,204 @@
+import { Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "./api";
+import * as i2 from "./cookie-service/smart-cookie.service";
+export class SmartSessionService {
+    constructor(apiService, cookieService) {
+        this.apiService = apiService;
+        this.cookieService = cookieService;
+        this.isAuthenticated = false;
+        this.authenticationStateChanged = new Subject();
+        this.headerParams = new Array();
+        this.headersUpdated = new Subject();
+        // Locale
+        this.localStorageLocaleName = "locale";
+        this.localeChanged = new Subject();
+        this.sessionExpiracyChanged = new Subject();
+    }
+    get sessionInfoData() {
+        return this._sessionInfoData;
+    }
+    set sessionInfoData(sessionInfoData) {
+        let expiracyChanged = this.sessionInfoData?.expiration !== sessionInfoData?.expiration;
+        this._sessionInfoData = sessionInfoData;
+        if (expiracyChanged) {
+            this.sessionExpiracyChanged.next();
+        }
+    }
+    setSessionHandlerService(smartSessionHandlerService) {
+        this.sessionHandlerService = smartSessionHandlerService;
+    }
+    async handleSessionError(sessionError) {
+        if (this.sessionHandlerService) {
+            await this.sessionHandlerService.handleSessionError(sessionError);
+        }
+        throw new Error(`sessionHandlerService was not initialized. Error: ${sessionError.code}`);
+    }
+    addHeaderParam(headerParam) {
+        this.headerParams.push(headerParam);
+        this.headersUpdated.next();
+    }
+    setUpTokenForSessionService() {
+        if (this.headerParams.find((header) => header.headerName === "Authorization")) {
+            let index = this.headerParams.findIndex((header) => header.headerName === "Authorization");
+            this.headerParams[index].value = `Bearer ${this.token}`;
+        }
+        else {
+            this.addHeaderParam({ headerName: "Authorization", value: `Bearer ${this.token}` });
+        }
+    }
+    setUrl(url) {
+        this.basePath = url;
+    }
+    getBasePath() {
+        if (!this.basePath) {
+            throw new Error("BasePath has not been set in SmartSessionService!");
+        }
+        return this.basePath;
+    }
+    setCookieName(name) {
+        this.cookieName = name;
+    }
+    saveTokenToLocalStorage() {
+        if (this.sessionInfoData && this.cookieName) {
+            localStorage.setItem("token", this.sessionInfoData.sid);
+            if (this.sessionInfoData.refreshToken &&
+                this.sessionInfoData.refreshToken !== localStorage.getItem("refreshToken")) {
+                localStorage.setItem("refreshToken", this.sessionInfoData.refreshToken);
+            }
+            this.cookieService.set(this.cookieName, this.token);
+        }
+    }
+    setAuthenticationStatus() {
+        if (this.sessionInfoData && this.sessionInfoData.authentications) {
+            this.isAuthenticated = this.sessionInfoData.authentications.length > 0;
+        }
+        this.authenticationStateChanged.next(this.isAuthenticated);
+    }
+    checkStatements() {
+        if (!this.basePath) {
+            throw new Error("The url of the backend api has not been set!");
+        }
+        else if (!this.cookieName) {
+            throw new Error("The name of the cookie required by the backend has not been set!");
+        }
+    }
+    async initialize() {
+        this.checkStatements();
+        let tokenFromLocalStorage = localStorage.getItem("token");
+        let tokenFromCookies = this.cookieService.get(this.cookieName);
+        if (tokenFromLocalStorage &&
+            tokenFromCookies &&
+            tokenFromLocalStorage === tokenFromCookies) {
+            this.token = tokenFromLocalStorage;
+            this.setUpTokenForSessionService();
+            try {
+                await this.getSession();
+            }
+            catch (err) {
+                await this.startSession();
+            }
+        }
+        else {
+            await this.clearAndStartNewSession();
+        }
+        if (this.sessionInfoData && this.sessionInfoData.locale) {
+            localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);
+            this.localeChanged.next();
+        }
+    }
+    async startSession() {
+        let sessionInfo = await this.apiService.startSession().toPromise();
+        if (sessionInfo) {
+            this.sessionInfoData = sessionInfo;
+            this.token = sessionInfo.sid;
+            this.saveTokenToLocalStorage();
+            this.setAuthenticationStatus();
+            this.setUpTokenForSessionService();
+        }
+        return this.sessionInfoData;
+    }
+    async getSession() {
+        let sessionInfo = await this.apiService.getSession().toPromise();
+        if (sessionInfo) {
+            this.sessionInfoData = sessionInfo;
+            this.token = sessionInfo.sid;
+            this.saveTokenToLocalStorage();
+            this.setAuthenticationStatus();
+        }
+        return this.sessionInfoData;
+    }
+    async refreshSession() {
+        let refreshToken = localStorage.getItem("refreshToken");
+        if (!refreshToken) {
+            return await this.startSession();
+        }
+        let sessionInfo = await this.apiService
+            .refreshSession({
+            refreshToken,
+        })
+            .toPromise()
+            .catch(async (error) => {
+            if (error.error &&
+                error.error.code &&
+                error.error.code === "session.refreshtoken.invalid") {
+                await this.startSession();
+            }
+        });
+        if (sessionInfo) {
+            this.sessionInfoData = sessionInfo;
+            this.token = sessionInfo.sid;
+            this.saveTokenToLocalStorage();
+            this.setAuthenticationStatus();
+            this.setUpTokenForSessionService();
+        }
+        return this.sessionInfoData;
+    }
+    async getAuthenticationProviders() {
+        let providers = await this.apiService
+            .getAuthenticationProviders()
+            .toPromise();
+        this.providers = providers?.authenticationProviders;
+        return this.providers;
+    }
+    async getIsAuthenticated() {
+        if (this.sessionInfoData) {
+            return this.isAuthenticated;
+        }
+        await this.getSession();
+        return this.isAuthenticated;
+    }
+    async clearAndStartNewSession() {
+        sessionStorage.clear();
+        localStorage.clear();
+        this.headerParams = [];
+        this.cookieService.delete(this.cookieName);
+        await this.startSession();
+    }
+    getLocale() {
+        if (this.sessionInfoData && this.sessionInfoData.locale) {
+            if (localStorage.getItem(this.localStorageLocaleName) !== this.sessionInfoData.locale) {
+                localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);
+            }
+            return this.sessionInfoData.locale;
+        }
+        throw new Error("There is no SessionInfoData or locale is undefined.");
+    }
+    async changeLocale(locale) {
+        this.sessionInfoData = await this.apiService.setLocale(locale).toPromise();
+        if (this.sessionInfoData && this.sessionInfoData.locale) {
+            localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);
+            this.localeChanged.next();
+        }
+    }
+}
+SmartSessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionService, deps: [{ token: i1.SessionService }, { token: i2.SmartCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartSessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SessionService }, { type: i2.SmartCookieService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-session.service.js","sourceRoot":"","sources":["../../../../../projects/smart-ng-client/src/lib/session/smart-session.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpErrorResponse } from \"@angular/common/http\";\nimport { Injectable } from \"@angular/core\";\nimport { Subject } from \"rxjs\";\nimport {\n    ApiError,\n    AuthenticationProviderData,\n    GetAuthenticationProvidersResponse,\n    SessionInfoData,\n    SessionService,\n} from \"./api\";\nimport { SmartCookieService } from \"./cookie-service/smart-cookie.service\";\nimport { SessionError, SmartSessionHandlerService } from \"./smart-session-handler.service\";\n\nexport interface HeaderParam {\n    headerName: string;\n    value: string;\n}\n@Injectable({\n    providedIn: \"root\",\n})\nexport class SmartSessionService {\n    private basePath?: string;\n    private token?: string;\n    private _sessionInfoData?: SessionInfoData;\n\n    public get sessionInfoData(): SessionInfoData | undefined {\n        return this._sessionInfoData;\n    }\n    private set sessionInfoData(sessionInfoData: SessionInfoData | undefined) {\n        let expiracyChanged = this.sessionInfoData?.expiration !== sessionInfoData?.expiration;\n\n        this._sessionInfoData = sessionInfoData;\n\n        if (expiracyChanged) {\n            this.sessionExpiracyChanged.next();\n        }\n    }\n\n    private providers?: Array<AuthenticationProviderData>;\n    private cookieName?: string;\n    public isAuthenticated: boolean = false;\n\n    public authenticationStateChanged: Subject<boolean> = new Subject();\n\n    public headerParams: Array<HeaderParam> = new Array();\n    public headersUpdated: Subject<void> = new Subject();\n\n    // Locale\n    private localStorageLocaleName: string = \"locale\";\n    public localeChanged: Subject<void> = new Subject();\n\n    public sessionExpiracyChanged: Subject<void> = new Subject();\n\n    private sessionHandlerService?: SmartSessionHandlerService;\n\n    constructor(private apiService: SessionService, private cookieService: SmartCookieService) {}\n\n    public setSessionHandlerService(smartSessionHandlerService: SmartSessionHandlerService): void {\n        this.sessionHandlerService = smartSessionHandlerService;\n    }\n\n    public async handleSessionError(sessionError: SessionError): Promise<void> {\n        if (this.sessionHandlerService) {\n            await this.sessionHandlerService.handleSessionError(sessionError);\n        }\n        throw new Error(`sessionHandlerService was not initialized. Error: ${sessionError.code}`);\n    }\n\n    public addHeaderParam(headerParam: HeaderParam): void {\n        this.headerParams.push(headerParam);\n        this.headersUpdated.next();\n    }\n\n    private setUpTokenForSessionService(): void {\n        if (\n            this.headerParams.find((header: HeaderParam) => header.headerName === \"Authorization\")\n        ) {\n            let index = this.headerParams.findIndex(\n                (header: HeaderParam) => header.headerName === \"Authorization\"\n            );\n            this.headerParams[index!].value = `Bearer ${this.token!}`;\n        } else {\n            this.addHeaderParam({ headerName: \"Authorization\", value: `Bearer ${this.token!}` });\n        }\n    }\n\n    public setUrl(url: string): void {\n        this.basePath = url;\n    }\n    public getBasePath(): string {\n        if (!this.basePath) {\n            throw new Error(\"BasePath has not been set in SmartSessionService!\");\n        }\n        return this.basePath;\n    }\n\n    public setCookieName(name: string): void {\n        this.cookieName = name;\n    }\n\n    private saveTokenToLocalStorage(): void {\n        if (this.sessionInfoData && this.cookieName) {\n            localStorage.setItem(\"token\", this.sessionInfoData.sid);\n            if (\n                this.sessionInfoData.refreshToken &&\n                this.sessionInfoData.refreshToken !== localStorage.getItem(\"refreshToken\")\n            ) {\n                localStorage.setItem(\"refreshToken\", this.sessionInfoData.refreshToken);\n            }\n            this.cookieService.set(this.cookieName, this.token!);\n        }\n    }\n\n    private setAuthenticationStatus(): void {\n        if (this.sessionInfoData && this.sessionInfoData.authentications) {\n            this.isAuthenticated = this.sessionInfoData.authentications.length > 0;\n        }\n        this.authenticationStateChanged.next(this.isAuthenticated);\n    }\n\n    private checkStatements(): void {\n        if (!this.basePath) {\n            throw new Error(\"The url of the backend api has not been set!\");\n        } else if (!this.cookieName) {\n            throw new Error(\"The name of the cookie required by the backend has not been set!\");\n        }\n    }\n\n    public async initialize(): Promise<void> {\n        this.checkStatements();\n\n        let tokenFromLocalStorage = localStorage.getItem(\"token\");\n        let tokenFromCookies = this.cookieService.get(this.cookieName!);\n\n        if (\n            tokenFromLocalStorage &&\n            tokenFromCookies &&\n            tokenFromLocalStorage === tokenFromCookies\n        ) {\n            this.token = tokenFromLocalStorage;\n            this.setUpTokenForSessionService();\n            try {\n                await this.getSession();\n            } catch (err) {\n                await this.startSession();\n            }\n        } else {\n            await this.clearAndStartNewSession();\n        }\n        if (this.sessionInfoData && this.sessionInfoData.locale) {\n            localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);\n            this.localeChanged.next();\n        }\n    }\n\n    private async startSession(): Promise<SessionInfoData> {\n        let sessionInfo = await this.apiService.startSession().toPromise();\n        if (sessionInfo) {\n            this.sessionInfoData = sessionInfo;\n            this.token = sessionInfo.sid;\n            this.saveTokenToLocalStorage();\n            this.setAuthenticationStatus();\n            this.setUpTokenForSessionService();\n        }\n\n        return this.sessionInfoData!;\n    }\n\n    public async getSession(): Promise<SessionInfoData> {\n        let sessionInfo = await this.apiService.getSession().toPromise();\n        if (sessionInfo) {\n            this.sessionInfoData = sessionInfo;\n            this.token = sessionInfo.sid;\n            this.saveTokenToLocalStorage();\n            this.setAuthenticationStatus();\n        }\n\n        return this.sessionInfoData!;\n    }\n\n    public async refreshSession(): Promise<SessionInfoData> {\n        let refreshToken = localStorage.getItem(\"refreshToken\");\n        if (!refreshToken) {\n            return await this.startSession();\n        }\n\n        let sessionInfo = await this.apiService\n            .refreshSession({\n                refreshToken,\n            })\n            .toPromise()\n            .catch(async (error: HttpErrorResponse) => {\n                if (\n                    error.error &&\n                    (error.error as ApiError).code &&\n                    (error.error as ApiError).code === \"session.refreshtoken.invalid\"\n                ) {\n                    await this.startSession();\n                }\n            });\n\n        if (sessionInfo) {\n            this.sessionInfoData = sessionInfo;\n            this.token = sessionInfo.sid;\n            this.saveTokenToLocalStorage();\n            this.setAuthenticationStatus();\n            this.setUpTokenForSessionService();\n        }\n\n        return this.sessionInfoData!;\n    }\n\n    public async getAuthenticationProviders(): Promise<Array<AuthenticationProviderData>> {\n        let providers: GetAuthenticationProvidersResponse | undefined = await this.apiService\n            .getAuthenticationProviders()\n            .toPromise();\n\n        this.providers = providers?.authenticationProviders;\n\n        return this.providers!;\n    }\n\n    public async getIsAuthenticated(): Promise<boolean> {\n        if (this.sessionInfoData) {\n            return this.isAuthenticated;\n        }\n        await this.getSession();\n        return this.isAuthenticated;\n    }\n\n    public async clearAndStartNewSession(): Promise<void> {\n        sessionStorage.clear();\n        localStorage.clear();\n        this.headerParams = [];\n        this.cookieService.delete(this.cookieName!);\n\n        await this.startSession();\n    }\n\n    public getLocale(): string {\n        if (this.sessionInfoData && this.sessionInfoData.locale) {\n            if (localStorage.getItem(this.localStorageLocaleName) !== this.sessionInfoData.locale) {\n                localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);\n            }\n            return this.sessionInfoData.locale;\n        }\n        throw new Error(\"There is no SessionInfoData or locale is undefined.\");\n    }\n\n    public async changeLocale(locale: string): Promise<void> {\n        this.sessionInfoData = await this.apiService.setLocale(locale).toPromise();\n        if (this.sessionInfoData && this.sessionInfoData.locale) {\n            localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);\n            this.localeChanged.next();\n        }\n    }\n}\n"]}

package/esm2020/lib/session/smart-timer/smart-session-timer.component.mjs

@@ -0,0 +1,35 @@
+import { Component } from "@angular/core";
+import { Subject, takeUntil } from "rxjs";
+import { SmartSessionTimerService } from "./smart-session-timer.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./smart-session-timer.service";
+import * as i2 from "@angular/common";
+export class SmartSessionTimerComponent {
+    constructor(service) {
+        this.service = service;
+        this._destroy$ = new Subject();
+    }
+    ngOnInit() {
+        this.service.startTimer();
+        this.timeInSeconds = this.service.timeLeftInSeconds;
+        this.service.timeChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this.timeInSeconds = this.service.timeLeftInSeconds;
+        });
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    formatTime(seconds) {
+        let minutes = Math.floor(seconds / 60);
+        let remainingSeconds = seconds % 60;
+        return `${minutes}:${remainingSeconds < 10 ? "0" : ""}${remainingSeconds}`;
+    }
+}
+SmartSessionTimerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionTimerComponent, deps: [{ token: i1.SmartSessionTimerService }], target: i0.ɵɵFactoryTarget.Component });
+SmartSessionTimerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: SmartSessionTimerComponent, selector: "smart-session-timer", providers: [SmartSessionTimerService], ngImport: i0, template: "<div class=\"smart-session-timer-container\">\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\n        {{ formatTime(timeInSeconds!) }}\n    </span>\n</div>\n", styles: [""], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionTimerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "smart-session-timer", providers: [SmartSessionTimerService], template: "<div class=\"smart-session-timer-container\">\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\n        {{ formatTime(timeInSeconds!) }}\n    </span>\n</div>\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: i1.SmartSessionTimerService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/session/smart-timer/smart-session-timer.service.mjs

@@ -0,0 +1,51 @@
+import { Injectable } from "@angular/core";
+import { Subject, takeUntil } from "rxjs";
+import * as i0 from "@angular/core";
+import * as i1 from "../smart-session.service";
+export class SmartSessionTimerService {
+    constructor(session) {
+        this.session = session;
+        this._destroy$ = new Subject();
+        this.totalTimeInMinutes = 30;
+        this.sessionExpiration = "sessionExpiracy";
+        this.timeChanged = new Subject();
+        this.onTimerExpired = new Subject();
+        this.session.sessionExpiracyChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this.restart();
+        });
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    startTimer() {
+        let sessionInfoData = this.session.sessionInfoData;
+        let expiration = new Date(sessionInfoData.expiration);
+        let now = new Date();
+        this.timeLeftInSeconds = Math.floor((expiration.getTime() - now.getTime()) / 1000);
+        this.timer = setInterval(() => {
+            this.timeLeftInSeconds--;
+            if (this.timeLeftInSeconds === 0) {
+                this.timeout();
+            }
+            this.timeChanged.next();
+        }, 1000);
+    }
+    restart() {
+        clearInterval(this.timer);
+        this.startTimer();
+    }
+    timeout() {
+        clearInterval(this.timer);
+        this.onTimerExpired.next();
+    }
+}
+SmartSessionTimerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionTimerService, deps: [{ token: i1.SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartSessionTimerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionTimerService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionTimerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SmartSessionService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/smart-ng-client.module.mjs

@@ -0,0 +1,20 @@
+import { NgModule } from "@angular/core";
+import { SmartNgClientService } from "./smart-ng-client.service";
+import { SmartSessionModule } from "./session/smart-session.module";
+import { SmartViewContextModule } from "./view-context/smart-view-context.module";
+import * as i0 from "@angular/core";
+export class SmartNgClientModule {
+}
+SmartNgClientModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SmartNgClientModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientModule, imports: [SmartSessionModule, SmartViewContextModule], exports: [SmartSessionModule, SmartViewContextModule] });
+SmartNgClientModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientModule, providers: [SmartNgClientService], imports: [[SmartSessionModule, SmartViewContextModule], SmartSessionModule, SmartViewContextModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [SmartSessionModule, SmartViewContextModule],
+                    exports: [SmartSessionModule, SmartViewContextModule],
+                    providers: [SmartNgClientService],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnQtbmctY2xpZW50Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3NtYXJ0LW5nLWNsaWVudC9zcmMvbGliL3NtYXJ0LW5nLWNsaWVudC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUNqRSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUNwRSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQzs7QUFRbEYsTUFBTSxPQUFPLG1CQUFtQjs7aUhBQW5CLG1CQUFtQjtrSEFBbkIsbUJBQW1CLFlBSmxCLGtCQUFrQixFQUFFLHNCQUFzQixhQUMxQyxrQkFBa0IsRUFBRSxzQkFBc0I7a0hBRzNDLG1CQUFtQixhQUZqQixDQUFDLG9CQUFvQixDQUFDLFlBRnhCLENBQUMsa0JBQWtCLEVBQUUsc0JBQXNCLENBQUMsRUFDM0Msa0JBQWtCLEVBQUUsc0JBQXNCOzRGQUczQyxtQkFBbUI7a0JBTi9CLFFBQVE7bUJBQUM7b0JBQ04sWUFBWSxFQUFFLEVBQUU7b0JBQ2hCLE9BQU8sRUFBRSxDQUFDLGtCQUFrQixFQUFFLHNCQUFzQixDQUFDO29CQUNyRCxPQUFPLEVBQUUsQ0FBQyxrQkFBa0IsRUFBRSxzQkFBc0IsQ0FBQztvQkFDckQsU0FBUyxFQUFFLENBQUMsb0JBQW9CLENBQUM7aUJBQ3BDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgU21hcnROZ0NsaWVudFNlcnZpY2UgfSBmcm9tIFwiLi9zbWFydC1uZy1jbGllbnQuc2VydmljZVwiO1xuaW1wb3J0IHsgU21hcnRTZXNzaW9uTW9kdWxlIH0gZnJvbSBcIi4vc2Vzc2lvbi9zbWFydC1zZXNzaW9uLm1vZHVsZVwiO1xuaW1wb3J0IHsgU21hcnRWaWV3Q29udGV4dE1vZHVsZSB9IGZyb20gXCIuL3ZpZXctY29udGV4dC9zbWFydC12aWV3LWNvbnRleHQubW9kdWxlXCI7XG5cbkBOZ01vZHVsZSh7XG4gICAgZGVjbGFyYXRpb25zOiBbXSxcbiAgICBpbXBvcnRzOiBbU21hcnRTZXNzaW9uTW9kdWxlLCBTbWFydFZpZXdDb250ZXh0TW9kdWxlXSxcbiAgICBleHBvcnRzOiBbU21hcnRTZXNzaW9uTW9kdWxlLCBTbWFydFZpZXdDb250ZXh0TW9kdWxlXSxcbiAgICBwcm92aWRlcnM6IFtTbWFydE5nQ2xpZW50U2VydmljZV0sXG59KVxuZXhwb3J0IGNsYXNzIFNtYXJ0TmdDbGllbnRNb2R1bGUge31cbiJdfQ==

package/esm2020/lib/smart-ng-client.service.mjs

@@ -0,0 +1,19 @@
+import { Injectable } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "./session/smart-session.service";
+import * as i2 from "./view-context/smart-view-context.service";
+export class SmartNgClientService {
+    constructor(session, viewContext) {
+        this.session = session;
+        this.viewContext = viewContext;
+    }
+}
+SmartNgClientService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientService, deps: [{ token: i1.SmartSessionService }, { token: i2.SmartViewContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartNgClientService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SmartSessionService }, { type: i2.SmartViewContextService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnQtbmctY2xpZW50LnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zbWFydC1uZy1jbGllbnQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7O0FBTzNDLE1BQU0sT0FBTyxvQkFBb0I7SUFDN0IsWUFDWSxPQUE0QixFQUM1QixXQUFvQztRQURwQyxZQUFPLEdBQVAsT0FBTyxDQUFxQjtRQUM1QixnQkFBVyxHQUFYLFdBQVcsQ0FBeUI7SUFDN0MsQ0FBQzs7a0hBSkssb0JBQW9CO3NIQUFwQixvQkFBb0IsY0FGakIsTUFBTTs0RkFFVCxvQkFBb0I7a0JBSGhDLFVBQVU7bUJBQUM7b0JBQ1IsVUFBVSxFQUFFLE1BQU07aUJBQ3JCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBTbWFydFNlc3Npb25TZXJ2aWNlIH0gZnJvbSBcIi4vc2Vzc2lvbi9zbWFydC1zZXNzaW9uLnNlcnZpY2VcIjtcbmltcG9ydCB7IFNtYXJ0Vmlld0NvbnRleHRTZXJ2aWNlIH0gZnJvbSBcIi4vdmlldy1jb250ZXh0L3NtYXJ0LXZpZXctY29udGV4dC5zZXJ2aWNlXCI7XG5cbkBJbmplY3RhYmxlKHtcbiAgICBwcm92aWRlZEluOiBcInJvb3RcIixcbn0pXG5leHBvcnQgY2xhc3MgU21hcnROZ0NsaWVudFNlcnZpY2Uge1xuICAgIGNvbnN0cnVjdG9yKFxuICAgICAgICBwcml2YXRlIHNlc3Npb246IFNtYXJ0U2Vzc2lvblNlcnZpY2UsXG4gICAgICAgIHByaXZhdGUgdmlld0NvbnRleHQ6IFNtYXJ0Vmlld0NvbnRleHRTZXJ2aWNlXG4gICAgKSB7fVxufVxuIl19

package/esm2020/lib/view-context/api/api/api.mjs

@@ -0,0 +1,4 @@
+export * from './view.service';
+import { ViewService } from './view.service';
+export const APIS = [ViewService];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc21hcnQtbmctY2xpZW50L3NyYy9saWIvdmlldy1jb250ZXh0L2FwaS9hcGkvYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdDLE1BQU0sQ0FBQyxNQUFNLElBQUksR0FBRyxDQUFDLFdBQVcsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi92aWV3LnNlcnZpY2UnO1xuaW1wb3J0IHsgVmlld1NlcnZpY2UgfSBmcm9tICcuL3ZpZXcuc2VydmljZSc7XG5leHBvcnQgY29uc3QgQVBJUyA9IFtWaWV3U2VydmljZV07XG4iXX0=