@alfresco/adf-core 8.1.0-16295248176 → 8.1.0-16342534841

package/esm2022/lib/common/services/user-preferences.service.mjs

@@ -0,0 +1,238 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { inject, Injectable, RendererFactory2 } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject } from 'rxjs';
+import { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';
+import { StorageService } from './storage.service';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { DOCUMENT } from '@angular/common';
+import { Directionality } from '@angular/cdk/bidi';
+import { DEFAULT_LANGUAGE_LIST } from '../models/default-languages.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+import * as i2 from "../../app-config/app-config.service";
+import * as i3 from "./storage.service";
+// eslint-disable-next-line no-shadow
+export var UserPreferenceValues;
+(function (UserPreferenceValues) {
+    UserPreferenceValues["PaginationSize"] = "paginationSize";
+    UserPreferenceValues["Locale"] = "locale";
+    UserPreferenceValues["SupportedPageSizes"] = "supportedPageSizes";
+    UserPreferenceValues["ExpandedSideNavStatus"] = "expandedSidenav";
+})(UserPreferenceValues || (UserPreferenceValues = {}));
+export class UserPreferencesService {
+    constructor(translate, appConfig, storage) {
+        this.translate = translate;
+        this.appConfig = appConfig;
+        this.storage = storage;
+        this.document = inject(DOCUMENT);
+        this.rendererFactory = inject(RendererFactory2);
+        this.directionality = inject(Directionality);
+        this.defaults = {
+            paginationSize: 25,
+            supportedPageSizes: [5, 10, 15, 20],
+            locale: 'en',
+            expandedSidenav: true
+        };
+        this.userPreferenceStatus = this.defaults;
+        this.onChangeSubject = new BehaviorSubject(this.userPreferenceStatus);
+        this.onChange = this.onChangeSubject.asObservable();
+        this.appConfig.onLoad.subscribe(() => {
+            this.initUserPreferenceStatus();
+        });
+        const renderer = this.rendererFactory.createRenderer(null, null);
+        this.select('textOrientation').subscribe((direction) => {
+            renderer.setAttribute(this.document.body, 'dir', direction);
+            this.directionality.value = direction;
+        });
+    }
+    initUserPreferenceStatus() {
+        this.initUserLanguage();
+        this.set(UserPreferenceValues.PaginationSize, this.paginationSize);
+        this.set(UserPreferenceValues.SupportedPageSizes, JSON.stringify(this.supportedPageSizes));
+    }
+    initUserLanguage() {
+        if (this.locale || this.appConfig.get(UserPreferenceValues.Locale)) {
+            const locale = this.locale || this.getDefaultLocale();
+            this.set(UserPreferenceValues.Locale, locale);
+            this.set('textOrientation', this.getLanguageByKey(locale).direction || 'ltr');
+        }
+        else {
+            const locale = this.locale || this.getDefaultLocale();
+            this.setWithoutStore(UserPreferenceValues.Locale, locale);
+            this.setWithoutStore('textOrientation', this.getLanguageByKey(locale).direction || '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 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), 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}`;
+    }
+    /**
+     * Gets an array containing the available page sizes.
+     *
+     * @returns Array of page size values
+     */
+    get supportedPageSizes() {
+        const supportedPageSizes = this.get(UserPreferenceValues.SupportedPageSizes);
+        if (supportedPageSizes) {
+            return JSON.parse(supportedPageSizes);
+        }
+        else {
+            return this.appConfig.get('pagination.supportedPageSizes', this.defaults.supportedPageSizes);
+        }
+    }
+    set supportedPageSizes(value) {
+        this.set(UserPreferenceValues.SupportedPageSizes, JSON.stringify(value));
+    }
+    /** Pagination size. */
+    set paginationSize(value) {
+        this.set(UserPreferenceValues.PaginationSize, value);
+    }
+    get paginationSize() {
+        const paginationSize = this.get(UserPreferenceValues.PaginationSize);
+        if (paginationSize) {
+            return Number(paginationSize);
+        }
+        else {
+            return Number(this.appConfig.get('pagination.size', this.defaults.paginationSize));
+        }
+    }
+    /**
+     * Current locale setting.
+     *
+     * @returns locale name
+     */
+    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.appConfig.get(UserPreferenceValues.Locale) || this.translate.getBrowserCultureLang() || 'en';
+    }
+    getLanguageByKey(key) {
+        const defaultLanguage = { key: 'en' };
+        let language;
+        const customLanguages = this.appConfig.get(AppConfigValues.APP_CONFIG_LANGUAGES_KEY);
+        if (Array.isArray(customLanguages)) {
+            language = customLanguages.find((customLanguage) => key.includes(customLanguage.key));
+        }
+        language ??= DEFAULT_LANGUAGE_LIST.find((defaultLang) => defaultLang.key === key) ?? defaultLanguage;
+        return language;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserPreferencesService, deps: [{ token: i1.TranslateService }, { token: i2.AppConfigService }, { token: i3.StorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserPreferencesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UserPreferencesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.TranslateService }, { type: i2.AppConfigService }, { type: i3.StorageService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-preferences.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/common/services/user-preferences.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { inject, Injectable, RendererFactory2 } from '@angular/core';\nimport { TranslateService } from '@ngx-translate/core';\nimport { Observable, BehaviorSubject } from 'rxjs';\nimport { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';\nimport { StorageService } from './storage.service';\nimport { distinctUntilChanged, map } from 'rxjs/operators';\nimport { LanguageItem } from './language-item.interface';\nimport { DOCUMENT } from '@angular/common';\nimport { Directionality, Direction } from '@angular/cdk/bidi';\nimport { DEFAULT_LANGUAGE_LIST } from '../models/default-languages.model';\n\n// eslint-disable-next-line no-shadow\nexport enum UserPreferenceValues {\n    PaginationSize = 'paginationSize',\n    Locale = 'locale',\n    SupportedPageSizes = 'supportedPageSizes',\n    ExpandedSideNavStatus = 'expandedSidenav'\n}\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class UserPreferencesService {\n    private document = inject(DOCUMENT);\n    private rendererFactory = inject(RendererFactory2);\n    private directionality = inject(Directionality);\n\n    defaults = {\n        paginationSize: 25,\n        supportedPageSizes: [5, 10, 15, 20],\n        locale: 'en',\n        expandedSidenav: true\n    };\n\n    private userPreferenceStatus: any = this.defaults;\n    private onChangeSubject: BehaviorSubject<any>;\n    onChange: Observable<any>;\n\n    constructor(public translate: TranslateService, private appConfig: AppConfigService, private storage: StorageService) {\n        this.onChangeSubject = new BehaviorSubject(this.userPreferenceStatus);\n        this.onChange = this.onChangeSubject.asObservable();\n\n        this.appConfig.onLoad.subscribe(() => {\n            this.initUserPreferenceStatus();\n        });\n\n        const renderer = this.rendererFactory.createRenderer(null, null);\n\n        this.select('textOrientation').subscribe((direction: Direction) => {\n            renderer.setAttribute(this.document.body, 'dir', direction);\n            (this.directionality as any).value = direction;\n        });\n    }\n\n    private initUserPreferenceStatus() {\n        this.initUserLanguage();\n        this.set(UserPreferenceValues.PaginationSize, this.paginationSize);\n        this.set(UserPreferenceValues.SupportedPageSizes, JSON.stringify(this.supportedPageSizes));\n    }\n\n    private initUserLanguage() {\n        if (this.locale || this.appConfig.get<string>(UserPreferenceValues.Locale)) {\n            const locale = this.locale || this.getDefaultLocale();\n\n            this.set(UserPreferenceValues.Locale, locale);\n            this.set('textOrientation', this.getLanguageByKey(locale).direction || 'ltr');\n        } else {\n            const locale = this.locale || this.getDefaultLocale();\n\n            this.setWithoutStore(UserPreferenceValues.Locale, locale);\n            this.setWithoutStore('textOrientation', this.getLanguageByKey(locale).direction || 'ltr');\n        }\n    }\n\n    /**\n     * Sets up a callback to notify when a property has changed.\n     *\n     * @param property The property to watch\n     * @returns Notification callback\n     */\n    select<T = any>(property: string): Observable<T> {\n        return this.onChange.pipe(\n            map((userPreferenceStatus) => userPreferenceStatus[property]),\n            distinctUntilChanged()\n        );\n    }\n\n    /**\n     * Gets a preference property.\n     *\n     * @param property Name of the property\n     * @param defaultValue Default to return if the property is not found\n     * @returns Preference property\n     */\n    get(property: string, defaultValue?: string): string {\n        const key = this.getPropertyKey(property);\n        const value = this.storage.getItem(key);\n        if (value === undefined || value === null) {\n            return defaultValue;\n        }\n        return value;\n    }\n\n    /**\n     * Sets a preference property.\n     *\n     * @param property Name of the property\n     * @param value New value for the property\n     */\n    set(property: string, value: any) {\n        if (!property) {\n            return;\n        }\n        this.storage.setItem(this.getPropertyKey(property), value);\n        this.userPreferenceStatus[property] = value;\n        this.onChangeSubject.next(this.userPreferenceStatus);\n    }\n\n    /**\n     * Sets a preference property.\n     *\n     * @param property Name of the property\n     * @param value New value for the property\n     */\n    setWithoutStore(property: string, value: any) {\n        if (!property) {\n            return;\n        }\n        this.userPreferenceStatus[property] = value;\n        this.onChangeSubject.next(this.userPreferenceStatus);\n    }\n\n    /**\n     * Check if an item is present in the storage\n     *\n     * @param property Name of the property\n     * @returns True if the item is present, false otherwise\n     */\n    hasItem(property: string): boolean {\n        if (!property) {\n            return false;\n        }\n        return this.storage.hasItem(this.getPropertyKey(property));\n    }\n\n    /**\n     * Gets the active storage prefix for preferences.\n     *\n     * @returns Storage prefix\n     */\n    getStoragePrefix(): string {\n        return this.storage.getItem('USER_PROFILE') || 'GUEST';\n    }\n\n    /**\n     * Sets the active storage prefix for preferences.\n     *\n     * @param value Name of the prefix\n     */\n    setStoragePrefix(value: string | null) {\n        this.storage.setItem('USER_PROFILE', value || 'GUEST');\n        this.initUserPreferenceStatus();\n    }\n\n    /**\n     * Gets the full property key with prefix.\n     *\n     * @param property The property name\n     * @returns Property key\n     */\n    getPropertyKey(property: string): string {\n        return `${this.getStoragePrefix()}__${property}`;\n    }\n\n    /**\n     * Gets an array containing the available page sizes.\n     *\n     * @returns Array of page size values\n     */\n    get supportedPageSizes(): number[] {\n        const supportedPageSizes = this.get(UserPreferenceValues.SupportedPageSizes);\n\n        if (supportedPageSizes) {\n            return JSON.parse(supportedPageSizes);\n        } else {\n            return this.appConfig.get('pagination.supportedPageSizes', this.defaults.supportedPageSizes);\n        }\n    }\n\n    set supportedPageSizes(value: number[]) {\n        this.set(UserPreferenceValues.SupportedPageSizes, JSON.stringify(value));\n    }\n\n    /** Pagination size. */\n    set paginationSize(value: number) {\n        this.set(UserPreferenceValues.PaginationSize, value);\n    }\n\n    get paginationSize(): number {\n        const paginationSize = this.get(UserPreferenceValues.PaginationSize);\n\n        if (paginationSize) {\n            return Number(paginationSize);\n        } else {\n            return Number(this.appConfig.get('pagination.size', this.defaults.paginationSize));\n        }\n    }\n\n    /**\n     * Current locale setting.\n     *\n     * @returns locale name\n     */\n    get locale(): string {\n        return this.get(UserPreferenceValues.Locale);\n    }\n\n    set locale(value: string) {\n        this.set(UserPreferenceValues.Locale, value);\n    }\n\n    /**\n     * Gets the default locale.\n     *\n     * @returns Default locale language code\n     */\n    getDefaultLocale(): string {\n        return this.appConfig.get<string>(UserPreferenceValues.Locale) || this.translate.getBrowserCultureLang() || 'en';\n    }\n\n    private getLanguageByKey(key: string): LanguageItem {\n        const defaultLanguage = { key: 'en' } as LanguageItem;\n        let language: LanguageItem;\n\n        const customLanguages = this.appConfig.get<Array<LanguageItem>>(AppConfigValues.APP_CONFIG_LANGUAGES_KEY);\n        if (Array.isArray(customLanguages)) {\n            language = customLanguages.find((customLanguage) => key.includes(customLanguage.key));\n        }\n        language ??= DEFAULT_LANGUAGE_LIST.find((defaultLang) => defaultLang.key === key) ?? defaultLanguage;\n        return language;\n    }\n}\n"]}

package/esm2022/lib/common/utils/date-fns-adapter.mjs

@@ -0,0 +1,115 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { DateFnsAdapter } from '@angular/material-date-fns-adapter';
+import { DateFnsUtils } from './date-fns-utils';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { MAT_DATE_FORMATS, MAT_DATE_LOCALE } from '@angular/material/core';
+import { UserPreferenceValues, UserPreferencesService } from '../services/user-preferences.service';
+import { isValid, parse } from 'date-fns';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/user-preferences.service";
+/**
+ * Date-fns adapter with moment-to-date-fns conversion.
+ *
+ * Automatically switches locales based on user preferences.
+ * Supports custom display format.
+ *
+ * @example
+ *
+ * Add the following to the component `providers` section
+ *
+ * providers: [
+ *  { provide: MAT_DATE_FORMATS, useValue: ADF_FORM_DATE_FORMATS },
+ *  { provide: DateAdapter, useClass: AdfDateFnsAdapter }
+ * ]
+ *
+ * Setting custom format
+ *
+ * constructor(private dateAdapter: DateAdapter<Date>) {}
+ *
+ * ngOnInit() {
+ *   const adapter = this.dateAdapter as AdfDateFnsAdapter;
+     adapter.displayFormat = '<custom date-fns format>';
+ * }
+ */
+export const DEFAULT_DATE_FORMAT = 'dd-MM-yyyy';
+/**
+ * Material date formats for Date-fns
+ */
+export const ADF_DATE_FORMATS = {
+    parse: {
+        dateInput: DEFAULT_DATE_FORMAT
+    },
+    display: {
+        dateInput: DEFAULT_DATE_FORMAT,
+        monthLabel: 'LLL',
+        monthYearLabel: 'LLL uuuu',
+        dateA11yLabel: 'PP',
+        monthYearA11yLabel: 'LLLL uuuu'
+    }
+};
+export class AdfDateFnsAdapter extends DateFnsAdapter {
+    get displayFormat() {
+        return this._displayFormat;
+    }
+    set displayFormat(value) {
+        this._displayFormat = value ? DateFnsUtils.convertMomentToDateFnsFormat(value) : null;
+    }
+    constructor(matDateLocale, formats, preferences) {
+        super(matDateLocale);
+        this.formats = formats;
+        this._displayFormat = null;
+        preferences.select(UserPreferenceValues.Locale).subscribe((locale) => {
+            this.setLocale(DateFnsUtils.getLocaleFromString(locale));
+        });
+    }
+    parse(value, parseFormat) {
+        const dateValue = this.isValid(value) ? value : this.parseAndValidateDate(value);
+        const format = Array.isArray(parseFormat)
+            ? parseFormat.map(DateFnsUtils.convertMomentToDateFnsFormat)
+            : DateFnsUtils.convertMomentToDateFnsFormat(parseFormat);
+        return super.parse(dateValue, format);
+    }
+    format(date, displayFormat) {
+        displayFormat = DateFnsUtils.convertMomentToDateFnsFormat(displayFormat);
+        if (this.displayFormat && displayFormat === this.formats?.display?.dateInput) {
+            return super.format(date, this.displayFormat || displayFormat);
+        }
+        return super.format(date, displayFormat);
+    }
+    parseAndValidateDate(value) {
+        const parsedDate = parse(value, this.displayFormat || DEFAULT_DATE_FORMAT, new Date());
+        return isValid(parsedDate) ? parsedDate : value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AdfDateFnsAdapter, deps: [{ token: MAT_DATE_LOCALE, optional: true }, { token: MAT_DATE_FORMATS, optional: true }, { token: i1.UserPreferencesService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AdfDateFnsAdapter, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AdfDateFnsAdapter, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAT_DATE_LOCALE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [MAT_DATE_FORMATS]
+                }] }, { type: i1.UserPreferencesService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-fns-adapter.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/common/utils/date-fns-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { DateFnsAdapter } from '@angular/material-date-fns-adapter';\nimport { DateFnsUtils } from './date-fns-utils';\nimport { Inject, Injectable, Optional } from '@angular/core';\nimport { MAT_DATE_FORMATS, MAT_DATE_LOCALE, MatDateFormats } from '@angular/material/core';\nimport { UserPreferenceValues, UserPreferencesService } from '../services/user-preferences.service';\nimport { isValid, Locale, parse } from 'date-fns';\n\n/**\n * Date-fns adapter with moment-to-date-fns conversion.\n *\n * Automatically switches locales based on user preferences.\n * Supports custom display format.\n *\n * @example\n *\n * Add the following to the component `providers` section\n *\n * providers: [\n *  { provide: MAT_DATE_FORMATS, useValue: ADF_FORM_DATE_FORMATS },\n *  { provide: DateAdapter, useClass: AdfDateFnsAdapter }\n * ]\n *\n * Setting custom format\n *\n * constructor(private dateAdapter: DateAdapter<Date>) {}\n *\n * ngOnInit() {\n *   const adapter = this.dateAdapter as AdfDateFnsAdapter;\n     adapter.displayFormat = '<custom date-fns format>';\n * }\n */\n\nexport const DEFAULT_DATE_FORMAT = 'dd-MM-yyyy';\n\n/**\n * Material date formats for Date-fns\n */\nexport const ADF_DATE_FORMATS: MatDateFormats = {\n    parse: {\n        dateInput: DEFAULT_DATE_FORMAT\n    },\n    display: {\n        dateInput: DEFAULT_DATE_FORMAT,\n        monthLabel: 'LLL',\n        monthYearLabel: 'LLL uuuu',\n        dateA11yLabel: 'PP',\n        monthYearA11yLabel: 'LLLL uuuu'\n    }\n};\n\n@Injectable({ providedIn: 'root' })\nexport class AdfDateFnsAdapter extends DateFnsAdapter {\n    private _displayFormat?: string = null;\n\n    get displayFormat(): string | null {\n        return this._displayFormat;\n    }\n\n    set displayFormat(value: string | null) {\n        this._displayFormat = value ? DateFnsUtils.convertMomentToDateFnsFormat(value) : null;\n    }\n\n    constructor(\n        @Optional() @Inject(MAT_DATE_LOCALE) matDateLocale: Locale,\n        @Optional() @Inject(MAT_DATE_FORMATS) private formats: MatDateFormats,\n        preferences: UserPreferencesService\n    ) {\n        super(matDateLocale);\n\n        preferences.select(UserPreferenceValues.Locale).subscribe((locale: string) => {\n            this.setLocale(DateFnsUtils.getLocaleFromString(locale));\n        });\n    }\n\n    override parse(value: any, parseFormat: string | string[]): Date {\n        const dateValue = this.isValid(value) ? value : this.parseAndValidateDate(value);\n        const format = Array.isArray(parseFormat)\n            ? parseFormat.map(DateFnsUtils.convertMomentToDateFnsFormat)\n            : DateFnsUtils.convertMomentToDateFnsFormat(parseFormat);\n        return super.parse(dateValue, format);\n    }\n\n    override format(date: Date, displayFormat: string): string {\n        displayFormat = DateFnsUtils.convertMomentToDateFnsFormat(displayFormat);\n\n        if (this.displayFormat && displayFormat === this.formats?.display?.dateInput) {\n            return super.format(date, this.displayFormat || displayFormat);\n        }\n\n        return super.format(date, displayFormat);\n    }\n\n    private parseAndValidateDate(value: any): Date {\n        const parsedDate = parse(value, this.displayFormat || DEFAULT_DATE_FORMAT, new Date());\n        return isValid(parsedDate) ? parsedDate : value;\n    }\n}\n"]}

package/esm2022/lib/common/utils/date-fns-utils.mjs

@@ -0,0 +1,222 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { format, parse, parseISO, isValid, isBefore, isAfter } from 'date-fns';
+import { ar, cs, da, de, enUS, es, fi, fr, it, ja, nb, nl, pl, ptBR, ru, sv, zhCN } from 'date-fns/locale';
+const panDate = (num = 1) => {
+    let text = num.toString();
+    while (text.length < 2) {
+        text = '0' + text;
+    }
+    return text;
+};
+export class DateFnsUtils {
+    static getLocaleFromString(locale) {
+        let dateFnsLocale;
+        switch (locale) {
+            case 'ar':
+                dateFnsLocale = ar;
+                break;
+            case 'cs':
+                dateFnsLocale = cs;
+                break;
+            case 'da':
+                dateFnsLocale = da;
+                break;
+            case 'de':
+                dateFnsLocale = de;
+                break;
+            case 'en':
+                dateFnsLocale = enUS;
+                break;
+            case 'es':
+                dateFnsLocale = es;
+                break;
+            case 'fi':
+                dateFnsLocale = fi;
+                break;
+            case 'fr':
+                dateFnsLocale = fr;
+                break;
+            case 'it':
+                dateFnsLocale = it;
+                break;
+            case 'ja':
+                dateFnsLocale = ja;
+                break;
+            case 'nb':
+                dateFnsLocale = nb;
+                break;
+            case 'nl':
+                dateFnsLocale = nl;
+                break;
+            case 'pl':
+                dateFnsLocale = pl;
+                break;
+            case 'pt-BR':
+                dateFnsLocale = ptBR;
+                break;
+            case 'ru':
+                dateFnsLocale = ru;
+                break;
+            case 'sv':
+                dateFnsLocale = sv;
+                break;
+            case 'zh-CN':
+                dateFnsLocale = zhCN;
+                break;
+            default:
+                dateFnsLocale = enUS;
+                break;
+        }
+        return dateFnsLocale;
+    }
+    static { this.momentToDateFnsMap = {
+        D: 'd',
+        Y: 'y',
+        AZ: 'aa',
+        A: 'a',
+        ll: 'PP',
+        T: `'T'`,
+        ZZ: 'XX',
+        Z: `XXX`
+    }; }
+    /**
+     * Converts a Moment.js date format string to the equivalent date-fns format string.
+     *
+     * @param dateDisplayFormat - The Moment.js date format string to convert.
+     * @returns The equivalent date-fns format string.
+     */
+    static convertMomentToDateFnsFormat(dateDisplayFormat) {
+        if (dateDisplayFormat && dateDisplayFormat.trim() !== '') {
+            // normalise the input to support double conversion of the same string
+            dateDisplayFormat = dateDisplayFormat.replace(`'T'`, 'T');
+            for (const [search, replace] of Object.entries(this.momentToDateFnsMap)) {
+                dateDisplayFormat = dateDisplayFormat.replace(new RegExp(search, 'g'), replace);
+            }
+            return dateDisplayFormat;
+        }
+        return '';
+    }
+    /**
+     * Formats a date using the specified date format.
+     *
+     * @param date - The date to format, can be a number or a Date object.
+     * @param dateFormat - The date format string to use for formatting.
+     * @returns The formatted date as a string
+     */
+    static formatDate(date, dateFormat) {
+        if (typeof date === 'string') {
+            date = parseISO(date);
+        }
+        return format(date, this.convertMomentToDateFnsFormat(dateFormat));
+    }
+    /**
+     * Parses a date string using the specified date format.
+     *
+     * @param value - The date value to parse. Can be a string or a Date (for generic calls)
+     * @param dateFormat - The date format string to use for parsing.
+     * @param options - Additional options
+     * @param options.dateOnly - Strip the time and zone
+     * @returns The parsed Date object.
+     */
+    static parseDate(value, dateFormat, options) {
+        if (value) {
+            if (typeof value === 'string') {
+                if (options?.dateOnly && value.includes('T')) {
+                    value = value.split('T')[0];
+                }
+                return parse(value, this.convertMomentToDateFnsFormat(dateFormat), new Date());
+            }
+            return value;
+        }
+        return new Date('error');
+    }
+    /**
+     * Parses a datetime string using the ISO format
+     *
+     * @param value - The date and time string to parse
+     * @returns returns the parsed Date object
+     */
+    static parseDateTime(value) {
+        return parseISO(value);
+    }
+    /**
+     * Checks if the date string is a valid date according to the specified format
+     *
+     * @param dateValue Date value
+     * @param dateFormat The date format
+     * @returns `true` if the date is valid, otherwise `false`
+     */
+    static isValidDate(dateValue, dateFormat) {
+        if (dateValue) {
+            const date = this.parseDate(dateValue, dateFormat);
+            return isValid(date);
+        }
+        return false;
+    }
+    /**
+     * Validates a date is before another one
+     *
+     * @param source source date to compare
+     * @param target target date to compare
+     * @returns `true` if the source date is before the target one, otherwise `false`
+     */
+    static isBeforeDate(source, target) {
+        return isBefore(source, target);
+    }
+    /**
+     * Validates a date is after another one
+     *
+     * @param source source date to compare
+     * @param target target date to compare
+     * @returns `true` if the source date is after the target one, otherwise `false`
+     */
+    static isAfterDate(source, target) {
+        return isAfter(source, target);
+    }
+    static utcToLocal(date) {
+        return new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds()));
+    }
+    static localToUtc(date) {
+        return new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds());
+    }
+    static forceLocal(date) {
+        if (typeof date === 'string') {
+            date = parseISO(date);
+        }
+        const localDate = `${date.getUTCFullYear()}-${panDate(date.getUTCMonth() + 1)}-${panDate(date.getUTCDate())}T00:00:00.000`;
+        return new Date(localDate);
+    }
+    static forceUtc(date) {
+        if (typeof date === 'string') {
+            date = parseISO(date);
+        }
+        const utcDate = `${date.getFullYear()}-${panDate(date.getMonth() + 1)}-${panDate(date.getDate())}T00:00:00.000Z`;
+        return new Date(utcDate);
+    }
+    static stringDateContainsTimeZone(value) {
+        return /(Z|([+|-]\d\d:?\d\d))$/.test(value);
+    }
+    static getDate(value) {
+        let date = new Date(value);
+        if (typeof value === 'string' && !DateFnsUtils.stringDateContainsTimeZone(value)) {
+            date = this.utcToLocal(date);
+        }
+        return date;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-fns-utils.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/common/utils/date-fns-utils.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { format, parse, parseISO, isValid, isBefore, isAfter } from 'date-fns';\nimport { ar, cs, da, de, enUS, es, fi, fr, it, ja, nb, nl, pl, ptBR, ru, sv, zhCN } from 'date-fns/locale';\n\nconst panDate = (num: number = 1): string => {\n    let text = num.toString();\n    while (text.length < 2) {\n        text = '0' + text;\n    }\n    return text;\n};\n\nexport class DateFnsUtils {\n    static getLocaleFromString(locale: string): Locale {\n        let dateFnsLocale: Locale;\n        switch (locale) {\n            case 'ar':\n                dateFnsLocale = ar;\n                break;\n            case 'cs':\n                dateFnsLocale = cs;\n                break;\n            case 'da':\n                dateFnsLocale = da;\n                break;\n            case 'de':\n                dateFnsLocale = de;\n                break;\n            case 'en':\n                dateFnsLocale = enUS;\n                break;\n            case 'es':\n                dateFnsLocale = es;\n                break;\n            case 'fi':\n                dateFnsLocale = fi;\n                break;\n            case 'fr':\n                dateFnsLocale = fr;\n                break;\n            case 'it':\n                dateFnsLocale = it;\n                break;\n            case 'ja':\n                dateFnsLocale = ja;\n                break;\n            case 'nb':\n                dateFnsLocale = nb;\n                break;\n            case 'nl':\n                dateFnsLocale = nl;\n                break;\n            case 'pl':\n                dateFnsLocale = pl;\n                break;\n            case 'pt-BR':\n                dateFnsLocale = ptBR;\n                break;\n            case 'ru':\n                dateFnsLocale = ru;\n                break;\n            case 'sv':\n                dateFnsLocale = sv;\n                break;\n            case 'zh-CN':\n                dateFnsLocale = zhCN;\n                break;\n            default:\n                dateFnsLocale = enUS;\n                break;\n        }\n        return dateFnsLocale;\n    }\n\n    private static momentToDateFnsMap = {\n        D: 'd',\n        Y: 'y',\n        AZ: 'aa',\n        A: 'a',\n        ll: 'PP',\n        T: `'T'`,\n        ZZ: 'XX',\n        Z: `XXX`\n    };\n\n    /**\n     * Converts a Moment.js date format string to the equivalent date-fns format string.\n     *\n     * @param dateDisplayFormat - The Moment.js date format string to convert.\n     * @returns The equivalent date-fns format string.\n     */\n    static convertMomentToDateFnsFormat(dateDisplayFormat: string): string {\n        if (dateDisplayFormat && dateDisplayFormat.trim() !== '') {\n            // normalise the input to support double conversion of the same string\n            dateDisplayFormat = dateDisplayFormat.replace(`'T'`, 'T');\n\n            for (const [search, replace] of Object.entries(this.momentToDateFnsMap)) {\n                dateDisplayFormat = dateDisplayFormat.replace(new RegExp(search, 'g'), replace);\n            }\n            return dateDisplayFormat;\n        }\n        return '';\n    }\n\n    /**\n     * Formats a date using the specified date format.\n     *\n     * @param date - The date to format, can be a number or a Date object.\n     * @param dateFormat - The date format string to use for formatting.\n     * @returns The formatted date as a string\n     */\n    static formatDate(date: number | Date | string, dateFormat: string): string {\n        if (typeof date === 'string') {\n            date = parseISO(date);\n        }\n        return format(date, this.convertMomentToDateFnsFormat(dateFormat));\n    }\n\n    /**\n     * Parses a date string using the specified date format.\n     *\n     * @param value - The date value to parse. Can be a string or a Date (for generic calls)\n     * @param dateFormat - The date format string to use for parsing.\n     * @param options - Additional options\n     * @param options.dateOnly - Strip the time and zone\n     * @returns The parsed Date object.\n     */\n    static parseDate(value: string | Date, dateFormat: string, options?: { dateOnly?: boolean }): Date {\n        if (value) {\n            if (typeof value === 'string') {\n                if (options?.dateOnly && value.includes('T')) {\n                    value = value.split('T')[0];\n                }\n\n                return parse(value, this.convertMomentToDateFnsFormat(dateFormat), new Date());\n            }\n            return value;\n        }\n        return new Date('error');\n    }\n\n    /**\n     * Parses a datetime string using the ISO format\n     *\n     * @param value - The date and time string to parse\n     * @returns returns the parsed Date object\n     */\n    static parseDateTime(value: string): Date {\n        return parseISO(value);\n    }\n\n    /**\n     * Checks if the date string is a valid date according to the specified format\n     *\n     * @param dateValue Date value\n     * @param dateFormat The date format\n     * @returns `true` if the date is valid, otherwise `false`\n     */\n    static isValidDate(dateValue: string, dateFormat: string): boolean {\n        if (dateValue) {\n            const date = this.parseDate(dateValue, dateFormat);\n            return isValid(date);\n        }\n        return false;\n    }\n\n    /**\n     * Validates a date is before another one\n     *\n     * @param source source date to compare\n     * @param target target date to compare\n     * @returns `true` if the source date is before the target one, otherwise `false`\n     */\n    static isBeforeDate(source: Date, target: Date): boolean {\n        return isBefore(source, target);\n    }\n\n    /**\n     * Validates a date is after another one\n     *\n     * @param source source date to compare\n     * @param target target date to compare\n     * @returns `true` if the source date is after the target one, otherwise `false`\n     */\n    static isAfterDate(source: Date, target: Date): boolean {\n        return isAfter(source, target);\n    }\n\n    static utcToLocal(date: Date): Date {\n        return new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds()));\n    }\n\n    static localToUtc(date: Date): Date {\n        return new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds());\n    }\n\n    static forceLocal(date: Date | string): Date {\n        if (typeof date === 'string') {\n            date = parseISO(date);\n        }\n        const localDate = `${date.getUTCFullYear()}-${panDate(date.getUTCMonth() + 1)}-${panDate(date.getUTCDate())}T00:00:00.000`;\n        return new Date(localDate);\n    }\n\n    static forceUtc(date: Date | string): Date {\n        if (typeof date === 'string') {\n            date = parseISO(date);\n        }\n        const utcDate = `${date.getFullYear()}-${panDate(date.getMonth() + 1)}-${panDate(date.getDate())}T00:00:00.000Z`;\n        return new Date(utcDate);\n    }\n\n    static stringDateContainsTimeZone(value: string): boolean {\n        return /(Z|([+|-]\\d\\d:?\\d\\d))$/.test(value);\n    }\n\n    static getDate(value: string | number | Date): Date {\n        let date = new Date(value);\n\n        if (typeof value === 'string' && !DateFnsUtils.stringDateContainsTimeZone(value)) {\n            date = this.utcToLocal(date);\n        }\n\n        return date;\n    }\n}\n"]}