@alfresco/aca-shared 5.1.1 → 6.0.0-11114941325

package/esm2022/lib/services/app.service.mjs

@@ -0,0 +1,239 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { inject, Injectable } from '@angular/core';
+import { AuthenticationService, AppConfigService, PageTitleService, UserPreferencesService, NotificationService } from '@alfresco/adf-core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { AlfrescoApiService, SearchQueryBuilderService, SharedLinksApiService, UploadService } from '@alfresco/adf-content-services';
+import { OverlayContainer } from '@angular/cdk/overlay';
+import { ActivatedRoute, ActivationEnd, NavigationStart, Router } from '@angular/router';
+import { filter, map } from 'rxjs/operators';
+import { SetCurrentUrlAction, SetRepositoryInfoAction, SetUserProfileAction, ResetSelectionAction } from '@alfresco/aca-shared/store';
+import { ContentApiService } from './content-api.service';
+import { RouterExtensionService } from './router.extension.service';
+import { Store } from '@ngrx/store';
+import { AcaMobileAppSwitcherService } from './aca-mobile-app-switcher.service';
+import { AppSettingsService } from './app-settings.service';
+import { UserProfileService } from './user-profile.service';
+import { MatDialog } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+import * as i2 from "@ngrx/store";
+import * as i3 from "@angular/router";
+import * as i4 from "@alfresco/adf-content-services";
+import * as i5 from "./router.extension.service";
+import * as i6 from "./content-api.service";
+import * as i7 from "@angular/cdk/overlay";
+import * as i8 from "./aca-mobile-app-switcher.service";
+import * as i9 from "./app-settings.service";
+import * as i10 from "./user-profile.service";
+class AppService {
+    preferencesService;
+    authenticationService;
+    store;
+    router;
+    activatedRoute;
+    config;
+    pageTitle;
+    alfrescoApiService;
+    uploadService;
+    routerExtensionService;
+    contentApi;
+    sharedLinksApiService;
+    overlayContainer;
+    acaMobileAppSwitcherService;
+    appSettingsService;
+    userProfileService;
+    notificationService = inject(NotificationService);
+    matDialog = inject(MatDialog);
+    ready;
+    ready$;
+    pageHeading = new BehaviorSubject('');
+    /** @deprecated page title is updated automatically */
+    pageHeading$ = this.pageHeading.asObservable();
+    appNavNarMode$ = new BehaviorSubject('expanded');
+    toggleAppNavBar$ = new Subject();
+    hideSidenavConditions = ['/preview/'];
+    minimizeSidenavConditions = ['search'];
+    onDestroy$ = new Subject();
+    /**
+     * Whether `withCredentials` mode is enabled.
+     * Usually means that `Kerberos` mode is used.
+     */
+    get withCredentials() {
+        return this.config.get('auth.withCredentials', false);
+    }
+    constructor(preferencesService, authenticationService, store, router, activatedRoute, config, pageTitle, alfrescoApiService, uploadService, routerExtensionService, contentApi, sharedLinksApiService, overlayContainer, searchQueryBuilderService, acaMobileAppSwitcherService, appSettingsService, userProfileService) {
+        this.preferencesService = preferencesService;
+        this.authenticationService = authenticationService;
+        this.store = store;
+        this.router = router;
+        this.activatedRoute = activatedRoute;
+        this.config = config;
+        this.pageTitle = pageTitle;
+        this.alfrescoApiService = alfrescoApiService;
+        this.uploadService = uploadService;
+        this.routerExtensionService = routerExtensionService;
+        this.contentApi = contentApi;
+        this.sharedLinksApiService = sharedLinksApiService;
+        this.overlayContainer = overlayContainer;
+        this.acaMobileAppSwitcherService = acaMobileAppSwitcherService;
+        this.appSettingsService = appSettingsService;
+        this.userProfileService = userProfileService;
+        this.ready = new BehaviorSubject(this.authenticationService.isLoggedIn() || this.withCredentials);
+        this.ready$ = this.ready.asObservable();
+        this.authenticationService.onLogin.subscribe(() => {
+            this.ready.next(true);
+            this.preferencesService.setStoragePrefix(this.authenticationService.getUsername());
+        });
+        this.authenticationService.onLogout.subscribe(() => {
+            searchQueryBuilderService.resetToDefaults();
+            acaMobileAppSwitcherService.clearSessionExpireTime();
+            acaMobileAppSwitcherService.closeDialog();
+        });
+        this.router.events
+            .pipe(filter((event) => event instanceof ActivationEnd && event.snapshot.children.length === 0), map((event) => event.snapshot?.data?.title ?? ''))
+            .subscribe((title) => {
+            this.pageHeading.next(title);
+            this.pageTitle.setTitle(title);
+        });
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    init() {
+        this.alfrescoApiService.getInstance().on('error', (error) => {
+            if (error.status === 401 && !this.alfrescoApiService.isExcludedErrorListener(error?.response?.req?.url)) {
+                if (!this.authenticationService.isLoggedIn()) {
+                    this.matDialog.closeAll();
+                    let redirectUrl = this.activatedRoute.snapshot.queryParams['redirectUrl'];
+                    if (!redirectUrl) {
+                        redirectUrl = this.router.url;
+                    }
+                    this.router.navigate(['/login'], {
+                        queryParams: { redirectUrl }
+                    });
+                }
+            }
+        });
+        this.loadCustomCss();
+        this.loadCustomWebFont();
+        const { router } = this;
+        this.router.events.pipe(filter((event) => event instanceof ActivationEnd && event.snapshot.children.length === 0)).subscribe(() => {
+            this.store.dispatch(new SetCurrentUrlAction(router.url));
+        });
+        this.router.events.pipe(filter((event) => event instanceof NavigationStart)).subscribe(() => {
+            this.store.dispatch(new ResetSelectionAction());
+        });
+        this.routerExtensionService.mapExtensionRoutes();
+        this.uploadService.fileUploadError.subscribe((error) => this.onFileUploadedError(error));
+        this.sharedLinksApiService.error.subscribe((err) => {
+            if (err?.message) {
+                this.notificationService.showError(err.message);
+            }
+        });
+        this.ready$.subscribe((isReady) => {
+            if (isReady) {
+                this.loadRepositoryStatus();
+                this.loadUserProfile();
+                setTimeout(() => {
+                    this.openMobileAppDialog();
+                });
+            }
+        });
+        this.overlayContainer.getContainerElement().setAttribute('role', 'region');
+    }
+    setAppNavbarMode(mode) {
+        this.appNavNarMode$.next(mode);
+        this.preferencesService.set('expandedSidenav', mode === 'expanded');
+    }
+    loadRepositoryStatus() {
+        this.contentApi.getRepositoryInformation().subscribe((response) => {
+            if (response?.entry?.repository) {
+                this.store.dispatch(new SetRepositoryInfoAction(response.entry.repository));
+            }
+        });
+    }
+    async loadUserProfile() {
+        const profile = await this.userProfileService.loadUserProfile();
+        this.store.dispatch(new SetUserProfileAction(profile));
+    }
+    onFileUploadedError(error) {
+        let message = 'APP.MESSAGES.UPLOAD.ERROR.GENERIC';
+        if (error?.error?.status === 403) {
+            message = 'APP.MESSAGES.UPLOAD.ERROR.403';
+        }
+        if (error?.error?.status === 404) {
+            message = 'APP.MESSAGES.UPLOAD.ERROR.404';
+        }
+        if (error?.error?.status === 409) {
+            message = 'APP.MESSAGES.UPLOAD.ERROR.CONFLICT';
+        }
+        if (error?.error?.status === 500) {
+            message = 'APP.MESSAGES.UPLOAD.ERROR.500';
+        }
+        if (error?.error?.status === 504) {
+            message = 'APP.MESSAGES.UPLOAD.ERROR.504';
+        }
+        this.notificationService.showError(message);
+    }
+    loadCustomCss() {
+        const customCssPath = this.appSettingsService.customCssPath;
+        if (customCssPath) {
+            this.createLink(customCssPath);
+        }
+    }
+    loadCustomWebFont() {
+        const webFontPath = this.appSettingsService.webFontPath;
+        if (webFontPath) {
+            this.createLink(webFontPath);
+        }
+    }
+    createLink(url) {
+        const cssLinkElement = document.createElement('link');
+        cssLinkElement.setAttribute('rel', 'stylesheet');
+        cssLinkElement.setAttribute('type', 'text/css');
+        cssLinkElement.setAttribute('href', url);
+        document.head.appendChild(cssLinkElement);
+    }
+    openMobileAppDialog() {
+        const isMobileSwitchEnabled = this.config.get('mobileAppSwitch.enabled', false);
+        if (isMobileSwitchEnabled) {
+            this.acaMobileAppSwitcherService.resolveExistenceOfDialog();
+        }
+        else {
+            this.acaMobileAppSwitcherService.clearSessionExpireTime();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppService, deps: [{ token: i1.UserPreferencesService }, { token: i1.AuthenticationService }, { token: i2.Store }, { token: i3.Router }, { token: i3.ActivatedRoute }, { token: i1.AppConfigService }, { token: i1.PageTitleService }, { token: i4.AlfrescoApiService }, { token: i4.UploadService }, { token: i5.RouterExtensionService }, { token: i6.ContentApiService }, { token: i4.SharedLinksApiService }, { token: i7.OverlayContainer }, { token: i4.SearchQueryBuilderService }, { token: i8.AcaMobileAppSwitcherService }, { token: i9.AppSettingsService }, { token: i10.UserProfileService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppService, providedIn: 'root' });
+}
+export { AppService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AppService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.UserPreferencesService }, { type: i1.AuthenticationService }, { type: i2.Store }, { type: i3.Router }, { type: i3.ActivatedRoute }, { type: i1.AppConfigService }, { type: i1.PageTitleService }, { type: i4.AlfrescoApiService }, { type: i4.UploadService }, { type: i5.RouterExtensionService }, { type: i6.ContentApiService }, { type: i4.SharedLinksApiService }, { type: i7.OverlayContainer }, { type: i4.SearchQueryBuilderService }, { type: i8.AcaMobileAppSwitcherService }, { type: i9.AppSettingsService }, { type: i10.UserProfileService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.service.js","sourceRoot":"","sources":["../../../../../../projects/aca-shared/src/lib/services/app.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAa,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC5I,OAAO,EAAc,eAAe,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC5D,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,qBAAqB,EACrB,aAAa,EAEd,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzF,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAY,mBAAmB,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAChJ,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC,OAAO,EAAE,2BAA2B,EAAE,MAAM,mCAAmC,CAAC;AAEhF,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;;;;;;;;;;;;AAErD,MAIa,UAAU;IA4BZ;IACC;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IAEA;IACA;IACA;IA3CF,mBAAmB,GAAG,MAAM,CAAC,mBAAmB,CAAC,CAAC;IAClD,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAC9B,KAAK,CAA2B;IAExC,MAAM,CAAsB;IAEpB,WAAW,GAAG,IAAI,eAAe,CAAC,EAAE,CAAC,CAAC;IAC9C,sDAAsD;IACtD,YAAY,GAAG,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,CAAC;IAE/C,cAAc,GAAsC,IAAI,eAAe,CAAC,UAAU,CAAC,CAAC;IACpF,gBAAgB,GAAG,IAAI,OAAO,EAAQ,CAAC;IAEvC,qBAAqB,GAAG,CAAC,WAAW,CAAC,CAAC;IACtC,yBAAyB,GAAG,CAAC,QAAQ,CAAC,CAAC;IAEvC,UAAU,GAAG,IAAI,OAAO,EAAW,CAAC;IAEpC;;;OAGG;IACH,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAU,sBAAsB,EAAE,KAAK,CAAC,CAAC;IACjE,CAAC;IAED,YACS,kBAA0C,EACzC,qBAA4C,EAC5C,KAAsB,EACtB,MAAc,EACd,cAA8B,EAC9B,MAAwB,EACxB,SAA2B,EAC3B,kBAAsC,EACtC,aAA4B,EAC5B,sBAA8C,EAC9C,UAA6B,EAC7B,qBAA4C,EAC5C,gBAAkC,EAC1C,yBAAoD,EAC5C,2BAAwD,EACxD,kBAAsC,EACtC,kBAAsC;QAhBvC,uBAAkB,GAAlB,kBAAkB,CAAwB;QACzC,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,UAAK,GAAL,KAAK,CAAiB;QACtB,WAAM,GAAN,MAAM,CAAQ;QACd,mBAAc,GAAd,cAAc,CAAgB;QAC9B,WAAM,GAAN,MAAM,CAAkB;QACxB,cAAS,GAAT,SAAS,CAAkB;QAC3B,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,kBAAa,GAAb,aAAa,CAAe;QAC5B,2BAAsB,GAAtB,sBAAsB,CAAwB;QAC9C,eAAU,GAAV,UAAU,CAAmB;QAC7B,0BAAqB,GAArB,qBAAqB,CAAuB;QAC5C,qBAAgB,GAAhB,gBAAgB,CAAkB;QAElC,gCAA2B,GAA3B,2BAA2B,CAA6B;QACxD,uBAAkB,GAAlB,kBAAkB,CAAoB;QACtC,uBAAkB,GAAlB,kBAAkB,CAAoB;QAE9C,IAAI,CAAC,KAAK,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,IAAI,IAAI,CAAC,eAAe,CAAC,CAAC;QAClG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;QAExC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE;YAChD,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,IAAI,CAAC,qBAAqB,CAAC,WAAW,EAAE,CAAC,CAAC;QACrF,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,EAAE;YACjD,yBAAyB,CAAC,eAAe,EAAE,CAAC;YAC5C,2BAA2B,CAAC,sBAAsB,EAAE,CAAC;YACrD,2BAA2B,CAAC,WAAW,EAAE,CAAC;QAC5C,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,MAAM;aACf,IAAI,CACH,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,YAAY,aAAa,IAAI,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,EACzF,GAAG,CAAC,CAAC,KAAoB,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC,CACjE;aACA,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC7B,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,CAAC;IACP,CAAC;IAED,WAAW;QACT,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC3B,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAED,IAAI;QACF,IAAI,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAwC,EAAE,EAAE;YAC7F,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,uBAAuB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE;gBACvG,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,EAAE;oBAC5C,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;oBAE1B,IAAI,WAAW,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC;oBAC1E,IAAI,CAAC,WAAW,EAAE;wBAChB,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;qBAC/B;oBAED,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,EAAE;wBAC/B,WAAW,EAAE,EAAE,WAAW,EAAE;qBAC7B,CAAC,CAAC;iBACJ;aACF;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAEzB,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;QAExB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,YAAY,aAAa,IAAI,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAChI,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,mBAAmB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;QAC3D,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,YAAY,eAAe,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE;YAC1F,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,oBAAoB,EAAE,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,sBAAsB,CAAC,kBAAkB,EAAE,CAAC;QAEjD,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC;QAEzF,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,GAAwB,EAAE,EAAE;YACtE,IAAI,GAAG,EAAE,OAAO,EAAE;gBAChB,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;aACjD;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;YAChC,IAAI,OAAO,EAAE;gBACX,IAAI,CAAC,oBAAoB,EAAE,CAAC;gBAC5B,IAAI,CAAC,eAAe,EAAE,CAAC;gBACvB,UAAU,CAAC,GAAG,EAAE;oBACd,IAAI,CAAC,mBAAmB,EAAE,CAAC;gBAC7B,CAAC,CAAC,CAAC;aACJ;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,gBAAgB,CAAC,mBAAmB,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAC7E,CAAC;IAED,gBAAgB,CAAC,IAA8B;QAC7C,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,iBAAiB,EAAE,IAAI,KAAK,UAAU,CAAC,CAAC;IACtE,CAAC;IAEO,oBAAoB;QAC1B,IAAI,CAAC,UAAU,CAAC,wBAAwB,EAAE,CAAC,SAAS,CAAC,CAAC,QAAwB,EAAE,EAAE;YAChF,IAAI,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE;gBAC/B,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,uBAAuB,CAAC,QAAQ,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC;aAC7E;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,eAAe;QAC3B,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,kBAAkB,CAAC,eAAe,EAAE,CAAC;QAChE,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAAC;IACzD,CAAC;IAED,mBAAmB,CAAC,KAA2B;QAC7C,IAAI,OAAO,GAAG,mCAAmC,CAAC;QAElD,IAAI,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,EAAE;YAChC,OAAO,GAAG,+BAA+B,CAAC;SAC3C;QAED,IAAI,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,EAAE;YAChC,OAAO,GAAG,+BAA+B,CAAC;SAC3C;QAED,IAAI,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,EAAE;YAChC,OAAO,GAAG,oCAAoC,CAAC;SAChD;QAED,IAAI,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,EAAE;YAChC,OAAO,GAAG,+BAA+B,CAAC;SAC3C;QAED,IAAI,KAAK,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,EAAE;YAChC,OAAO,GAAG,+BAA+B,CAAC;SAC3C;QAED,IAAI,CAAC,mBAAmB,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;IAEO,aAAa;QACnB,MAAM,aAAa,GAAG,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC;QAC5D,IAAI,aAAa,EAAE;YACjB,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;SAChC;IACH,CAAC;IAEO,iBAAiB;QACvB,MAAM,WAAW,GAAG,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC;QACxD,IAAI,WAAW,EAAE;YACf,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;SAC9B;IACH,CAAC;IAEO,UAAU,CAAC,GAAW;QAC5B,MAAM,cAAc,GAAG,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QACtD,cAAc,CAAC,YAAY,CAAC,KAAK,EAAE,YAAY,CAAC,CAAC;QACjD,cAAc,CAAC,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAChD,cAAc,CAAC,YAAY,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QACzC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;IAC5C,CAAC;IAEM,mBAAmB;QACxB,MAAM,qBAAqB,GAAY,IAAI,CAAC,MAAM,CAAC,GAAG,CAAU,yBAAyB,EAAE,KAAK,CAAC,CAAC;QAClG,IAAI,qBAAqB,EAAE;YACzB,IAAI,CAAC,2BAA2B,CAAC,wBAAwB,EAAE,CAAC;SAC7D;aAAM;YACL,IAAI,CAAC,2BAA2B,CAAC,sBAAsB,EAAE,CAAC;SAC3D;IACH,CAAC;uGA3MU,UAAU;2GAAV,UAAU,cAHT,MAAM;;SAGP,UAAU;2FAAV,UAAU;kBAJtB,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["/*!\n * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Alfresco Example Content Application\n *\n * This file is part of the Alfresco Example Content Application.\n * If the software was purchased under a paid Alfresco license, the terms of\n * the paid license agreement will prevail. Otherwise, the software is\n * provided under the following open source license terms:\n *\n * The Alfresco Example Content Application is free software: you can redistribute it and/or modify\n * it under the terms of the GNU Lesser General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * The Alfresco Example Content Application is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public License\n * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.\n */\n\nimport { inject, Injectable, OnDestroy } from '@angular/core';\nimport { AuthenticationService, AppConfigService, PageTitleService, UserPreferencesService, NotificationService } from '@alfresco/adf-core';\nimport { Observable, BehaviorSubject, Subject } from 'rxjs';\nimport {\n  AlfrescoApiService,\n  SearchQueryBuilderService,\n  SharedLinksApiService,\n  UploadService,\n  FileUploadErrorEvent\n} from '@alfresco/adf-content-services';\nimport { OverlayContainer } from '@angular/cdk/overlay';\nimport { ActivatedRoute, ActivationEnd, NavigationStart, Router } from '@angular/router';\nimport { filter, map } from 'rxjs/operators';\nimport { AppStore, SetCurrentUrlAction, SetRepositoryInfoAction, SetUserProfileAction, ResetSelectionAction } from '@alfresco/aca-shared/store';\nimport { ContentApiService } from './content-api.service';\nimport { RouterExtensionService } from './router.extension.service';\nimport { Store } from '@ngrx/store';\nimport { DiscoveryEntry } from '@alfresco/js-api';\nimport { AcaMobileAppSwitcherService } from './aca-mobile-app-switcher.service';\nimport { ShellAppService } from '@alfresco/adf-core/shell';\nimport { AppSettingsService } from './app-settings.service';\nimport { UserProfileService } from './user-profile.service';\nimport { MatDialog } from '@angular/material/dialog';\n\n@Injectable({\n  providedIn: 'root'\n})\n// After moving shell to ADF to core, AppService will implement ShellAppService\nexport class AppService implements ShellAppService, OnDestroy {\n  private notificationService = inject(NotificationService);\n  private matDialog = inject(MatDialog);\n  private ready: BehaviorSubject<boolean>;\n\n  ready$: Observable<boolean>;\n\n  private pageHeading = new BehaviorSubject('');\n  /** @deprecated page title is updated automatically */\n  pageHeading$ = this.pageHeading.asObservable();\n\n  appNavNarMode$: Subject<'collapsed' | 'expanded'> = new BehaviorSubject('expanded');\n  toggleAppNavBar$ = new Subject<void>();\n\n  hideSidenavConditions = ['/preview/'];\n  minimizeSidenavConditions = ['search'];\n\n  onDestroy$ = new Subject<boolean>();\n\n  /**\n   * Whether `withCredentials` mode is enabled.\n   * Usually means that `Kerberos` mode is used.\n   */\n  get withCredentials(): boolean {\n    return this.config.get<boolean>('auth.withCredentials', false);\n  }\n\n  constructor(\n    public preferencesService: UserPreferencesService,\n    private authenticationService: AuthenticationService,\n    private store: Store<AppStore>,\n    private router: Router,\n    private activatedRoute: ActivatedRoute,\n    private config: AppConfigService,\n    private pageTitle: PageTitleService,\n    private alfrescoApiService: AlfrescoApiService,\n    private uploadService: UploadService,\n    private routerExtensionService: RouterExtensionService,\n    private contentApi: ContentApiService,\n    private sharedLinksApiService: SharedLinksApiService,\n    private overlayContainer: OverlayContainer,\n    searchQueryBuilderService: SearchQueryBuilderService,\n    private acaMobileAppSwitcherService: AcaMobileAppSwitcherService,\n    private appSettingsService: AppSettingsService,\n    private userProfileService: UserProfileService\n  ) {\n    this.ready = new BehaviorSubject(this.authenticationService.isLoggedIn() || this.withCredentials);\n    this.ready$ = this.ready.asObservable();\n\n    this.authenticationService.onLogin.subscribe(() => {\n      this.ready.next(true);\n      this.preferencesService.setStoragePrefix(this.authenticationService.getUsername());\n    });\n\n    this.authenticationService.onLogout.subscribe(() => {\n      searchQueryBuilderService.resetToDefaults();\n      acaMobileAppSwitcherService.clearSessionExpireTime();\n      acaMobileAppSwitcherService.closeDialog();\n    });\n\n    this.router.events\n      .pipe(\n        filter((event) => event instanceof ActivationEnd && event.snapshot.children.length === 0),\n        map((event: ActivationEnd) => event.snapshot?.data?.title ?? '')\n      )\n      .subscribe((title) => {\n        this.pageHeading.next(title);\n        this.pageTitle.setTitle(title);\n      });\n  }\n\n  ngOnDestroy(): void {\n    this.onDestroy$.next(true);\n    this.onDestroy$.complete();\n  }\n\n  init(): void {\n    this.alfrescoApiService.getInstance().on('error', (error: { status: number; response: any }) => {\n      if (error.status === 401 && !this.alfrescoApiService.isExcludedErrorListener(error?.response?.req?.url)) {\n        if (!this.authenticationService.isLoggedIn()) {\n          this.matDialog.closeAll();\n\n          let redirectUrl = this.activatedRoute.snapshot.queryParams['redirectUrl'];\n          if (!redirectUrl) {\n            redirectUrl = this.router.url;\n          }\n\n          this.router.navigate(['/login'], {\n            queryParams: { redirectUrl }\n          });\n        }\n      }\n    });\n\n    this.loadCustomCss();\n    this.loadCustomWebFont();\n\n    const { router } = this;\n\n    this.router.events.pipe(filter((event) => event instanceof ActivationEnd && event.snapshot.children.length === 0)).subscribe(() => {\n      this.store.dispatch(new SetCurrentUrlAction(router.url));\n    });\n\n    this.router.events.pipe(filter((event) => event instanceof NavigationStart)).subscribe(() => {\n      this.store.dispatch(new ResetSelectionAction());\n    });\n\n    this.routerExtensionService.mapExtensionRoutes();\n\n    this.uploadService.fileUploadError.subscribe((error) => this.onFileUploadedError(error));\n\n    this.sharedLinksApiService.error.subscribe((err: { message: string }) => {\n      if (err?.message) {\n        this.notificationService.showError(err.message);\n      }\n    });\n\n    this.ready$.subscribe((isReady) => {\n      if (isReady) {\n        this.loadRepositoryStatus();\n        this.loadUserProfile();\n        setTimeout(() => {\n          this.openMobileAppDialog();\n        });\n      }\n    });\n\n    this.overlayContainer.getContainerElement().setAttribute('role', 'region');\n  }\n\n  setAppNavbarMode(mode: 'expanded' | 'collapsed'): void {\n    this.appNavNarMode$.next(mode);\n    this.preferencesService.set('expandedSidenav', mode === 'expanded');\n  }\n\n  private loadRepositoryStatus() {\n    this.contentApi.getRepositoryInformation().subscribe((response: DiscoveryEntry) => {\n      if (response?.entry?.repository) {\n        this.store.dispatch(new SetRepositoryInfoAction(response.entry.repository));\n      }\n    });\n  }\n\n  private async loadUserProfile() {\n    const profile = await this.userProfileService.loadUserProfile();\n    this.store.dispatch(new SetUserProfileAction(profile));\n  }\n\n  onFileUploadedError(error: FileUploadErrorEvent) {\n    let message = 'APP.MESSAGES.UPLOAD.ERROR.GENERIC';\n\n    if (error?.error?.status === 403) {\n      message = 'APP.MESSAGES.UPLOAD.ERROR.403';\n    }\n\n    if (error?.error?.status === 404) {\n      message = 'APP.MESSAGES.UPLOAD.ERROR.404';\n    }\n\n    if (error?.error?.status === 409) {\n      message = 'APP.MESSAGES.UPLOAD.ERROR.CONFLICT';\n    }\n\n    if (error?.error?.status === 500) {\n      message = 'APP.MESSAGES.UPLOAD.ERROR.500';\n    }\n\n    if (error?.error?.status === 504) {\n      message = 'APP.MESSAGES.UPLOAD.ERROR.504';\n    }\n\n    this.notificationService.showError(message);\n  }\n\n  private loadCustomCss(): void {\n    const customCssPath = this.appSettingsService.customCssPath;\n    if (customCssPath) {\n      this.createLink(customCssPath);\n    }\n  }\n\n  private loadCustomWebFont(): void {\n    const webFontPath = this.appSettingsService.webFontPath;\n    if (webFontPath) {\n      this.createLink(webFontPath);\n    }\n  }\n\n  private createLink(url: string): void {\n    const cssLinkElement = document.createElement('link');\n    cssLinkElement.setAttribute('rel', 'stylesheet');\n    cssLinkElement.setAttribute('type', 'text/css');\n    cssLinkElement.setAttribute('href', url);\n    document.head.appendChild(cssLinkElement);\n  }\n\n  public openMobileAppDialog(): void {\n    const isMobileSwitchEnabled: boolean = this.config.get<boolean>('mobileAppSwitch.enabled', false);\n    if (isMobileSwitchEnabled) {\n      this.acaMobileAppSwitcherService.resolveExistenceOfDialog();\n    } else {\n      this.acaMobileAppSwitcherService.clearSessionExpireTime();\n    }\n  }\n}\n"]}

package/esm2022/lib/services/auto-download.service.mjs

@@ -0,0 +1,59 @@
+/*!
+ * Copyright © 2005-2024 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Alfresco Example Content Application
+ *
+ * This file is part of the Alfresco Example Content Application.
+ * If the software was purchased under a paid Alfresco license, the terms of
+ * the paid license agreement will prevail. Otherwise, the software is
+ * provided under the following open source license terms:
+ *
+ * The Alfresco Example Content Application is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * The Alfresco Example Content Application is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * from Hyland Software. If not, see <http://www.gnu.org/licenses/>.
+ */
+import { inject, Injectable } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { FileAutoDownloadComponent } from '@alfresco/adf-content-services';
+import * as i0 from "@angular/core";
+const BYTES_TO_MB_CONVERSION_VALUE = 1048576;
+class AutoDownloadService {
+    dialog = inject(MatDialog);
+    shouldDownload(node, threshold) {
+        const fileSizeInBytes = node?.entry?.content?.sizeInBytes || 0;
+        const sizeInMB = fileSizeInBytes / BYTES_TO_MB_CONVERSION_VALUE;
+        return sizeInMB && sizeInMB > threshold;
+    }
+    /**
+     * Opens the dialog to download the node content.
+     * Determines whether node content should be auto downloaded based on the file size and the configured threshold.
+     * @param node node entry
+     * @param threshold file size threshold in MB
+     */
+    tryDownload(node, threshold) {
+        if (this.shouldDownload(node, threshold)) {
+            this.dialog.open(FileAutoDownloadComponent, { disableClose: true, data: node });
+            return true;
+        }
+        return false;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AutoDownloadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AutoDownloadService, providedIn: 'root' });
+}
+export { AutoDownloadService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.9", ngImport: i0, type: AutoDownloadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0by1kb3dubG9hZC5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYWNhLXNoYXJlZC9zcmMvbGliL3NlcnZpY2VzL2F1dG8tZG93bmxvYWQuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXNCRztBQUVILE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUVyRCxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQzs7QUFFM0UsTUFBTSw0QkFBNEIsR0FBRyxPQUFPLENBQUM7QUFFN0MsTUFHYSxtQkFBbUI7SUFDdEIsTUFBTSxHQUFHLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUUzQixjQUFjLENBQUMsSUFBZSxFQUFFLFNBQWlCO1FBQ3ZELE1BQU0sZUFBZSxHQUFHLElBQUksRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFLFdBQVcsSUFBSSxDQUFDLENBQUM7UUFDL0QsTUFBTSxRQUFRLEdBQUcsZUFBZSxHQUFHLDRCQUE0QixDQUFDO1FBRWhFLE9BQU8sUUFBUSxJQUFJLFFBQVEsR0FBRyxTQUFTLENBQUM7SUFDMUMsQ0FBQztJQUVEOzs7OztPQUtHO0lBQ0gsV0FBVyxDQUFDLElBQWUsRUFBRSxTQUFpQjtRQUM1QyxJQUFJLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxFQUFFO1lBQ3hDLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLHlCQUF5QixFQUFFLEVBQUUsWUFBWSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztZQUNoRixPQUFPLElBQUksQ0FBQztTQUNiO1FBRUQsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO3VHQXZCVSxtQkFBbUI7MkdBQW5CLG1CQUFtQixjQUZsQixNQUFNOztTQUVQLG1CQUFtQjsyRkFBbkIsbUJBQW1CO2tCQUgvQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNCBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvblxuICpcbiAqIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24uXG4gKiBJZiB0aGUgc29mdHdhcmUgd2FzIHB1cmNoYXNlZCB1bmRlciBhIHBhaWQgQWxmcmVzY28gbGljZW5zZSwgdGhlIHRlcm1zIG9mXG4gKiB0aGUgcGFpZCBsaWNlbnNlIGFncmVlbWVudCB3aWxsIHByZXZhaWwuIE90aGVyd2lzZSwgdGhlIHNvZnR3YXJlIGlzXG4gKiBwcm92aWRlZCB1bmRlciB0aGUgZm9sbG93aW5nIG9wZW4gc291cmNlIGxpY2Vuc2UgdGVybXM6XG4gKlxuICogVGhlIEFsZnJlc2NvIEV4YW1wbGUgQ29udGVudCBBcHBsaWNhdGlvbiBpcyBmcmVlIHNvZnR3YXJlOiB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5XG4gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnlcbiAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yXG4gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLlxuICpcbiAqIFRoZSBBbGZyZXNjbyBFeGFtcGxlIENvbnRlbnQgQXBwbGljYXRpb24gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCxcbiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mXG4gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIFNlZSB0aGVcbiAqIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLlxuICpcbiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZVxuICogZnJvbSBIeWxhbmQgU29mdHdhcmUuIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi5cbiAqL1xuXG5pbXBvcnQgeyBpbmplY3QsIEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE1hdERpYWxvZyB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2RpYWxvZyc7XG5pbXBvcnQgeyBOb2RlRW50cnkgfSBmcm9tICdAYWxmcmVzY28vanMtYXBpJztcbmltcG9ydCB7IEZpbGVBdXRvRG93bmxvYWRDb21wb25lbnQgfSBmcm9tICdAYWxmcmVzY28vYWRmLWNvbnRlbnQtc2VydmljZXMnO1xuXG5jb25zdCBCWVRFU19UT19NQl9DT05WRVJTSU9OX1ZBTFVFID0gMTA0ODU3NjtcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgQXV0b0Rvd25sb2FkU2VydmljZSB7XG4gIHByaXZhdGUgZGlhbG9nID0gaW5qZWN0KE1hdERpYWxvZyk7XG5cbiAgcHJpdmF0ZSBzaG91bGREb3dubG9hZChub2RlOiBOb2RlRW50cnksIHRocmVzaG9sZDogbnVtYmVyKTogYm9vbGVhbiB7XG4gICAgY29uc3QgZmlsZVNpemVJbkJ5dGVzID0gbm9kZT8uZW50cnk/LmNvbnRlbnQ/LnNpemVJbkJ5dGVzIHx8IDA7XG4gICAgY29uc3Qgc2l6ZUluTUIgPSBmaWxlU2l6ZUluQnl0ZXMgLyBCWVRFU19UT19NQl9DT05WRVJTSU9OX1ZBTFVFO1xuXG4gICAgcmV0dXJuIHNpemVJbk1CICYmIHNpemVJbk1CID4gdGhyZXNob2xkO1xuICB9XG5cbiAgLyoqXG4gICAqIE9wZW5zIHRoZSBkaWFsb2cgdG8gZG93bmxvYWQgdGhlIG5vZGUgY29udGVudC5cbiAgICogRGV0ZXJtaW5lcyB3aGV0aGVyIG5vZGUgY29udGVudCBzaG91bGQgYmUgYXV0byBkb3dubG9hZGVkIGJhc2VkIG9uIHRoZSBmaWxlIHNpemUgYW5kIHRoZSBjb25maWd1cmVkIHRocmVzaG9sZC5cbiAgICogQHBhcmFtIG5vZGUgbm9kZSBlbnRyeVxuICAgKiBAcGFyYW0gdGhyZXNob2xkIGZpbGUgc2l6ZSB0aHJlc2hvbGQgaW4gTUJcbiAgICovXG4gIHRyeURvd25sb2FkKG5vZGU6IE5vZGVFbnRyeSwgdGhyZXNob2xkOiBudW1iZXIpOiBib29sZWFuIHtcbiAgICBpZiAodGhpcy5zaG91bGREb3dubG9hZChub2RlLCB0aHJlc2hvbGQpKSB7XG4gICAgICB0aGlzLmRpYWxvZy5vcGVuKEZpbGVBdXRvRG93bmxvYWRDb21wb25lbnQsIHsgZGlzYWJsZUNsb3NlOiB0cnVlLCBkYXRhOiBub2RlIH0pO1xuICAgICAgcmV0dXJuIHRydWU7XG4gICAgfVxuXG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG59XG4iXX0=