nuxeo-development-framework 0.0.0-watch

package/esm2015/lib/core/services/translation/translation.service.js

@@ -0,0 +1,176 @@
+import { Inject, Injectable, InjectionToken, Optional, } from '@angular/core';
+import { BehaviorSubject, forkJoin, from } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { Lang } from '../../enums/language.enum';
+import { UserPreferenceValues, } from '../user/user-preferences.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../localStorag/local-storag.service";
+import * as i3 from "../user/user-preferences.service";
+import * as i4 from "../../../configuration/app-config.service";
+import * as i5 from "../nuxeo/nuxeo.service";
+export const TRANSLATION_PROVIDER = new InjectionToken('Injection token for translation providers.');
+export class TranslationService {
+    constructor(translate, rendererFactory, localStorage, userPreferencesService, appConfig, nuxeoService, environment, providers) {
+        this.translate = translate;
+        this.rendererFactory = rendererFactory;
+        this.localStorage = localStorage;
+        this.appConfig = appConfig;
+        this.nuxeoService = nuxeoService;
+        this.environment = environment;
+        this.isArabic = new BehaviorSubject(false);
+        this.isArabic$ = this.isArabic.asObservable();
+        this.translationApiName = this.appConfig.myConfiguration['translationApi'] ? this.appConfig.myConfiguration['translationApi'] : null;
+        this.customLoader = this.translate.currentLoader;
+        this.renderer = rendererFactory.createRenderer(null, null);
+        this.defaultLang = 'en';
+        translate.setDefaultLang(this.defaultLang);
+        this.customLoader.setDefaultLang(this.defaultLang);
+        if (providers && providers.length > 0) {
+            for (const provider of providers) {
+                this.addTranslationFolder(provider.name, provider.source);
+            }
+        }
+        userPreferencesService
+            .select(UserPreferenceValues.Locale)
+            .subscribe((locale) => {
+            if (locale) {
+                this.userLang = locale.split('-')[0];
+            }
+            if (this.nuxeoService.nuxeoClient) {
+                if (this.userLang) {
+                    this.loadTranslation(this.userLang, this.defaultLang);
+                }
+                else {
+                    this.loadTranslation(this.defaultLang);
+                }
+            }
+        });
+    }
+    /**
+     * Adds a new folder of translation source files.
+     * @param name Name for the translation provider
+     * @param path Path to the folder
+     */
+    addTranslationFolder(name = '', path = '') {
+        if (!this.customLoader.providerRegistered(name)) {
+            this.customLoader.registerProvider(name, path);
+        }
+    }
+    /**
+     * Loads a translation file.
+     * @param lang Language code for the language to load
+     * @param fallback Language code to fall back to if the first one was unavailable
+     */
+    loadTranslation(lang, fallback) {
+        if (lang === Lang.Arabic) {
+            this.renderer.addClass(document.body, 'rtl');
+            this.isArabic.next(true);
+        }
+        else {
+            this.renderer.removeClass(document.body, 'rtl');
+            this.isArabic.next(false);
+        }
+        const arabicFile$ = this.getOrCreateTranslationFile('ar');
+        const englishFile$ = this.getOrCreateTranslationFile('en');
+        forkJoin([
+            arabicFile$,
+            englishFile$,
+            this.translate.getTranslation(lang),
+        ]).subscribe((res) => {
+            this.arabicFile = res[0];
+            this.englishFile = res[1];
+            this.translate.use(lang);
+            let ArorEnFile = lang === 'en'
+                ? JSON.parse(res[1].properties['note:note'])
+                : JSON.parse(res[0].properties['note:note']);
+            this.translate.setTranslation(this.translate.currentLang, Object.assign({}, ArorEnFile), true);
+            this.onTranslationChanged(lang);
+        }, () => {
+            if (fallback && fallback !== lang) {
+                this.loadTranslation(fallback);
+            }
+        });
+    }
+    /**
+     * Triggers a notification callback when the translation language changes.
+     * @param lang The new language code
+     */
+    onTranslationChanged(lang) {
+        this.translate.onTranslationChange.next({
+            lang: lang,
+            translations: this.customLoader.getFullTranslationJSON(lang),
+        });
+    }
+    /**
+     * Sets the target language for translations.
+     * @param lang Code name for the language
+     * @returns Translations available for the language
+     */
+    use(lang) {
+        this.customLoader.init(lang);
+        return this.translate.use(lang);
+    }
+    /**
+     * Gets the translation for the supplied key.
+     * @param key Key to translate
+     * @param interpolateParams String(s) to be interpolated into the main message
+     * @returns Translated text
+     */
+    get(key, interpolateParams) {
+        return this.translate.get(key, interpolateParams);
+    }
+    /**
+     * Directly returns the translation for the supplied key.
+     * @param key Key to translate
+     * @param interpolateParams String(s) to be interpolated into the main message
+     * @returns Translated text
+     */
+    instant(key, interpolateParams) {
+        return key ? this.translate.instant(key, interpolateParams) : '';
+    }
+    getOrCreateTranslationFile(lang) {
+        return from(this.nuxeoService.nuxeoClient
+            .operation(this.translationApiName ? this.translationApiName : 'AC_UA_Translation_GetOrCreate', {
+            url: `${this.environment.nuxeo}${this.environment.customAutomation}`,
+        })
+            .params({ language: lang })
+            .execute({
+            headers: {
+                properties: '*',
+            },
+        })).pipe(catchError((err) => {
+            console.log(err);
+            throw err;
+        }));
+    }
+    updateTranslationFile(doc, params = {}) {
+        return from(this.nuxeoService.nuxeoClient
+            .repository()
+            .headers({
+            properties: '*',
+        })
+            .update(doc, params)).pipe(map((data) => {
+            return data;
+        }), catchError((err) => {
+            throw err;
+        }));
+    }
+}
+TranslationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TranslationService, deps: [{ token: i1.TranslateService }, { token: i0.RendererFactory2 }, { token: i2.LocalStoragService }, { token: i3.UserPreferencesService }, { token: i4.AppConfigService }, { token: i5.NuxeoService }, { token: 'environment' }, { token: TRANSLATION_PROVIDER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+TranslationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TranslationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: TranslationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i0.RendererFactory2 }, { type: i2.LocalStoragService }, { type: i3.UserPreferencesService }, { type: i4.AppConfigService }, { type: i5.NuxeoService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TRANSLATION_PROVIDER]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translation.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/core/services/translation/translation.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  Inject,\r\n  Injectable,\r\n  InjectionToken,\r\n  Optional,\r\n  Renderer2,\r\n  RendererFactory2,\r\n} from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { BehaviorSubject, forkJoin, from, Observable } from 'rxjs';\r\nimport { catchError, map } from 'rxjs/operators';\r\nimport { AppConfigService } from '../../../configuration/app-config.service';\r\nimport { Lang } from '../../enums/language.enum';\r\nimport { LocalStoragService } from '../localStorag/local-storag.service';\r\nimport { NuxeoService } from '../nuxeo/nuxeo.service';\r\nimport {\r\n  UserPreferencesService,\r\n  UserPreferenceValues,\r\n} from '../user/user-preferences.service';\r\nimport { TranslateLoaderService } from './translate-loader.service';\r\n\r\nexport const TRANSLATION_PROVIDER = new InjectionToken(\r\n  'Injection token for translation providers.'\r\n);\r\n\r\nexport interface TranslationProvider {\r\n  name: string;\r\n  source: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TranslationService {\r\n  public arabicFile;\r\n  public englishFile;\r\n  defaultLang: string;\r\n  userLang: string;\r\n  customLoader: TranslateLoaderService;\r\n  lang: string;\r\n  private renderer: Renderer2;\r\n  isArabic = new BehaviorSubject<boolean>(false);\r\n  isArabic$ = this.isArabic.asObservable();\r\n  translationApiName;\r\n  constructor(\r\n    public translate: TranslateService,\r\n    private rendererFactory: RendererFactory2,\r\n    private localStorage: LocalStoragService,\r\n    userPreferencesService: UserPreferencesService,\r\n    private appConfig : AppConfigService,\r\n    private nuxeoService: NuxeoService,\r\n    @Inject('environment') private environment,\r\n    @Optional() @Inject(TRANSLATION_PROVIDER) providers: TranslationProvider[]\r\n  ) {\r\n    this.translationApiName = this.appConfig.myConfiguration['translationApi'] ? this.appConfig.myConfiguration['translationApi'] : null;\r\n    this.customLoader = <TranslateLoaderService>this.translate.currentLoader;\r\n    this.renderer = rendererFactory.createRenderer(null, null);\r\n\r\n    this.defaultLang = 'en';\r\n    translate.setDefaultLang(this.defaultLang);\r\n    this.customLoader.setDefaultLang(this.defaultLang);\r\n\r\n    if (providers && providers.length > 0) {\r\n      for (const provider of providers) {\r\n        this.addTranslationFolder(provider.name, provider.source);\r\n      }\r\n    }\r\n    userPreferencesService\r\n      .select(UserPreferenceValues.Locale)\r\n      .subscribe((locale) => {\r\n        if (locale) {\r\n          this.userLang = locale.split('-')[0];\r\n        }\r\n        if(this.nuxeoService.nuxeoClient){\r\n          if (this.userLang) {\r\n            this.loadTranslation(this.userLang, this.defaultLang);\r\n          } else {\r\n            this.loadTranslation(this.defaultLang);\r\n          }\r\n        }\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Adds a new folder of translation source files.\r\n   * @param name Name for the translation provider\r\n   * @param path Path to the folder\r\n   */\r\n  addTranslationFolder(name: string = '', path: string = '') {\r\n    if (!this.customLoader.providerRegistered(name)) {\r\n      this.customLoader.registerProvider(name, path);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Loads a translation file.\r\n   * @param lang Language code for the language to load\r\n   * @param fallback Language code to fall back to if the first one was unavailable\r\n   */\r\n  loadTranslation(lang: string, fallback?: string) {\r\n    if (lang === Lang.Arabic) {\r\n      this.renderer.addClass(document.body, 'rtl');\r\n      this.isArabic.next(true);\r\n    } else {\r\n      this.renderer.removeClass(document.body, 'rtl');\r\n      this.isArabic.next(false);\r\n    }\r\n    const arabicFile$ = this.getOrCreateTranslationFile('ar');\r\n    const englishFile$ = this.getOrCreateTranslationFile('en');\r\n\r\n    forkJoin([\r\n      arabicFile$,\r\n      englishFile$,\r\n      this.translate.getTranslation(lang),\r\n    ]).subscribe(\r\n      (res: any) => {\r\n        this.arabicFile = res[0];\r\n        this.englishFile = res[1];\r\n        this.translate.use(lang);\r\n        let ArorEnFile =\r\n          lang === 'en'\r\n            ? JSON.parse(res[1].properties['note:note'])\r\n            : JSON.parse(res[0].properties['note:note']);\r\n        this.translate.setTranslation(\r\n          this.translate.currentLang,\r\n          { ...ArorEnFile },\r\n          true\r\n        );\r\n\r\n        this.onTranslationChanged(lang);\r\n      },\r\n      () => {\r\n        if (fallback && fallback !== lang) {\r\n          this.loadTranslation(fallback);\r\n        }\r\n      }\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Triggers a notification callback when the translation language changes.\r\n   * @param lang The new language code\r\n   */\r\n  onTranslationChanged(lang: string): void {\r\n    this.translate.onTranslationChange.next({\r\n      lang: lang,\r\n      translations: this.customLoader.getFullTranslationJSON(lang),\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Sets the target language for translations.\r\n   * @param lang Code name for the language\r\n   * @returns Translations available for the language\r\n   */\r\n  use(lang: string): Observable<any> {\r\n    this.customLoader.init(lang);\r\n    return this.translate.use(lang);\r\n  }\r\n\r\n  /**\r\n   * Gets the translation for the supplied key.\r\n   * @param key Key to translate\r\n   * @param interpolateParams String(s) to be interpolated into the main message\r\n   * @returns Translated text\r\n   */\r\n  get(\r\n    key: string | Array<string>,\r\n    interpolateParams?: Object\r\n  ): Observable<string | any> {\r\n    return this.translate.get(key, interpolateParams);\r\n  }\r\n\r\n  /**\r\n   * Directly returns the translation for the supplied key.\r\n   * @param key Key to translate\r\n   * @param interpolateParams String(s) to be interpolated into the main message\r\n   * @returns Translated text\r\n   */\r\n  instant(\r\n    key: string | Array<string>,\r\n    interpolateParams?: Object\r\n  ): string | any {\r\n    return key ? this.translate.instant(key, interpolateParams) : '';\r\n  }\r\n\r\n  getOrCreateTranslationFile(lang) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .operation( this.translationApiName ? this.translationApiName : 'AC_UA_Translation_GetOrCreate', {\r\n          url: `${this.environment.nuxeo}${this.environment.customAutomation}`,\r\n        })\r\n        .params({ language: lang })\r\n        .execute({\r\n          headers: {\r\n            properties: '*',\r\n          },\r\n        })\r\n    ).pipe(\r\n      catchError((err) => {\r\n        console.log(err);\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n  updateTranslationFile(doc, params = {}) {\r\n    return from(\r\n      this.nuxeoService.nuxeoClient\r\n        .repository()\r\n        .headers({\r\n          properties: '*',\r\n        })\r\n        .update(doc, params)\r\n    ).pipe(\r\n      map((data: any) => {\r\n        return data;\r\n      }),\r\n      catchError((err) => {\r\n        throw err;\r\n      })\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2015/lib/core/services/user/user-preferences.service.js

@@ -0,0 +1,171 @@
+var _UserPreferencesService_instances, _UserPreferencesService_encrypt, _UserPreferencesService_decrypt, _UserPreferencesService_encryptKey_get, _UserPreferencesService_enableEncryption_get;
+import { __awaiter, __classPrivateFieldGet } from "tslib";
+import { Injectable } from "@angular/core";
+import { BehaviorSubject } from "rxjs";
+import { distinctUntilChanged, map } from "rxjs/operators";
+import CryptoJS from "crypto-js";
+import { EnvManager } from "../../env";
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../localStorag/local-storag.service";
+const ENCRYPT_KEY = "_ndf_";
+export var UserPreferenceValues;
+(function (UserPreferenceValues) {
+    UserPreferenceValues["Locale"] = "locale";
+    UserPreferenceValues["ExpandedSideNavStatus"] = "expandedSidenav";
+})(UserPreferenceValues || (UserPreferenceValues = {}));
+export class UserPreferencesService {
+    constructor(translate, storage) {
+        this.translate = translate;
+        this.storage = storage;
+        _UserPreferencesService_instances.add(this);
+        this.defaults = {
+            locale: "en",
+            expandedSidenav: true,
+        };
+        this.userPreferenceStatus = this.defaults;
+        this.onChangeSubject = new BehaviorSubject(this.userPreferenceStatus);
+        this.onChange = this.onChangeSubject.asObservable();
+    }
+    initUserPreferenceStatus() {
+        this.initUserLanguage();
+    }
+    initUserLanguage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.locale) {
+                const locale = this.locale || this.getDefaultLocale();
+                this.set(UserPreferenceValues.Locale, locale);
+                this.set("textOrientation", (yield this.getLanguageByKey(locale)).dir || "ltr");
+            }
+            else {
+                const locale = this.locale || this.getDefaultLocale();
+                this.setWithoutStore(UserPreferenceValues.Locale, locale);
+                this.setWithoutStore("textOrientation", (yield this.getLanguageByKey(locale)).dir || "ltr");
+            }
+        });
+    }
+    /**
+     * Sets up a callback to notify when a property has changed.
+     * @param property The property to watch
+     * @returns Notification callback
+     */
+    select(property) {
+        return this.onChange.pipe(map((userPreferenceStatus) => userPreferenceStatus[property]), distinctUntilChanged());
+    }
+    /**
+     * Gets a preference property.
+     * @param property Name of the property
+     * @param defaultValue Default to return if the property is not found
+     * @returns Preference property
+     */
+    get(property, defaultValue) {
+        const key = this.getPropertyKey(property);
+        const value = this.storage.getItem(key);
+        if (value === undefined || value === null) {
+            return defaultValue;
+        }
+        return __classPrivateFieldGet(this, _UserPreferencesService_instances, "m", _UserPreferencesService_decrypt).call(this, value);
+    }
+    /**
+     * Sets a preference property.
+     * @param property Name of the property
+     * @param value New value for the property
+     */
+    set(property, value) {
+        if (!property) {
+            return;
+        }
+        this.storage.setItem(this.getPropertyKey(property), __classPrivateFieldGet(this, _UserPreferencesService_instances, "m", _UserPreferencesService_encrypt).call(this, value));
+        this.userPreferenceStatus[property] = value;
+        this.onChangeSubject.next(this.userPreferenceStatus);
+    }
+    /**
+     * Sets a preference property.
+     * @param property Name of the property
+     * @param value New value for the property
+     */
+    setWithoutStore(property, value) {
+        if (!property) {
+            return;
+        }
+        this.userPreferenceStatus[property] = value;
+        this.onChangeSubject.next(this.userPreferenceStatus);
+    }
+    /**
+     * Check if an item is present in the storage
+     * @param property Name of the property
+     * @returns True if the item is present, false otherwise
+     */
+    hasItem(property) {
+        if (!property) {
+            return false;
+        }
+        return this.storage.hasItem(this.getPropertyKey(property));
+    }
+    /**
+     * Gets the active storage prefix for preferences.
+     * @returns Storage prefix
+     */
+    getStoragePrefix() {
+        return this.storage.getItem("USER_PROFILE") || "GUEST";
+    }
+    /**
+     * Sets the active storage prefix for preferences.
+     * @param value Name of the prefix
+     */
+    setStoragePrefix(value) {
+        this.storage.setItem("USER_PROFILE", value || "GUEST");
+        this.initUserPreferenceStatus();
+    }
+    /**
+     * Gets the full property key with prefix.
+     * @param property The property name
+     * @returns Property key
+     */
+    getPropertyKey(property) {
+        return `${this.getStoragePrefix()}__${property}`;
+    }
+    /** Current locale setting. */
+    get locale() {
+        return this.get(UserPreferenceValues.Locale);
+    }
+    set locale(value) {
+        this.set(UserPreferenceValues.Locale, value);
+    }
+    /**
+     * Gets the default locale.
+     * @returns Default locale language code
+     */
+    getDefaultLocale() {
+        return this.translate.getBrowserCultureLang() || "en";
+    }
+    getLanguageByKey(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const translation = yield this.translate.getTranslation(key).toPromise();
+            return translation;
+        });
+    }
+}
+_UserPreferencesService_instances = new WeakSet(), _UserPreferencesService_encrypt = function _UserPreferencesService_encrypt(message) {
+    if (!message || !__classPrivateFieldGet(this, _UserPreferencesService_instances, "a", _UserPreferencesService_enableEncryption_get))
+        return message;
+    return CryptoJS.AES.encrypt(message, __classPrivateFieldGet(this, _UserPreferencesService_instances, "a", _UserPreferencesService_encryptKey_get)).toString();
+}, _UserPreferencesService_decrypt = function _UserPreferencesService_decrypt(ciphertext) {
+    if (!ciphertext || !__classPrivateFieldGet(this, _UserPreferencesService_instances, "a", _UserPreferencesService_enableEncryption_get))
+        return ciphertext;
+    const bytes = CryptoJS.AES.decrypt(ciphertext, __classPrivateFieldGet(this, _UserPreferencesService_instances, "a", _UserPreferencesService_encryptKey_get));
+    return bytes.toString(CryptoJS.enc.Utf8);
+}, _UserPreferencesService_encryptKey_get = function _UserPreferencesService_encryptKey_get() {
+    return EnvManager.environment.encryptKey || ENCRYPT_KEY;
+}, _UserPreferencesService_enableEncryption_get = function _UserPreferencesService_enableEncryption_get() {
+    return EnvManager.environment.enableEncryption == "YES" || false;
+};
+UserPreferencesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UserPreferencesService, deps: [{ token: i1.TranslateService }, { token: i2.LocalStoragService }], target: i0.ɵɵFactoryTarget.Injectable });
+UserPreferencesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UserPreferencesService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: UserPreferencesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.LocalStoragService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-preferences.service.js","sourceRoot":"","sources":["../../../../../../../projects/nuxeo-development-framework/src/lib/core/services/user/user-preferences.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from \"@angular/core\";\r\nimport { TranslateService } from \"@ngx-translate/core\";\r\nimport { Observable, BehaviorSubject } from \"rxjs\";\r\nimport { distinctUntilChanged, map, filter } from \"rxjs/operators\";\r\nimport { LocalStoragService } from \"../localStorag/local-storag.service\";\r\n\r\nimport CryptoJS from \"crypto-js\";\r\nimport { EnvManager } from \"../../env\";\r\nconst ENCRYPT_KEY = \"_ndf_\";\r\n\r\nexport enum UserPreferenceValues {\r\n  Locale = \"locale\",\r\n  ExpandedSideNavStatus = \"expandedSidenav\",\r\n}\r\n\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class UserPreferencesService {\r\n  defaults = {\r\n    locale: \"en\",\r\n    expandedSidenav: true,\r\n  };\r\n\r\n  private userPreferenceStatus: any = this.defaults;\r\n  private onChangeSubject: BehaviorSubject<any>;\r\n  onChange: Observable<any>;\r\n\r\n  constructor(\r\n    public translate: TranslateService,\r\n    private storage: LocalStoragService\r\n  ) {\r\n    this.onChangeSubject = new BehaviorSubject(this.userPreferenceStatus);\r\n    this.onChange = this.onChangeSubject.asObservable();\r\n  }\r\n\r\n  private initUserPreferenceStatus() {\r\n    this.initUserLanguage();\r\n  }\r\n\r\n  private async initUserLanguage() {\r\n    if (this.locale) {\r\n      const locale = this.locale || this.getDefaultLocale();\r\n\r\n      this.set(UserPreferenceValues.Locale, locale);\r\n      this.set(\r\n        \"textOrientation\",\r\n        (await this.getLanguageByKey(locale)).dir || \"ltr\"\r\n      );\r\n    } else {\r\n      const locale = this.locale || this.getDefaultLocale();\r\n\r\n      this.setWithoutStore(UserPreferenceValues.Locale, locale);\r\n      this.setWithoutStore(\r\n        \"textOrientation\",\r\n        (await this.getLanguageByKey(locale)).dir || \"ltr\"\r\n      );\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets up a callback to notify when a property has changed.\r\n   * @param property The property to watch\r\n   * @returns Notification callback\r\n   */\r\n  select(property: string): Observable<any> {\r\n    return this.onChange.pipe(\r\n      map((userPreferenceStatus) => userPreferenceStatus[property]),\r\n      distinctUntilChanged()\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Gets a preference property.\r\n   * @param property Name of the property\r\n   * @param defaultValue Default to return if the property is not found\r\n   * @returns Preference property\r\n   */\r\n  get(property: string, defaultValue?: string): string {\r\n    const key = this.getPropertyKey(property);\r\n    const value = this.storage.getItem(key);\r\n    if (value === undefined || value === null) {\r\n      return defaultValue;\r\n    }\r\n    return this.#decrypt(value);\r\n  }\r\n\r\n  /**\r\n   * Sets a preference property.\r\n   * @param property Name of the property\r\n   * @param value New value for the property\r\n   */\r\n  set(property: string, value: any) {\r\n    if (!property) {\r\n      return;\r\n    }\r\n    this.storage.setItem(this.getPropertyKey(property), this.#encrypt(value));\r\n    this.userPreferenceStatus[property] = value;\r\n    this.onChangeSubject.next(this.userPreferenceStatus);\r\n  }\r\n\r\n  /**\r\n   * Sets a preference property.\r\n   * @param property Name of the property\r\n   * @param value New value for the property\r\n   */\r\n  setWithoutStore(property: string, value: any) {\r\n    if (!property) {\r\n      return;\r\n    }\r\n    this.userPreferenceStatus[property] = value;\r\n    this.onChangeSubject.next(this.userPreferenceStatus);\r\n  }\r\n\r\n  /**\r\n   * Check if an item is present in the storage\r\n   * @param property Name of the property\r\n   * @returns True if the item is present, false otherwise\r\n   */\r\n  hasItem(property: string): boolean {\r\n    if (!property) {\r\n      return false;\r\n    }\r\n    return this.storage.hasItem(this.getPropertyKey(property));\r\n  }\r\n\r\n  /**\r\n   * Gets the active storage prefix for preferences.\r\n   * @returns Storage prefix\r\n   */\r\n  getStoragePrefix(): string {\r\n    return this.storage.getItem(\"USER_PROFILE\") || \"GUEST\";\r\n  }\r\n\r\n  /**\r\n   * Sets the active storage prefix for preferences.\r\n   * @param value Name of the prefix\r\n   */\r\n  setStoragePrefix(value: string) {\r\n    this.storage.setItem(\"USER_PROFILE\", value || \"GUEST\");\r\n    this.initUserPreferenceStatus();\r\n  }\r\n\r\n  /**\r\n   * Gets the full property key with prefix.\r\n   * @param property The property name\r\n   * @returns Property key\r\n   */\r\n  getPropertyKey(property: string): string {\r\n    return `${this.getStoragePrefix()}__${property}`;\r\n  }\r\n\r\n  /** Current locale setting. */\r\n  get locale(): string {\r\n    return this.get(UserPreferenceValues.Locale);\r\n  }\r\n\r\n  set locale(value: string) {\r\n    this.set(UserPreferenceValues.Locale, value);\r\n  }\r\n\r\n  /**\r\n   * Gets the default locale.\r\n   * @returns Default locale language code\r\n   */\r\n  public getDefaultLocale(): string {\r\n    return this.translate.getBrowserCultureLang() || \"en\";\r\n  }\r\n\r\n  private async getLanguageByKey(key: string) {\r\n    const translation = await this.translate.getTranslation(key).toPromise();\r\n    return translation;\r\n  }\r\n\r\n  #encrypt(message: string) {\r\n    if (!message || !this.#enableEncryption) return message;\r\n\r\n    return CryptoJS.AES.encrypt(message, this.#encryptKey).toString();\r\n  }\r\n  #decrypt(ciphertext: string) {\r\n    if (!ciphertext || !this.#enableEncryption) return ciphertext;\r\n\r\n    const bytes = CryptoJS.AES.decrypt(ciphertext, this.#encryptKey);\r\n    return bytes.toString(CryptoJS.enc.Utf8);\r\n  }\r\n  get #encryptKey() {\r\n    return EnvManager.environment.encryptKey || ENCRYPT_KEY;\r\n  }\r\n  get #enableEncryption() {\r\n    return EnvManager.environment.enableEncryption == \"YES\" || false;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/core/utilities/moment-date-adapter.js

@@ -0,0 +1,178 @@
+import { Injectable } from '@angular/core';
+import { DateAdapter } from '@angular/material/core';
+import { isMoment } from 'moment';
+import moment from 'moment-es6';
+import * as i0 from "@angular/core";
+export class MomentDateAdapter extends DateAdapter {
+    constructor() {
+        super(...arguments);
+        this.localeData = moment.localeData();
+    }
+    getYear(date) {
+        return date.year();
+    }
+    getMonth(date) {
+        return date.month();
+    }
+    getDate(date) {
+        return date.date();
+    }
+    getDayOfWeek(date) {
+        return date.day();
+    }
+    getMonthNames(style) {
+        switch (style) {
+            case 'long':
+                return this.localeData.months();
+            case 'short':
+                return this.localeData.monthsShort();
+            case 'narrow':
+                return this.localeData.monthsShort().map((month) => month[0]);
+            default:
+                return [];
+        }
+    }
+    getDateNames() {
+        const dateNames = [];
+        for (let date = 1; date <= 31; date++) {
+            dateNames.push(String(date));
+        }
+        return dateNames;
+    }
+    getDayOfWeekNames(style) {
+        switch (style) {
+            case 'long':
+                return this.localeData.weekdays();
+            case 'short':
+                return this.localeData.weekdaysShort();
+            case 'narrow':
+                return this.localeData.weekdaysShort();
+            default:
+                return [];
+        }
+    }
+    getYearName(date) {
+        return String(date.year());
+    }
+    getFirstDayOfWeek() {
+        return this.localeData.firstDayOfWeek();
+    }
+    getNumDaysInMonth(date) {
+        return date.daysInMonth();
+    }
+    clone(date) {
+        const locale = this.locale || 'en';
+        return date.clone().locale(locale);
+    }
+    createDate(year, month, date) {
+        return moment([year, month, date]);
+    }
+    today() {
+        const locale = this.locale || 'en';
+        return moment().locale(locale);
+    }
+    parse(value, parseFormat) {
+        const locale = this.locale || 'en';
+        if (value && typeof value === 'string') {
+            let m = moment(value, parseFormat, locale, true);
+            if (!m.isValid()) {
+                // use strict parsing because Moment's parser is very forgiving, and this can lead to undesired behavior.
+                m = moment(value, this.overrideDisplayFormat, locale, true);
+            }
+            if (m.isValid()) {
+                // if user omits year, it defaults to 2001, so check for that issue.
+                if (m.year() === 2001 && value.indexOf('2001') === -1) {
+                    // if 2001 not actually in the value string, change to current year
+                    const currentYear = new Date().getFullYear();
+                    m.set('year', currentYear);
+                    // if date is in the future, set previous year
+                    if (m.isAfter(moment())) {
+                        m.set('year', currentYear - 1);
+                    }
+                }
+            }
+            return m;
+        }
+        return value ? moment(value).locale(locale) : null;
+    }
+    format(date, displayFormat) {
+        date = this.clone(date);
+        displayFormat = this.overrideDisplayFormat ? this.overrideDisplayFormat : displayFormat;
+        if (date && date.format) {
+            return date.format(displayFormat);
+        }
+        else {
+            return '';
+        }
+    }
+    addCalendarYears(date, years) {
+        return date.clone().add(years, 'y');
+    }
+    addCalendarMonths(date, months) {
+        return date.clone().add(months, 'M');
+    }
+    addCalendarDays(date, days) {
+        return date.clone().add(days, 'd');
+    }
+    getISODateString(date) {
+        return date.toISOString();
+    }
+    setLocale(locale) {
+        super.setLocale(locale);
+        this.localeData = moment.localeData(locale);
+    }
+    compareDate(first, second) {
+        return first.diff(second, 'seconds', true);
+    }
+    sameDate(first, second) {
+        if (first == null) {
+            // same if both null
+            return second == null;
+        }
+        else if (isMoment(first)) {
+            return first.isSame(second);
+        }
+        else {
+            const isSame = super.sameDate(first, second);
+            return isSame;
+        }
+    }
+    clampDate(date, min, max) {
+        if (min && date.isBefore(min)) {
+            return min;
+        }
+        else if (max && date.isAfter(max)) {
+            return max;
+        }
+        else {
+            return date;
+        }
+    }
+    isDateInstance(date) {
+        let isValidDateInstance = false;
+        if (date) {
+            isValidDateInstance = date._isAMomentObject;
+        }
+        return isValidDateInstance;
+    }
+    isValid(date) {
+        return date.isValid();
+    }
+    toIso8601(date) {
+        return this.clone(date).format();
+    }
+    fromIso8601(iso8601String) {
+        const locale = this.locale || 'en';
+        const d = moment(iso8601String, moment.ISO_8601).locale(locale);
+        return this.isValid(d) ? d : null;
+    }
+    invalid() {
+        return moment.invalid();
+    }
+}
+MomentDateAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MomentDateAdapter, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+MomentDateAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MomentDateAdapter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MomentDateAdapter, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"moment-date-adapter.js","sourceRoot":"","sources":["../../../../../../projects/nuxeo-development-framework/src/lib/core/utilities/moment-date-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,QAAQ,EAAU,MAAM,QAAQ,CAAC;AAC1C,OAAO,MAAM,MAAM,YAAY,CAAC;;AAGhC,MAAM,OAAO,iBAAkB,SAAQ,WAAmB;IAD1D;;QAGU,eAAU,GAAQ,MAAM,CAAC,UAAU,EAAE,CAAC;KAkM/C;IA9LC,OAAO,CAAC,IAAY;QAClB,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IAED,QAAQ,CAAC,IAAY;QACnB,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC;IACtB,CAAC;IAED,OAAO,CAAC,IAAY;QAClB,OAAO,IAAI,CAAC,IAAI,EAAE,CAAC;IACrB,CAAC;IAED,YAAY,CAAC,IAAY;QACvB,OAAO,IAAI,CAAC,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,aAAa,CAAC,KAAkC;QAC9C,QAAQ,KAAK,EAAE;YACb,KAAK,MAAM;gBACT,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;YAClC,KAAK,OAAO;gBACV,OAAO,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;YACvC,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAChE;gBACE,OAAO,EAAE,CAAC;SACb;IACH,CAAC;IAED,YAAY;QACV,MAAM,SAAS,GAAa,EAAE,CAAC;QAC/B,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE;YACrC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;SAC9B;QAED,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,iBAAiB,CAAC,KAAkC;QAClD,QAAQ,KAAK,EAAE;YACb,KAAK,MAAM;gBACT,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;YACpC,KAAK,OAAO;gBACV,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC;YACzC,KAAK,QAAQ;gBACX,OAAO,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC;YACzC;gBACE,OAAO,EAAE,CAAC;SACb;IACH,CAAC;IAED,WAAW,CAAC,IAAY;QACtB,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7B,CAAC;IAED,iBAAiB;QACf,OAAO,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;IAC1C,CAAC;IAED,iBAAiB,CAAC,IAAY;QAC5B,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;IAED,KAAK,CAAC,IAAY;QAChB,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC;QACnC,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;IAED,UAAU,CAAC,IAAY,EAAE,KAAa,EAAE,IAAY;QAClD,OAAO,MAAM,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;IACrC,CAAC;IAED,KAAK;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC;QACnC,OAAO,MAAM,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,KAAU,EAAE,WAAgB;QAChC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC;QAEnC,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YACtC,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;YACjD,IAAI,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE;gBAChB,yGAAyG;gBACzG,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,qBAAqB,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;aAC7D;YACD,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;gBACf,oEAAoE;gBACpE,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE;oBACrD,mEAAmE;oBACnE,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;oBAC7C,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;oBAC3B,8CAA8C;oBAC9C,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE;wBACvB,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,GAAG,CAAC,CAAC,CAAC;qBAChC;iBACF;aACF;YACD,OAAO,CAAC,CAAC;SACV;QAED,OAAO,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACrD,CAAC;IAED,MAAM,CAAC,IAAY,EAAE,aAAkB;QACrC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACxB,aAAa,GAAG,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,CAAC,aAAa,CAAC;QAExF,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE;YACvB,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;SACnC;aAAM;YACL,OAAO,EAAE,CAAC;SACX;IACH,CAAC;IAED,gBAAgB,CAAC,IAAY,EAAE,KAAa;QAC1C,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;IACtC,CAAC;IAED,iBAAiB,CAAC,IAAY,EAAE,MAAc;QAC5C,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACvC,CAAC;IAED,eAAe,CAAC,IAAY,EAAE,IAAY;QACxC,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IACrC,CAAC;IAED,gBAAgB,CAAC,IAAY;QAC3B,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;IAC5B,CAAC;IAED,SAAS,CAAC,MAAW;QACnB,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAExB,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED,WAAW,CAAC,KAAa,EAAE,MAAc;QACvC,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC;IAC7C,CAAC;IAED,QAAQ,CAAC,KAAmB,EAAE,MAAoB;QAChD,IAAI,KAAK,IAAI,IAAI,EAAE;YACjB,oBAAoB;YACpB,OAAO,MAAM,IAAI,IAAI,CAAC;SACvB;aAAM,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE;YAC1B,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;SAC7B;aAAM;YACL,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YAC7C,OAAO,MAAM,CAAC;SACf;IACH,CAAC;IAED,SAAS,CAAC,IAAY,EAAE,GAAkB,EAAE,GAAkB;QAC5D,IAAI,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YAC7B,OAAO,GAAG,CAAC;SACZ;aAAM,IAAI,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACnC,OAAO,GAAG,CAAC;SACZ;aAAM;YACL,OAAO,IAAI,CAAC;SACb;IACH,CAAC;IAED,cAAc,CAAC,IAAS;QACtB,IAAI,mBAAmB,GAAG,KAAK,CAAC;QAEhC,IAAI,IAAI,EAAE;YACR,mBAAmB,GAAG,IAAI,CAAC,gBAAgB,CAAC;SAC7C;QAED,OAAO,mBAAmB,CAAC;IAC7B,CAAC;IAED,OAAO,CAAC,IAAY;QAClB,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;IAED,SAAS,CAAC,IAAY;QACpB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC;IACnC,CAAC;IAED,WAAW,CAAC,aAAqB;QAC/B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC;QACnC,MAAM,CAAC,GAAG,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAChE,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACpC,CAAC;IAED,OAAO;QACL,OAAO,MAAM,CAAC,OAAO,EAAE,CAAC;IAC1B,CAAC;;+GAnMU,iBAAiB;mHAAjB,iBAAiB;4FAAjB,iBAAiB;kBAD7B,UAAU","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { DateAdapter } from '@angular/material/core';\r\nimport { isMoment, Moment } from 'moment';\r\nimport moment from 'moment-es6';\r\n\r\n@Injectable()\r\nexport class MomentDateAdapter extends DateAdapter<Moment> {\r\n\r\n  private localeData: any = moment.localeData();\r\n\r\n  overrideDisplayFormat: string;\r\n\r\n  getYear(date: Moment): number {\r\n    return date.year();\r\n  }\r\n\r\n  getMonth(date: Moment): number {\r\n    return date.month();\r\n  }\r\n\r\n  getDate(date: Moment): number {\r\n    return date.date();\r\n  }\r\n\r\n  getDayOfWeek(date: Moment): number {\r\n    return date.day();\r\n  }\r\n\r\n  getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {\r\n    switch (style) {\r\n      case 'long':\r\n        return this.localeData.months();\r\n      case 'short':\r\n        return this.localeData.monthsShort();\r\n      case 'narrow':\r\n        return this.localeData.monthsShort().map((month) => month[0]);\r\n      default:\r\n        return [];\r\n    }\r\n  }\r\n\r\n  getDateNames(): string[] {\r\n    const dateNames: string[] = [];\r\n    for (let date = 1; date <= 31; date++) {\r\n      dateNames.push(String(date));\r\n    }\r\n\r\n    return dateNames;\r\n  }\r\n\r\n  getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {\r\n    switch (style) {\r\n      case 'long':\r\n        return this.localeData.weekdays();\r\n      case 'short':\r\n        return this.localeData.weekdaysShort();\r\n      case 'narrow':\r\n        return this.localeData.weekdaysShort();\r\n      default:\r\n        return [];\r\n    }\r\n  }\r\n\r\n  getYearName(date: Moment): string {\r\n    return String(date.year());\r\n  }\r\n\r\n  getFirstDayOfWeek(): number {\r\n    return this.localeData.firstDayOfWeek();\r\n  }\r\n\r\n  getNumDaysInMonth(date: Moment): number {\r\n    return date.daysInMonth();\r\n  }\r\n\r\n  clone(date: Moment): Moment {\r\n    const locale = this.locale || 'en';\r\n    return date.clone().locale(locale);\r\n  }\r\n\r\n  createDate(year: number, month: number, date: number): Moment {\r\n    return moment([year, month, date]);\r\n  }\r\n\r\n  today(): Moment {\r\n    const locale = this.locale || 'en';\r\n    return moment().locale(locale);\r\n  }\r\n\r\n  parse(value: any, parseFormat: any): Moment {\r\n    const locale = this.locale || 'en';\r\n\r\n    if (value && typeof value === 'string') {\r\n      let m = moment(value, parseFormat, locale, true);\r\n      if (!m.isValid()) {\r\n        // use strict parsing because Moment's parser is very forgiving, and this can lead to undesired behavior.\r\n        m = moment(value, this.overrideDisplayFormat, locale, true);\r\n      }\r\n      if (m.isValid()) {\r\n        // if user omits year, it defaults to 2001, so check for that issue.\r\n        if (m.year() === 2001 && value.indexOf('2001') === -1) {\r\n          // if 2001 not actually in the value string, change to current year\r\n          const currentYear = new Date().getFullYear();\r\n          m.set('year', currentYear);\r\n          // if date is in the future, set previous year\r\n          if (m.isAfter(moment())) {\r\n            m.set('year', currentYear - 1);\r\n          }\r\n        }\r\n      }\r\n      return m;\r\n    }\r\n\r\n    return value ? moment(value).locale(locale) : null;\r\n  }\r\n\r\n  format(date: Moment, displayFormat: any): string {\r\n    date = this.clone(date);\r\n    displayFormat = this.overrideDisplayFormat ? this.overrideDisplayFormat : displayFormat;\r\n\r\n    if (date && date.format) {\r\n      return date.format(displayFormat);\r\n    } else {\r\n      return '';\r\n    }\r\n  }\r\n\r\n  addCalendarYears(date: Moment, years: number): Moment {\r\n    return date.clone().add(years, 'y');\r\n  }\r\n\r\n  addCalendarMonths(date: Moment, months: number): Moment {\r\n    return date.clone().add(months, 'M');\r\n  }\r\n\r\n  addCalendarDays(date: Moment, days: number): Moment {\r\n    return date.clone().add(days, 'd');\r\n  }\r\n\r\n  getISODateString(date: Moment): string {\r\n    return date.toISOString();\r\n  }\r\n\r\n  setLocale(locale: any): void {\r\n    super.setLocale(locale);\r\n\r\n    this.localeData = moment.localeData(locale);\r\n  }\r\n\r\n  compareDate(first: Moment, second: Moment): number {\r\n    return first.diff(second, 'seconds', true);\r\n  }\r\n\r\n  sameDate(first: any | Moment, second: any | Moment): boolean {\r\n    if (first == null) {\r\n      // same if both null\r\n      return second == null;\r\n    } else if (isMoment(first)) {\r\n      return first.isSame(second);\r\n    } else {\r\n      const isSame = super.sameDate(first, second);\r\n      return isSame;\r\n    }\r\n  }\r\n\r\n  clampDate(date: Moment, min?: any | Moment, max?: any | Moment): Moment {\r\n    if (min && date.isBefore(min)) {\r\n      return min;\r\n    } else if (max && date.isAfter(max)) {\r\n      return max;\r\n    } else {\r\n      return date;\r\n    }\r\n  }\r\n\r\n  isDateInstance(date: any) {\r\n    let isValidDateInstance = false;\r\n\r\n    if (date) {\r\n      isValidDateInstance = date._isAMomentObject;\r\n    }\r\n\r\n    return isValidDateInstance;\r\n  }\r\n\r\n  isValid(date: Moment): boolean {\r\n    return date.isValid();\r\n  }\r\n\r\n  toIso8601(date: Moment): string {\r\n    return this.clone(date).format();\r\n  }\r\n\r\n  fromIso8601(iso8601String: string): Moment | null {\r\n    const locale = this.locale || 'en';\r\n    const d = moment(iso8601String, moment.ISO_8601).locale(locale);\r\n    return this.isValid(d) ? d : null;\r\n  }\r\n\r\n  invalid(): Moment {\r\n    return moment.invalid();\r\n  }\r\n}\r\n"]}