UNPKG

@linid-dm/directory-manager-client-core

Version:

Core package by providing a set of angular components for the Directory Manager app.

118 lines • 23.8 kB

JavaScript

import { __decorate } from "tslib"; /** * Copyright (C) 2020-2024 Linagora * * This program is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the Free * Software Foundation, either version 3 of the License, or (at your option) any * later version, provided you comply with the Additional Terms applicable for * LinID Directory Manager software by LINAGORA pursuant to Section 7 of the GNU * Affero General Public License, subsections (b), (c), and (e), pursuant to * which these Appropriate Legal Notices must notably (i) retain the display of * the "LinID™" trademark/logo at the top of the interface window, the display * of the “You are using the Open Source and free version of LinID™, powered by * Linagora © 2009–2013. Contribute to LinID R&D by subscribing to an Enterprise * offer!” infobox and in the e-mails sent with the Program, notice appended to * any type of outbound messages (e.g. e-mail and meeting requests) as well as * in the LinID Directory Manager user interface, (ii) retain all hypertext * links between LinID Directory Manager and https://linid.org/, as well as * between LINAGORA and LINAGORA.com, and (iii) refrain from infringing LINAGORA * intellectual property rights over its trademarks and commercial brands. Other * Additional Terms apply, see <http://www.linagora.com/licenses/> for more * details. * * This program 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 Affero General Public License for more * details. * * You should have received a copy of the GNU Affero General Public License and * its applicable Additional Terms for LinID Directory Manager along with this * program. If not, see <http://www.gnu.org/licenses/> for the GNU Affero * General Public License version 3 and <http://www.linagora.com/licenses/> for * the Additional Terms applicable to the LinID Directory Manager software. */ import { Breakpoints, } from '@angular/cdk/layout'; import { Component, Inject } from '@angular/core'; import { Select } from '@ngxs/store'; import { filter, Subject, takeUntil, tap } from 'rxjs'; import { Ui, UiState } from '../../shared'; import { LANGUAGES } from './core/injection-tokens'; import * as i0 from "@angular/core"; import * as i1 from "@ngx-translate/core"; import * as i2 from "@ngxs/store"; import * as i3 from "@angular/cdk/layout"; import * as i4 from "./shared/auth/auth.service.interface"; import * as i5 from "./shared/services/routing.service"; import * as i6 from "@angular/router"; export class AppComponent { constructor(_translate, languages, _store$, _breakpointObserver, _authService, _routingService) { this._translate = _translate; this.languages = languages; this._store$ = _store$; this._breakpointObserver = _breakpointObserver; this._authService = _authService; this._routingService = _routingService; this._onDestroy$ = new Subject(); this._screenSizeMap = new Map([ [Breakpoints.XSmall, 'xs'], [Breakpoints.Small, 'sm'], [Breakpoints.Medium, 'md'], [Breakpoints.Large, 'lg'], [Breakpoints.XLarge, 'xl'], ]); } ngOnInit() { this._authService.run(); this._routingService.run(); this._breakpointObserver .observe([ Breakpoints.XSmall, Breakpoints.Small, Breakpoints.Medium, Breakpoints.Large, Breakpoints.XLarge, ]) .subscribe((breakpointChangeSize) => { let screenSize; for (const query of Object.keys(breakpointChangeSize.breakpoints)) { if (breakpointChangeSize.breakpoints[query]) { screenSize = this._screenSizeMap.get(query) ?? 'Unknown'; } } this._store$.dispatch(new Ui.ChangeScreenSize({ screenSize: screenSize, })); }); // default and fallback language // if a translation isn't found in a language, // it'll try to get it on the default language // by default here, we take the first of the array const browserLanguage = this._translate.getBrowserLang(); const languageToUse = browserLanguage || this.languages[0]; this._translate.setDefaultLang(languageToUse); this._store$.dispatch(new Ui.SetLanguage({ language: languageToUse })); // when the language changes in store, // change it in translate provider this.language$ .pipe(takeUntil(this._onDestroy$), filter((language) => !!language), tap((language) => this._translate.use(language))) .subscribe(); } ngOnDestroy() { this._onDestroy$.next(); this._onDestroy$.complete(); } static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: AppComponent, deps: [{ token: i1.TranslateService }, { token: LANGUAGES }, { token: i2.Store }, { token: i3.BreakpointObserver }, { token: i4.AuthService }, { token: i5.RoutingService }], target: i0.ɵɵFactoryTarget.Component }); } static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.4", type: AppComponent, selector: "dm-root", ngImport: i0, template: "\n\n<router-outlet></router-outlet>\n", styles: ["@charset \"UTF-8\";\n"], dependencies: [{ kind: "directive", type: i6.RouterOutlet, selector: "router-outlet", inputs: ["name"], outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }] }); } } __decorate([ Select(UiState.getLanguage) ], AppComponent.prototype, "language$", void 0); i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.4", ngImport: i0, type: AppComponent, decorators: [{ type: Component, args: [{ selector: 'dm-root', template: "\n\n<router-outlet></router-outlet>\n", styles: ["@charset \"UTF-8\";\n"] }] }], ctorParameters: () => [{ type: i1.TranslateService }, { type: undefined, decorators: [{ type: Inject, args: [LANGUAGES] }] }, { type: i2.Store }, { type: i3.BreakpointObserver }, { type: i4.AuthService }, { type: i5.RoutingService }], propDecorators: { language$: [] } }); //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.component.js","sourceRoot":"","sources":["../../../../../../../../packages/libs/client-core/src/lib/dm-core/app/app.component.ts","../../../../../../../../packages/libs/client-core/src/lib/dm-core/app/app.component.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * Copyright (C) 2020-2024 Linagora\n *\n * This program is free software: you can redistribute it and/or modify it under\n * the terms of the GNU Affero General Public License as published by the Free\n * Software Foundation, either version 3 of the License, or (at your option) any\n * later version, provided you comply with the Additional Terms applicable for\n * LinID Directory Manager software by LINAGORA pursuant to Section 7 of the GNU\n * Affero General Public License, subsections (b), (c), and (e), pursuant to\n * which these Appropriate Legal Notices must notably (i) retain the display of\n * the \"LinID™\" trademark/logo at the top of the interface window, the display\n * of the “You are using the Open Source and free version of LinID™, powered by\n * Linagora © 2009–2013. Contribute to LinID R&D by subscribing to an Enterprise\n * offer!” infobox and in the e-mails sent with the Program, notice appended to\n * any type of outbound messages (e.g. e-mail and meeting requests) as well as\n * in the LinID Directory Manager user interface, (ii) retain all hypertext\n * links between LinID Directory Manager and https://linid.org/, as well as\n * between LINAGORA and LINAGORA.com, and (iii) refrain from infringing LINAGORA\n * intellectual property rights over its trademarks and commercial brands. Other\n * Additional Terms apply, see <http://www.linagora.com/licenses/> for more\n * details.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more\n * details.\n *\n * You should have received a copy of the GNU Affero General Public License and\n * its applicable Additional Terms for LinID Directory Manager along with this\n * program. If not, see <http://www.gnu.org/licenses/> for the GNU Affero\n * General Public License version 3 and <http://www.linagora.com/licenses/> for\n * the Additional Terms applicable to the LinID Directory Manager software.\n */\n\nimport {\n  BreakpointObserver,\n  Breakpoints,\n  BreakpointState,\n} from '@angular/cdk/layout';\nimport { Component, Inject, OnDestroy, OnInit } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { Select, Store } from '@ngxs/store';\nimport { filter, Observable, Subject, takeUntil, tap } from 'rxjs';\nimport { ScreenSize, Ui, UiState } from '../../shared';\nimport { LANGUAGES } from './core/injection-tokens';\nimport { AuthService } from './shared/auth/auth.service.interface';\nimport { RoutingService } from './shared/services/routing.service';\n\n@Component({\n  selector: 'dm-root',\n  templateUrl: './app.component.html',\n  styleUrls: ['./app.component.scss'],\n})\nexport class AppComponent implements OnInit, OnDestroy {\n  @Select(UiState.getLanguage) language$: Observable<string>;\n\n  private _onDestroy$ = new Subject<void>();\n\n  private _screenSizeMap = new Map([\n    [Breakpoints.XSmall, 'xs'],\n    [Breakpoints.Small, 'sm'],\n    [Breakpoints.Medium, 'md'],\n    [Breakpoints.Large, 'lg'],\n    [Breakpoints.XLarge, 'xl'],\n  ]);\n\n  constructor(\n    private _translate: TranslateService,\n    @Inject(LANGUAGES) public languages,\n    private _store$: Store,\n    private _breakpointObserver: BreakpointObserver,\n    private _authService: AuthService,\n    private _routingService: RoutingService\n  ) {}\n\n  ngOnInit(): void {\n    this._authService.run();\n    this._routingService.run();\n\n    this._breakpointObserver\n      .observe([\n        Breakpoints.XSmall,\n        Breakpoints.Small,\n        Breakpoints.Medium,\n        Breakpoints.Large,\n        Breakpoints.XLarge,\n      ])\n      .subscribe((breakpointChangeSize: BreakpointState) => {\n        let screenSize: string;\n        for (const query of Object.keys(breakpointChangeSize.breakpoints)) {\n          if (breakpointChangeSize.breakpoints[query]) {\n            screenSize = this._screenSizeMap.get(query) ?? 'Unknown';\n          }\n        }\n        this._store$.dispatch(\n          new Ui.ChangeScreenSize({\n            screenSize: screenSize as ScreenSize,\n          })\n        );\n      });\n\n    // default and fallback language\n    // if a translation isn't found in a language,\n    // it'll try to get it on the default language\n    // by default here, we take the first of the array\n    const browserLanguage: string = this._translate.getBrowserLang();\n    const languageToUse: string = browserLanguage || this.languages[0];\n\n    this._translate.setDefaultLang(languageToUse);\n    this._store$.dispatch(new Ui.SetLanguage({ language: languageToUse }));\n\n    // when the language changes in store,\n    // change it in translate provider\n    this.language$\n      .pipe(\n        takeUntil(this._onDestroy$),\n        filter((language: string) => !!language),\n        tap((language: string) => this._translate.use(language))\n      )\n      .subscribe();\n  }\n\n  ngOnDestroy(): void {\n    this._onDestroy$.next();\n    this._onDestroy$.complete();\n  }\n}\n","<!-- Copyright (C) 2020-2024 Linagora\n\nThis program is free software: you can redistribute it and/or modify it under\nthe terms of the GNU Affero General Public License as published by the Free\nSoftware Foundation, either version 3 of the License, or (at your option) any\nlater version, provided you comply with the Additional Terms applicable for\nLinID Directory Manager software by LINAGORA pursuant to Section 7 of the GNU\nAffero General Public License, subsections (b), (c), and (e), pursuant to\nwhich these Appropriate Legal Notices must notably (i) retain the display of\nthe \"LinID™\" trademark/logo at the top of the interface window, the display\nof the “You are using the Open Source and free version of LinID™, powered by\nLinagora © 2009–2013. Contribute to LinID R&D by subscribing to an Enterprise\noffer!” infobox and in the e-mails sent with the Program, notice appended to\nany type of outbound messages (e.g. e-mail and meeting requests) as well as\nin the LinID Directory Manager user interface, (ii) retain all hypertext\nlinks between LinID Directory Manager and https://linid.org/, as well as\nbetween LINAGORA and LINAGORA.com, and (iii) refrain from infringing LINAGORA\nintellectual property rights over its trademarks and commercial brands. Other\nAdditional Terms apply, see <http://www.linagora.com/licenses/> for more\ndetails.\n\nThis program is distributed in the hope that it will be useful, but WITHOUT\nANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\nFOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more\ndetails.\n\nYou should have received a copy of the GNU Affero General Public License and\nits applicable Additional Terms for LinID Directory Manager along with this\nprogram. If not, see <http://www.gnu.org/licenses/> for the GNU Affero\nGeneral Public License version 3 and <http://www.linagora.com/licenses/> for\nthe Additional Terms applicable to the LinID Directory Manager software. -->\n\n<router-outlet></router-outlet>\n"]}